117 files changed, 6098 insertions, 1672 deletions

diff --git a/drivers/message/fusion/mptbase.h b/drivers/message/fusion/mptbase.h
index 1735c84ff757..fe902338539b 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.18"
-#define MPT_LINUX_PACKAGE_NAME          "@(#)mptlinux-3.04.18"
+#define MPT_LINUX_VERSION_COMMON        "3.04.19"
+#define MPT_LINUX_PACKAGE_NAME          "@(#)mptlinux-3.04.19"
 #define WHAT_MAGIC_STRING               "@" "(" "#" ")"
 
 #define show_mptmod_ver(s,ver)  \
diff --git a/drivers/message/fusion/mptsas.c b/drivers/message/fusion/mptsas.c
index 66f94125de4e..7596aecd5072 100644
--- a/drivers/message/fusion/mptsas.c
+++ b/drivers/message/fusion/mptsas.c
@@ -5012,7 +5012,6 @@ mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
                         (ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)) {
                         VirtTarget *vtarget = NULL;
                         u8              id, channel;
-                        u32      log_info = le32_to_cpu(reply->IOCLogInfo);
 
                         id = sas_event_data->TargetID;
                         channel = sas_event_data->Bus;
@@ -5023,7 +5022,8 @@ mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
                                     "LogInfo (0x%x) available for "
                                    "INTERNAL_DEVICE_RESET"
                                    "fw_id %d fw_channel %d\n", ioc->name,
-                                   log_info, id, channel));
+                                   le32_to_cpu(reply->IOCLogInfo),
+                                   id, channel));
                                 if (vtarget->raidVolume) {
                                         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
                                         "Skipping Raid Volume for inDMD\n",
diff --git a/drivers/message/fusion/mptscsih.c b/drivers/message/fusion/mptscsih.c
index 0d9b82a44540..a1d4ee6671be 100644
--- a/drivers/message/fusion/mptscsih.c
+++ b/drivers/message/fusion/mptscsih.c
@@ -1415,11 +1415,8 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
         dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "qcmd: SCpnt=%p, done()=%p\n",
                 ioc->name, SCpnt, done));
 
-        if (ioc->taskmgmt_quiesce_io) {
-                dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "qcmd: SCpnt=%p timeout + 60HZ\n",
-                        ioc->name, SCpnt));
+        if (ioc->taskmgmt_quiesce_io)
                 return SCSI_MLQUEUE_HOST_BUSY;
-        }
 
         /*
          *  Put together a MPT SCSI request...
@@ -1773,7 +1770,6 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
         int              scpnt_idx;
         int              retval;
         VirtDevice       *vdevice;
-        ulong            sn = SCpnt->serial_number;
         MPT_ADAPTER     *ioc;
 
         /* If we can't locate our host adapter structure, return FAILED status.
@@ -1859,8 +1855,7 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
                          vdevice->vtarget->id, vdevice->lun,
                          ctx2abort, mptscsih_get_tm_timeout(ioc));
 
-        if (SCPNT_TO_LOOKUP_IDX(ioc, SCpnt) == scpnt_idx &&
-            SCpnt->serial_number == sn) {
+        if (SCPNT_TO_LOOKUP_IDX(ioc, SCpnt) == scpnt_idx) {
                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
                     "task abort: command still in active list! (sc=%p)\n",
                     ioc->name, SCpnt));
@@ -1873,9 +1868,9 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
         }
 
  out:
-        printk(MYIOC_s_INFO_FMT "task abort: %s (rv=%04x) (sc=%p) (sn=%ld)\n",
+        printk(MYIOC_s_INFO_FMT "task abort: %s (rv=%04x) (sc=%p)\n",
             ioc->name, ((retval == SUCCESS) ? "SUCCESS" : "FAILED"), retval,
-            SCpnt, SCpnt->serial_number);
+            SCpnt);
 
         return retval;
 }
diff --git a/drivers/message/fusion/mptspi.c b/drivers/message/fusion/mptspi.c
index 6d9568d2ec59..8f61ba6aac23 100644
--- a/drivers/message/fusion/mptspi.c
+++ b/drivers/message/fusion/mptspi.c
@@ -867,6 +867,10 @@ static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
         struct _x_config_parms cfg;
         struct _CONFIG_PAGE_HEADER hdr;
         int err = -EBUSY;
+        u32 nego_parms;
+        u32 period;
+        struct scsi_device *sdev;
+        int i;
 
         /* don't allow updating nego parameters on RAID devices */
         if (starget->channel == 0 &&
@@ -904,6 +908,24 @@ static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
         pg1->Header.PageNumber = hdr.PageNumber;
         pg1->Header.PageType = hdr.PageType;
 
+        nego_parms = le32_to_cpu(pg1->RequestedParameters);
+        period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >>
+                MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD;
+        if (period == 8) {
+                /* Turn on inline data padding for TAPE when running U320 */
+                for (i = 0 ; i < 16; i++) {
+                        sdev = scsi_device_lookup_by_target(starget, i);
+                        if (sdev && sdev->type == TYPE_TAPE) {
+                                sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT
+                                            "IDP:ON\n", ioc->name);
+                                nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP;
+                                pg1->RequestedParameters =
+                                    cpu_to_le32(nego_parms);
+                                break;
+                        }
+                }
+        }
+
         mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
 
         if (mpt_config(ioc, &cfg)) {
diff --git a/drivers/message/i2o/i2o_scsi.c b/drivers/message/i2o/i2o_scsi.c
index f003957e8e1c..74fbe56321ff 100644
--- a/drivers/message/i2o/i2o_scsi.c
+++ b/drivers/message/i2o/i2o_scsi.c
@@ -361,7 +361,7 @@ static int i2o_scsi_reply(struct i2o_controller *c, u32 m,
          */
         error = le32_to_cpu(msg->body[0]);
 
-        osm_debug("Completed %ld\n", cmd->serial_number);
+        osm_debug("Completed %0x%p\n", cmd);
 
         cmd->result = error & 0xff;
         /*
@@ -678,7 +678,7 @@ static int i2o_scsi_queuecommand_lck(struct scsi_cmnd *SCpnt,
         /* Queue the message */
         i2o_msg_post(c, msg);
 
-        osm_debug("Issued %ld\n", SCpnt->serial_number);
+        osm_debug("Issued %0x%p\n", SCpnt);
 
         return 0;
 
diff --git a/drivers/scsi/arcmsr/arcmsr_hba.c b/drivers/scsi/arcmsr/arcmsr_hba.c
index da7b9887ec48..f980600f78a8 100644
--- a/drivers/scsi/arcmsr/arcmsr_hba.c
+++ b/drivers/scsi/arcmsr/arcmsr_hba.c
@@ -75,8 +75,10 @@ MODULE_AUTHOR("Nick Cheng <support@areca.com.tw>");
 MODULE_DESCRIPTION("ARECA (ARC11xx/12xx/16xx/1880) SATA/SAS RAID Host Bus Adapter");
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_VERSION(ARCMSR_DRIVER_VERSION);
-static int sleeptime = 10;
-static int retrycount = 12;
+
+#define ARCMSR_SLEEPTIME        10
+#define ARCMSR_RETRYCOUNT       12
+
 wait_queue_head_t wait_q;
 static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb,
                                         struct scsi_cmnd *cmd);
@@ -171,24 +173,6 @@ static struct pci_driver arcmsr_pci_driver = {
 ****************************************************************************
 ****************************************************************************
 */
-int arcmsr_sleep_for_bus_reset(struct scsi_cmnd *cmd)
-{
-                struct Scsi_Host *shost = NULL;
-                int i, isleep;
-                shost = cmd->device->host;
-                isleep = sleeptime / 10;
-                if (isleep > 0) {
-                        for (i = 0; i < isleep; i++) {
-                                msleep(10000);
-                        }
-                }
-
-                isleep = sleeptime % 10;
-                if (isleep > 0) {
-                        msleep(isleep*1000);
-                }
-                return 0;
-}
 
 static void arcmsr_free_hbb_mu(struct AdapterControlBlock *acb)
 {
@@ -323,66 +307,64 @@ static void arcmsr_define_adapter_type(struct AdapterControlBlock *acb)
 
         default: acb->adapter_type = ACB_ADAPTER_TYPE_A;
         }
-}       
+}
 
 static uint8_t arcmsr_hba_wait_msgint_ready(struct AdapterControlBlock *acb)
 {
         struct MessageUnit_A __iomem *reg = acb->pmuA;
-        uint32_t Index;
-        uint8_t Retries = 0x00;
-        do {
-                for (Index = 0; Index < 100; Index++) {
-                        if (readl(&reg->outbound_intstatus) &
-                                        ARCMSR_MU_OUTBOUND_MESSAGE0_INT) {
-                                writel(ARCMSR_MU_OUTBOUND_MESSAGE0_INT,
-                                        &reg->outbound_intstatus);
-                                return true;
-                        }
-                        msleep(10);
-                }/*max 1 seconds*/
+        int i;
+
+        for (i = 0; i < 2000; i++) {
+                if (readl(&reg->outbound_intstatus) &
+                                ARCMSR_MU_OUTBOUND_MESSAGE0_INT) {
+                        writel(ARCMSR_MU_OUTBOUND_MESSAGE0_INT,
+                                &reg->outbound_intstatus);
+                        return true;
+                }
+                msleep(10);
+        } /* max 20 seconds */
 
-        } while (Retries++ < 20);/*max 20 sec*/
         return false;
 }
 
 static uint8_t arcmsr_hbb_wait_msgint_ready(struct AdapterControlBlock *acb)
 {
         struct MessageUnit_B *reg = acb->pmuB;
-        uint32_t Index;
-        uint8_t Retries = 0x00;
-        do {
-                for (Index = 0; Index < 100; Index++) {
-                        if (readl(reg->iop2drv_doorbell)
-                                & ARCMSR_IOP2DRV_MESSAGE_CMD_DONE) {
-                                writel(ARCMSR_MESSAGE_INT_CLEAR_PATTERN
-                                        , reg->iop2drv_doorbell);
-                                writel(ARCMSR_DRV2IOP_END_OF_INTERRUPT, reg->drv2iop_doorbell);
-                                return true;
-                        }
-                        msleep(10);
-                }/*max 1 seconds*/
+        int i;
+
+        for (i = 0; i < 2000; i++) {
+                if (readl(reg->iop2drv_doorbell)
+                        & ARCMSR_IOP2DRV_MESSAGE_CMD_DONE) {
+                        writel(ARCMSR_MESSAGE_INT_CLEAR_PATTERN,
+                                        reg->iop2drv_doorbell);
+                        writel(ARCMSR_DRV2IOP_END_OF_INTERRUPT,
+                                        reg->drv2iop_doorbell);
+                        return true;
+                }
+                msleep(10);
+        } /* max 20 seconds */
 
-        } while (Retries++ < 20);/*max 20 sec*/
         return false;
 }
 
 static uint8_t arcmsr_hbc_wait_msgint_ready(struct AdapterControlBlock *pACB)
 {
         struct MessageUnit_C *phbcmu = (struct MessageUnit_C *)pACB->pmuC;
-        unsigned char Retries = 0x00;
-        uint32_t Index;
-        do {
-                for (Index = 0; Index < 100; Index++) {
-                        if (readl(&phbcmu->outbound_doorbell) & ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE) {
-                                writel(ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE_DOORBELL_CLEAR, &phbcmu->outbound_doorbell_clear);/*clear interrupt*/
-                                return true;
-                        }
-                        /* one us delay */
-                        msleep(10);
-                } /*max 1 seconds*/
-        } while (Retries++ < 20); /*max 20 sec*/
+        int i;
+
+        for (i = 0; i < 2000; i++) {
+                if (readl(&phbcmu->outbound_doorbell)
+                                & ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE) {
+                        writel(ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE_DOORBELL_CLEAR,
+                                &phbcmu->outbound_doorbell_clear); /*clear interrupt*/
+                        return true;
+                }
+                msleep(10);
+        } /* max 20 seconds */
+
         return false;
 }
+
 static void arcmsr_flush_hba_cache(struct AdapterControlBlock *acb)
 {
         struct MessageUnit_A __iomem *reg = acb->pmuA;
@@ -459,10 +441,11 @@ static int arcmsr_alloc_ccb_pool(struct AdapterControlBlock *acb)
         struct CommandControlBlock *ccb_tmp;
         int i = 0, j = 0;
         dma_addr_t cdb_phyaddr;
-        unsigned long roundup_ccbsize = 0, offset;
+        unsigned long roundup_ccbsize;
         unsigned long max_xfer_len;
         unsigned long max_sg_entrys;
         uint32_t  firm_config_version;
+
         for (i = 0; i < ARCMSR_MAX_TARGETID; i++)
                 for (j = 0; j < ARCMSR_MAX_TARGETLUN; j++)
                         acb->devstate[i][j] = ARECA_RAID_GONE;
@@ -472,23 +455,20 @@ static int arcmsr_alloc_ccb_pool(struct AdapterControlBlock *acb)
         firm_config_version = acb->firm_cfg_version;
         if((firm_config_version & 0xFF) >= 3){
                 max_xfer_len = (ARCMSR_CDB_SG_PAGE_LENGTH << ((firm_config_version >> 8) & 0xFF)) * 1024;/* max 4M byte */
-                max_sg_entrys = (max_xfer_len/4096);    
+                max_sg_entrys = (max_xfer_len/4096);
         }
         acb->host->max_sectors = max_xfer_len/512;
         acb->host->sg_tablesize = max_sg_entrys;
         roundup_ccbsize = roundup(sizeof(struct CommandControlBlock) + (max_sg_entrys - 1) * sizeof(struct SG64ENTRY), 32);
-        acb->uncache_size = roundup_ccbsize * ARCMSR_MAX_FREECCB_NUM + 32;
+        acb->uncache_size = roundup_ccbsize * ARCMSR_MAX_FREECCB_NUM;
         dma_coherent = dma_alloc_coherent(&pdev->dev, acb->uncache_size, &dma_coherent_handle, GFP_KERNEL);
         if(!dma_coherent){
-                printk(KERN_NOTICE "arcmsr%d: dma_alloc_coherent got error \n", acb->host->host_no);
+                printk(KERN_NOTICE "arcmsr%d: dma_alloc_coherent got error\n", acb->host->host_no);
                 return -ENOMEM;
         }
         acb->dma_coherent = dma_coherent;
         acb->dma_coherent_handle = dma_coherent_handle;
         memset(dma_coherent, 0, acb->uncache_size);
-        offset = roundup((unsigned long)dma_coherent, 32) - (unsigned long)dma_coherent;
-        dma_coherent_handle = dma_coherent_handle + offset;
-        dma_coherent = (struct CommandControlBlock *)dma_coherent + offset;
         ccb_tmp = dma_coherent;
         acb->vir2phy_offset = (unsigned long)dma_coherent - (unsigned long)dma_coherent_handle;
         for(i = 0; i < ARCMSR_MAX_FREECCB_NUM; i++){
@@ -2602,12 +2582,8 @@ static int arcmsr_iop_confirm(struct AdapterControlBlock *acb)
                 if (cdb_phyaddr_hi32 != 0) {
                         struct MessageUnit_C *reg = (struct MessageUnit_C *)acb->pmuC;
 
-                        if (cdb_phyaddr_hi32 != 0) {
-                                unsigned char Retries = 0x00;
-                                do {
-                                        printk(KERN_NOTICE "arcmsr%d: cdb_phyaddr_hi32=0x%x \n", acb->adapter_index, cdb_phyaddr_hi32);
-                                } while (Retries++ < 100);
-                        }
+                        printk(KERN_NOTICE "arcmsr%d: cdb_phyaddr_hi32=0x%x\n",
+                                        acb->adapter_index, cdb_phyaddr_hi32);
                         writel(ARCMSR_SIGNATURE_SET_CONFIG, &reg->msgcode_rwbuffer[0]);
                         writel(cdb_phyaddr_hi32, &reg->msgcode_rwbuffer[1]);
                         writel(ARCMSR_INBOUND_MESG0_SET_CONFIG, &reg->inbound_msgaddr0);
@@ -2955,12 +2931,12 @@ static int arcmsr_bus_reset(struct scsi_cmnd *cmd)
                                 arcmsr_hardware_reset(acb);
                                 acb->acb_flags &= ~ACB_F_IOP_INITED;
 sleep_again:
-                                arcmsr_sleep_for_bus_reset(cmd);
+                                ssleep(ARCMSR_SLEEPTIME);
                                 if ((readl(&reg->outbound_msgaddr1) & ARCMSR_OUTBOUND_MESG1_FIRMWARE_OK) == 0) {
-                                        printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, retry=%d \n", acb->host->host_no, retry_count);
-                                        if (retry_count > retrycount) {
+                                        printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, retry=%d\n", acb->host->host_no, retry_count);
+                                        if (retry_count > ARCMSR_RETRYCOUNT) {
                                                 acb->fw_flag = FW_DEADLOCK;
-                                                printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, RETRY TERMINATED!! \n", acb->host->host_no);
+                                                printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, RETRY TERMINATED!!\n", acb->host->host_no);
                                                 return FAILED;
                                         }
                                         retry_count++;
@@ -3025,12 +3001,12 @@ sleep_again:
                                 arcmsr_hardware_reset(acb);
                                 acb->acb_flags &= ~ACB_F_IOP_INITED;
 sleep:
-                                arcmsr_sleep_for_bus_reset(cmd);
+                                ssleep(ARCMSR_SLEEPTIME);
                                 if ((readl(&reg->host_diagnostic) & 0x04) != 0) {
-                                        printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, retry=%d \n", acb->host->host_no, retry_count);
-                                        if (retry_count > retrycount) {
+                                        printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, retry=%d\n", acb->host->host_no, retry_count);
+                                        if (retry_count > ARCMSR_RETRYCOUNT) {
                                                 acb->fw_flag = FW_DEADLOCK;
-                                                printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, RETRY TERMINATED!! \n", acb->host->host_no);
+                                                printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, RETRY TERMINATED!!\n", acb->host->host_no);
                                                 return FAILED;
                                         }
                                         retry_count++;
diff --git a/drivers/scsi/be2iscsi/be.h b/drivers/scsi/be2iscsi/be.h
index 1cb8a5e85c7f..1d7b976c850f 100644
--- a/drivers/scsi/be2iscsi/be.h
+++ b/drivers/scsi/be2iscsi/be.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -8,11 +8,11 @@
  * Public License is included in this distribution in the file called COPYING.
  *
  * Contact Information:
- * linux-drivers@serverengines.com
+ * linux-drivers@emulex.com
  *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #ifndef BEISCSI_H
diff --git a/drivers/scsi/be2iscsi/be_cmds.c b/drivers/scsi/be2iscsi/be_cmds.c
index ad246369d373..b8a82f2c62c8 100644
--- a/drivers/scsi/be2iscsi/be_cmds.c
+++ b/drivers/scsi/be2iscsi/be_cmds.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -8,11 +8,11 @@
  * Public License is included in this distribution in the file called COPYING.
  *
  * Contact Information:
- * linux-drivers@serverengines.com
+ * linux-drivers@emulex.com
  *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #include "be.h"
@@ -458,6 +458,7 @@ void be_cmd_hdr_prepare(struct be_cmd_req_hdr *req_hdr,
         req_hdr->opcode = opcode;
         req_hdr->subsystem = subsystem;
         req_hdr->request_length = cpu_to_le32(cmd_len - sizeof(*req_hdr));
+        req_hdr->timeout = 120;
 }
 
 static void be_cmd_page_addrs_prepare(struct phys_addr *pages, u32 max_pages,
diff --git a/drivers/scsi/be2iscsi/be_cmds.h b/drivers/scsi/be2iscsi/be_cmds.h
index fbd1dc2c15f7..497eb29e5c9e 100644
--- a/drivers/scsi/be2iscsi/be_cmds.h
+++ b/drivers/scsi/be2iscsi/be_cmds.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -8,11 +8,11 @@
  * Public License is included in this distribution in the file called COPYING.
  *
  * Contact Information:
- * linux-drivers@serverengines.com
+ * linux-drivers@emulex.com
  *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #ifndef BEISCSI_CMDS_H
diff --git a/drivers/scsi/be2iscsi/be_iscsi.c b/drivers/scsi/be2iscsi/be_iscsi.c
index 868cc5590145..3cad10605023 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.c
+++ b/drivers/scsi/be2iscsi/be_iscsi.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -7,15 +7,14 @@
  * as published by the Free Software Foundation.  The full GNU General
  * Public License is included in this distribution in the file called COPYING.
  *
- * Written by: Jayamohan Kallickal (jayamohank@serverengines.com)
+ * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
  *
  * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * linux-drivers@emulex.com
  *
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #include <scsi/libiscsi.h>
diff --git a/drivers/scsi/be2iscsi/be_iscsi.h b/drivers/scsi/be2iscsi/be_iscsi.h
index 9c532797c29e..ff60b7fd92d6 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.h
+++ b/drivers/scsi/be2iscsi/be_iscsi.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -7,15 +7,14 @@
  * as published by the Free Software Foundation.  The full GNU General
  * Public License is included in this distribution in the file called COPYING.
  *
- * Written by: Jayamohan Kallickal (jayamohank@serverengines.com)
+ * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
  *
  * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * linux-drivers@emulex.com
  *
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #ifndef _BE_ISCSI_
diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 24e20ba9633c..cea9b275965c 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -7,16 +7,16 @@
  * as published by the Free Software Foundation.  The full GNU General
  * Public License is included in this distribution in the file called COPYING.
  *
- * Written by: Jayamohan Kallickal (jayamohank@serverengines.com)
+ * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
  *
  * Contact Information:
- * linux-drivers@serverengines.com
- *
- *  ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * linux-drivers@emulex.com
  *
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
+
 #include <linux/reboot.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
@@ -420,7 +420,8 @@ static int beiscsi_setup_boot_info(struct beiscsi_hba *phba)
         return 0;
 
 free_kset:
-        iscsi_boot_destroy_kset(phba->boot_kset);
+        if (phba->boot_kset)
+                iscsi_boot_destroy_kset(phba->boot_kset);
         return -ENOMEM;
 }
 
@@ -3464,23 +3465,23 @@ static void hwi_enable_intr(struct beiscsi_hba *phba)
         addr = (u8 __iomem *) ((u8 __iomem *) ctrl->pcicfg +
                         PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET);
         reg = ioread32(addr);
-        SE_DEBUG(DBG_LVL_8, "reg =x%08x\n", reg);
 
         enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
         if (!enabled) {
                 reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
                 SE_DEBUG(DBG_LVL_8, "reg =x%08x addr=%p\n", reg, addr);
                 iowrite32(reg, addr);
-                if (!phba->msix_enabled) {
-                        eq = &phwi_context->be_eq[0].q;
+        }
+
+        if (!phba->msix_enabled) {
+                eq = &phwi_context->be_eq[0].q;
+                SE_DEBUG(DBG_LVL_8, "eq->id=%d\n", eq->id);
+                hwi_ring_eq_db(phba, eq->id, 0, 0, 1, 1);
+        } else {
+                for (i = 0; i <= phba->num_cpus; i++) {
+                        eq = &phwi_context->be_eq[i].q;
                         SE_DEBUG(DBG_LVL_8, "eq->id=%d\n", eq->id);
                         hwi_ring_eq_db(phba, eq->id, 0, 0, 1, 1);
-                } else {
-                        for (i = 0; i <= phba->num_cpus; i++) {
-                                eq = &phwi_context->be_eq[i].q;
-                                SE_DEBUG(DBG_LVL_8, "eq->id=%d\n", eq->id);
-                                hwi_ring_eq_db(phba, eq->id, 0, 0, 1, 1);
-                        }
                 }
         }
 }
@@ -4019,12 +4020,17 @@ static int beiscsi_mtask(struct iscsi_task *task)
                 hwi_write_buffer(pwrb, task);
                 break;
         case ISCSI_OP_NOOP_OUT:
-                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                              INI_RD_CMD);
-                if (task->hdr->ttt == ISCSI_RESERVED_TAG)
+                if (task->hdr->ttt != ISCSI_RESERVED_TAG) {
+                        AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                                      TGT_DM_CMD);
+                        AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt,
+                                      pwrb, 0);
                         AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
-                else
+                } else {
+                        AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                                      INI_RD_CMD);
                         AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 1);
+                }
                 hwi_write_buffer(pwrb, task);
                 break;
         case ISCSI_OP_TEXT:
@@ -4144,10 +4150,11 @@ static void beiscsi_remove(struct pci_dev *pcidev)
                             phba->ctrl.mbox_mem_alloced.size,
                             phba->ctrl.mbox_mem_alloced.va,
                             phba->ctrl.mbox_mem_alloced.dma);
+        if (phba->boot_kset)
+                iscsi_boot_destroy_kset(phba->boot_kset);
         iscsi_host_remove(phba->shost);
         pci_dev_put(phba->pcidev);
         iscsi_host_free(phba->shost);
-        iscsi_boot_destroy_kset(phba->boot_kset);
 }
 
 static void beiscsi_msix_enable(struct beiscsi_hba *phba)
diff --git a/drivers/scsi/be2iscsi/be_main.h b/drivers/scsi/be2iscsi/be_main.h
index 90eb74f6bcab..081c171a1ed6 100644
--- a/drivers/scsi/be2iscsi/be_main.h
+++ b/drivers/scsi/be2iscsi/be_main.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -7,15 +7,14 @@
  * as published by the Free Software Foundation.  The full GNU General
  * Public License is included in this distribution in the file called COPYING.
  *
- * Written by: Jayamohan Kallickal (jayamohank@serverengines.com)
+ * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
  *
  * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * linux-drivers@emulex.com
  *
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #ifndef _BEISCSI_MAIN_
@@ -35,7 +34,7 @@
 
 #include "be.h"
 #define DRV_NAME                "be2iscsi"
-#define BUILD_STR               "2.0.549.0"
+#define BUILD_STR               "2.103.298.0"
 #define BE_NAME                 "ServerEngines BladeEngine2" \
                                 "Linux iSCSI Driver version" BUILD_STR
 #define DRV_DESC                BE_NAME " " "Driver"
diff --git a/drivers/scsi/be2iscsi/be_mgmt.c b/drivers/scsi/be2iscsi/be_mgmt.c
index 877324fc594c..44762cfa3e12 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.c
+++ b/drivers/scsi/be2iscsi/be_mgmt.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -7,15 +7,14 @@
  * as published by the Free Software Foundation.  The full GNU General
  * Public License is included in this distribution in the file called COPYING.
  *
- * Written by: Jayamohan Kallickal (jayamohank@serverengines.com)
+ * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
  *
  * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * linux-drivers@emulex.com
  *
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #include "be_mgmt.h"
@@ -203,8 +202,8 @@ int mgmt_epfw_cleanup(struct beiscsi_hba *phba, unsigned short chute)
                            OPCODE_COMMON_ISCSI_CLEANUP, sizeof(*req));
 
         req->chute = chute;
-        req->hdr_ring_id = 0;
-        req->data_ring_id = 0;
+        req->hdr_ring_id = cpu_to_le16(HWI_GET_DEF_HDRQ_ID(phba));
+        req->data_ring_id = cpu_to_le16(HWI_GET_DEF_BUFQ_ID(phba));
 
         status =  be_mcc_notify_wait(phba);
         if (status)
diff --git a/drivers/scsi/be2iscsi/be_mgmt.h b/drivers/scsi/be2iscsi/be_mgmt.h
index b9acedf78653..08428824ace2 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.h
+++ b/drivers/scsi/be2iscsi/be_mgmt.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -7,15 +7,14 @@
  * as published by the Free Software Foundation.  The full GNU General
  * Public License is included in this distribution in the file called COPYING.
  *
- * Written by: Jayamohan Kallickal (jayamohank@serverengines.com)
+ * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
  *
  * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * linux-drivers@emulex.com
  *
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #ifndef _BEISCSI_MGMT_
diff --git a/drivers/scsi/bfa/bfad.c b/drivers/scsi/bfa/bfad.c
index 0fd510a01561..59b5e9b61d71 100644
--- a/drivers/scsi/bfa/bfad.c
+++ b/drivers/scsi/bfa/bfad.c
@@ -57,9 +57,19 @@ int		pcie_max_read_reqsz;
 int             bfa_debugfs_enable = 1;
 int             msix_disable_cb = 0, msix_disable_ct = 0;
 
+/* Firmware releated */
 u32     bfi_image_ct_fc_size, bfi_image_ct_cna_size, bfi_image_cb_fc_size;
 u32     *bfi_image_ct_fc, *bfi_image_ct_cna, *bfi_image_cb_fc;
 
+#define BFAD_FW_FILE_CT_FC      "ctfw_fc.bin"
+#define BFAD_FW_FILE_CT_CNA     "ctfw_cna.bin"
+#define BFAD_FW_FILE_CB_FC      "cbfw_fc.bin"
+
+static u32 *bfad_load_fwimg(struct pci_dev *pdev);
+static void bfad_free_fwimg(void);
+static void bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
+                u32 *bfi_image_size, char *fw_name);
+
 static const char *msix_name_ct[] = {
         "cpe0", "cpe1", "cpe2", "cpe3",
         "rme0", "rme1", "rme2", "rme3",
@@ -222,6 +232,9 @@ bfad_sm_created(struct bfad_s *bfad, enum bfad_sm_event event)
                 if ((bfad->bfad_flags & BFAD_HAL_INIT_DONE)) {
                         bfa_sm_send_event(bfad, BFAD_E_INIT_SUCCESS);
                 } else {
+                        printk(KERN_WARNING
+                                "bfa %s: bfa init failed\n",
+                                bfad->pci_name);
                         bfad->bfad_flags |= BFAD_HAL_INIT_FAIL;
                         bfa_sm_send_event(bfad, BFAD_E_INIT_FAILED);
                 }
@@ -991,10 +1004,6 @@ bfad_cfg_pport(struct bfad_s *bfad, enum bfa_lport_role role)
                 bfad->pport.roles |= BFA_LPORT_ROLE_FCP_IM;
         }
 
-        /* Setup the debugfs node for this scsi_host */
-        if (bfa_debugfs_enable)
-                bfad_debugfs_init(&bfad->pport);
-
         bfad->bfad_flags |= BFAD_CFG_PPORT_DONE;
 
 out:
@@ -1004,10 +1013,6 @@ out:
 void
 bfad_uncfg_pport(struct bfad_s *bfad)
 {
-        /* Remove the debugfs node for this scsi_host */
-        kfree(bfad->regdata);
-        bfad_debugfs_exit(&bfad->pport);
-
         if ((supported_fc4s & BFA_LPORT_ROLE_FCP_IM) &&
             (bfad->pport.roles & BFA_LPORT_ROLE_FCP_IM)) {
                 bfad_im_scsi_host_free(bfad, bfad->pport.im_port);
@@ -1389,6 +1394,10 @@ bfad_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pid)
         bfad->pport.bfad = bfad;
         INIT_LIST_HEAD(&bfad->pbc_vport_list);
 
+        /* Setup the debugfs node for this bfad */
+        if (bfa_debugfs_enable)
+                bfad_debugfs_init(&bfad->pport);
+
         retval = bfad_drv_init(bfad);
         if (retval != BFA_STATUS_OK)
                 goto out_drv_init_failure;
@@ -1404,6 +1413,9 @@ out_bfad_sm_failure:
         bfa_detach(&bfad->bfa);
         bfad_hal_mem_release(bfad);
 out_drv_init_failure:
+        /* Remove the debugfs node for this bfad */
+        kfree(bfad->regdata);
+        bfad_debugfs_exit(&bfad->pport);
         mutex_lock(&bfad_mutex);
         bfad_inst--;
         list_del(&bfad->list_entry);
@@ -1445,6 +1457,10 @@ bfad_pci_remove(struct pci_dev *pdev)
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
         bfad_hal_mem_release(bfad);
 
+        /* Remove the debugfs node for this bfad */
+        kfree(bfad->regdata);
+        bfad_debugfs_exit(&bfad->pport);
+
         /* Cleaning the BFAD instance */
         mutex_lock(&bfad_mutex);
         bfad_inst--;
@@ -1550,7 +1566,7 @@ bfad_exit(void)
 }
 
 /* Firmware handling */
-u32 *
+static void
 bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
                 u32 *bfi_image_size, char *fw_name)
 {
@@ -1558,27 +1574,25 @@ bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
 
         if (request_firmware(&fw, fw_name, &pdev->dev)) {
                 printk(KERN_ALERT "Can't locate firmware %s\n", fw_name);
-                goto error;
+                *bfi_image = NULL;
+                goto out;
         }
 
         *bfi_image = vmalloc(fw->size);
         if (NULL == *bfi_image) {
                 printk(KERN_ALERT "Fail to allocate buffer for fw image "
                         "size=%x!\n", (u32) fw->size);
-                goto error;
+                goto out;
         }
 
         memcpy(*bfi_image, fw->data, fw->size);
         *bfi_image_size = fw->size/sizeof(u32);
-
-        return *bfi_image;
-
-error:
-        return NULL;
+out:
+        release_firmware(fw);
 }
 
-u32 *
-bfad_get_firmware_buf(struct pci_dev *pdev)
+static u32 *
+bfad_load_fwimg(struct pci_dev *pdev)
 {
         if (pdev->device == BFA_PCI_DEVICE_ID_CT_FC) {
                 if (bfi_image_ct_fc_size == 0)
@@ -1598,6 +1612,17 @@ bfad_get_firmware_buf(struct pci_dev *pdev)
         }
 }
 
+static void
+bfad_free_fwimg(void)
+{
+        if (bfi_image_ct_fc_size && bfi_image_ct_fc)
+                vfree(bfi_image_ct_fc);
+        if (bfi_image_ct_cna_size && bfi_image_ct_cna)
+                vfree(bfi_image_ct_cna);
+        if (bfi_image_cb_fc_size && bfi_image_cb_fc)
+                vfree(bfi_image_cb_fc);
+}
+
 module_init(bfad_init);
 module_exit(bfad_exit);
 MODULE_LICENSE("GPL");
diff --git a/drivers/scsi/bfa/bfad_debugfs.c b/drivers/scsi/bfa/bfad_debugfs.c
index c66e32eced7b..48be0c54f2de 100644
--- a/drivers/scsi/bfa/bfad_debugfs.c
+++ b/drivers/scsi/bfa/bfad_debugfs.c
@@ -28,10 +28,10 @@
  * mount -t debugfs none /sys/kernel/debug
  *
  * BFA Hierarchy:
- *      - bfa/host#
- * where the host number corresponds to the one under /sys/class/scsi_host/host#
+ *      - bfa/pci_dev:<pci_name>
+ * where the pci_name corresponds to the one under /sys/bus/pci/drivers/bfa
  *
- * Debugging service available per host:
+ * Debugging service available per pci_dev:
  * fwtrc:  To collect current firmware trace.
  * drvtrc: To collect current driver trace
  * fwsave: To collect last saved fw trace as a result of firmware crash.
@@ -489,11 +489,9 @@ static atomic_t bfa_debugfs_port_count;
 inline void
 bfad_debugfs_init(struct bfad_port_s *port)
 {
-        struct bfad_im_port_s *im_port = port->im_port;
-        struct bfad_s *bfad = im_port->bfad;
-        struct Scsi_Host *shost = im_port->shost;
+        struct bfad_s *bfad = port->bfad;
         const struct bfad_debugfs_entry *file;
-        char name[16];
+        char name[64];
         int i;
 
         if (!bfa_debugfs_enable)
@@ -510,17 +508,15 @@ bfad_debugfs_init(struct bfad_port_s *port)
                 }
         }
 
-        /*
-         * Setup the host# directory for the port,
-         * corresponds to the scsi_host num of this port.
-         */
-        snprintf(name, sizeof(name), "host%d", shost->host_no);
+        /* Setup the pci_dev debugfs directory for the port */
+        snprintf(name, sizeof(name), "pci_dev:%s", bfad->pci_name);
         if (!port->port_debugfs_root) {
                 port->port_debugfs_root =
                         debugfs_create_dir(name, bfa_debugfs_root);
                 if (!port->port_debugfs_root) {
                         printk(KERN_WARNING
-                                "BFA host root dir creation failed\n");
+                                "bfa %s: debugfs root creation failed\n",
+                                bfad->pci_name);
                         goto err;
                 }
 
@@ -536,8 +532,8 @@ bfad_debugfs_init(struct bfad_port_s *port)
                                                         file->fops);
                         if (!bfad->bfad_dentry_files[i]) {
                                 printk(KERN_WARNING
-                                        "BFA host%d: create %s entry failed\n",
-                                        shost->host_no, file->name);
+                                        "bfa %s: debugfs %s creation failed\n",
+                                        bfad->pci_name, file->name);
                                 goto err;
                         }
                 }
@@ -550,8 +546,7 @@ err:
 inline void
 bfad_debugfs_exit(struct bfad_port_s *port)
 {
-        struct bfad_im_port_s *im_port = port->im_port;
-        struct bfad_s *bfad = im_port->bfad;
+        struct bfad_s *bfad = port->bfad;
         int i;
 
         for (i = 0; i < ARRAY_SIZE(bfad_debugfs_files); i++) {
@@ -562,9 +557,7 @@ bfad_debugfs_exit(struct bfad_port_s *port)
         }
 
         /*
-         * Remove the host# directory for the port,
-         * corresponds to the scsi_host num of this port.
-        */
+         * Remove the pci_dev debugfs directory for the port */
         if (port->port_debugfs_root) {
                 debugfs_remove(port->port_debugfs_root);
                 port->port_debugfs_root = NULL;
diff --git a/drivers/scsi/bfa/bfad_im.h b/drivers/scsi/bfa/bfad_im.h
index bfee63b16fa9..c296c8968511 100644
--- a/drivers/scsi/bfa/bfad_im.h
+++ b/drivers/scsi/bfa/bfad_im.h
@@ -141,29 +141,4 @@ extern struct device_attribute *bfad_im_vport_attrs[];
 
 irqreturn_t bfad_intx(int irq, void *dev_id);
 
-/* Firmware releated */
-#define BFAD_FW_FILE_CT_FC      "ctfw_fc.bin"
-#define BFAD_FW_FILE_CT_CNA     "ctfw_cna.bin"
-#define BFAD_FW_FILE_CB_FC      "cbfw_fc.bin"
-
-u32 *bfad_get_firmware_buf(struct pci_dev *pdev);
-u32 *bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
-                u32 *bfi_image_size, char *fw_name);
-
-static inline u32 *
-bfad_load_fwimg(struct pci_dev *pdev)
-{
-        return bfad_get_firmware_buf(pdev);
-}
-
-static inline void
-bfad_free_fwimg(void)
-{
-        if (bfi_image_ct_fc_size && bfi_image_ct_fc)
-                vfree(bfi_image_ct_fc);
-        if (bfi_image_ct_cna_size && bfi_image_ct_cna)
-                vfree(bfi_image_ct_cna);
-        if (bfi_image_cb_fc_size && bfi_image_cb_fc)
-                vfree(bfi_image_cb_fc);
-}
 #endif
diff --git a/drivers/scsi/bnx2fc/bnx2fc.h b/drivers/scsi/bnx2fc/bnx2fc.h
index b6d350ac4288..0a404bfb44fe 100644
--- a/drivers/scsi/bnx2fc/bnx2fc.h
+++ b/drivers/scsi/bnx2fc/bnx2fc.h
@@ -130,7 +130,7 @@
 #define BNX2FC_TM_TIMEOUT               60      /* secs */
 #define BNX2FC_IO_TIMEOUT               20000UL /* msecs */
 
-#define BNX2FC_WAIT_CNT                 120
+#define BNX2FC_WAIT_CNT                 1200
 #define BNX2FC_FW_TIMEOUT               (3 * HZ)
 #define PORT_MAX                        2
 
diff --git a/drivers/scsi/bnx2fc/bnx2fc_fcoe.c b/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
index e2e647509a73..662365676689 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
@@ -1130,7 +1130,7 @@ static void bnx2fc_interface_release(struct kref *kref)
         struct net_device *phys_dev;
 
         hba = container_of(kref, struct bnx2fc_hba, kref);
-        BNX2FC_HBA_DBG(hba->ctlr.lp, "Interface is being released\n");
+        BNX2FC_MISC_DBG("Interface is being released\n");
 
         netdev = hba->netdev;
         phys_dev = hba->phys_dev;
@@ -1254,20 +1254,17 @@ setup_err:
 static struct fc_lport *bnx2fc_if_create(struct bnx2fc_hba *hba,
                                   struct device *parent, int npiv)
 {
-        struct fc_lport         *lport = NULL;
+        struct fc_lport         *lport, *n_port;
         struct fcoe_port        *port;
         struct Scsi_Host        *shost;
         struct fc_vport         *vport = dev_to_vport(parent);
         int                     rc = 0;
 
         /* Allocate Scsi_Host structure */
-        if (!npiv) {
-                lport = libfc_host_alloc(&bnx2fc_shost_template,
-                                          sizeof(struct fcoe_port));
-        } else {
-                lport = libfc_vport_create(vport,
-                                           sizeof(struct fcoe_port));
-        }
+        if (!npiv)
+                lport = libfc_host_alloc(&bnx2fc_shost_template, sizeof(*port));
+        else
+                lport = libfc_vport_create(vport, sizeof(*port));
 
         if (!lport) {
                 printk(KERN_ERR PFX "could not allocate scsi host structure\n");
@@ -1285,7 +1282,6 @@ static struct fc_lport *bnx2fc_if_create(struct bnx2fc_hba *hba,
                 goto lp_config_err;
 
         if (npiv) {
-                vport = dev_to_vport(parent);
                 printk(KERN_ERR PFX "Setting vport names, 0x%llX 0x%llX\n",
                         vport->node_name, vport->port_name);
                 fc_set_wwnn(lport, vport->node_name);
@@ -1314,12 +1310,17 @@ static struct fc_lport *bnx2fc_if_create(struct bnx2fc_hba *hba,
         fc_host_port_type(lport->host) = FC_PORTTYPE_UNKNOWN;
 
         /* Allocate exchange manager */
-        if (!npiv) {
+        if (!npiv)
                 rc = bnx2fc_em_config(lport);
-                if (rc) {
-                        printk(KERN_ERR PFX "Error on bnx2fc_em_config\n");
-                        goto shost_err;
-                }
+        else {
+                shost = vport_to_shost(vport);
+                n_port = shost_priv(shost);
+                rc = fc_exch_mgr_list_clone(n_port, lport);
+        }
+
+        if (rc) {
+                printk(KERN_ERR PFX "Error on bnx2fc_em_config\n");
+                goto shost_err;
         }
 
         bnx2fc_interface_get(hba);
@@ -1352,8 +1353,6 @@ static void bnx2fc_if_destroy(struct fc_lport *lport)
         /* Free existing transmit skbs */
         fcoe_clean_pending_queue(lport);
 
-        bnx2fc_interface_put(hba);
-
         /* Free queued packets for the receive thread */
         bnx2fc_clean_rx_queue(lport);
 
@@ -1372,6 +1371,8 @@ static void bnx2fc_if_destroy(struct fc_lport *lport)
 
         /* Release Scsi_Host */
         scsi_host_put(lport->host);
+
+        bnx2fc_interface_put(hba);
 }
 
 /**
diff --git a/drivers/scsi/bnx2fc/bnx2fc_hwi.c b/drivers/scsi/bnx2fc/bnx2fc_hwi.c
index 1b680e288c56..f756d5f85c7a 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_hwi.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_hwi.c
@@ -522,6 +522,7 @@ void bnx2fc_process_l2_frame_compl(struct bnx2fc_rport *tgt,
         fp = fc_frame_alloc(lport, payload_len);
         if (!fp) {
                 printk(KERN_ERR PFX "fc_frame_alloc failure\n");
+                kfree(unsol_els);
                 return;
         }
 
@@ -547,6 +548,7 @@ void bnx2fc_process_l2_frame_compl(struct bnx2fc_rport *tgt,
                                  */
                                 printk(KERN_ERR PFX "dropping ELS 0x%x\n", op);
                                 kfree_skb(skb);
+                                kfree(unsol_els);
                                 return;
                         }
                 }
@@ -563,6 +565,7 @@ void bnx2fc_process_l2_frame_compl(struct bnx2fc_rport *tgt,
         } else {
                 BNX2FC_HBA_DBG(lport, "fh_r_ctl = 0x%x\n", fh->fh_r_ctl);
                 kfree_skb(skb);
+                kfree(unsol_els);
         }
 }
 
diff --git a/drivers/scsi/bnx2fc/bnx2fc_io.c b/drivers/scsi/bnx2fc/bnx2fc_io.c
index 1decefbf32e3..b5b5c346d779 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_io.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_io.c
@@ -1663,6 +1663,12 @@ int bnx2fc_queuecommand(struct Scsi_Host *host,
         tgt = (struct bnx2fc_rport *)&rp[1];
 
         if (!test_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags)) {
+                if (test_bit(BNX2FC_FLAG_UPLD_REQ_COMPL, &tgt->flags))  {
+                        sc_cmd->result = DID_NO_CONNECT << 16;
+                        sc_cmd->scsi_done(sc_cmd);
+                        return 0;
+
+                }
                 /*
                  * Session is not offloaded yet. Let SCSI-ml retry
                  * the command.
diff --git a/drivers/scsi/constants.c b/drivers/scsi/constants.c
index d0c82340f0e2..60d2ef291646 100644
--- a/drivers/scsi/constants.c
+++ b/drivers/scsi/constants.c
@@ -772,6 +772,7 @@ static const struct error_info additional[] =
         {0x3802, "Esn - power management class event"},
         {0x3804, "Esn - media class event"},
         {0x3806, "Esn - device busy class event"},
+        {0x3807, "Thin Provisioning soft threshold reached"},
 
         {0x3900, "Saving parameters not supported"},
 
diff --git a/drivers/scsi/dc395x.c b/drivers/scsi/dc395x.c
index b10b3841535c..f5b718d3c31b 100644
--- a/drivers/scsi/dc395x.c
+++ b/drivers/scsi/dc395x.c
@@ -778,8 +778,8 @@ static void srb_free_insert(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb)
 static void srb_waiting_insert(struct DeviceCtlBlk *dcb,
                 struct ScsiReqBlk *srb)
 {
-        dprintkdbg(DBG_0, "srb_waiting_insert: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+        dprintkdbg(DBG_0, "srb_waiting_insert: (0x%p) <%02i-%i> srb=%p\n",
+                srb->cmd, dcb->target_id, dcb->target_lun, srb);
         list_add(&srb->list, &dcb->srb_waiting_list);
 }
 
@@ -787,16 +787,16 @@ static void srb_waiting_insert(struct DeviceCtlBlk *dcb,
 static void srb_waiting_append(struct DeviceCtlBlk *dcb,
                 struct ScsiReqBlk *srb)
 {
-        dprintkdbg(DBG_0, "srb_waiting_append: (pid#%li) <%02i-%i> srb=%p\n",
-                 srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+        dprintkdbg(DBG_0, "srb_waiting_append: (0x%p) <%02i-%i> srb=%p\n",
+                 srb->cmd, dcb->target_id, dcb->target_lun, srb);
         list_add_tail(&srb->list, &dcb->srb_waiting_list);
 }
 
 
 static void srb_going_append(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb)
 {
-        dprintkdbg(DBG_0, "srb_going_append: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+        dprintkdbg(DBG_0, "srb_going_append: (0x%p) <%02i-%i> srb=%p\n",
+                srb->cmd, dcb->target_id, dcb->target_lun, srb);
         list_add_tail(&srb->list, &dcb->srb_going_list);
 }
 
@@ -805,8 +805,8 @@ static void srb_going_remove(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb)
 {
         struct ScsiReqBlk *i;
         struct ScsiReqBlk *tmp;
-        dprintkdbg(DBG_0, "srb_going_remove: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+        dprintkdbg(DBG_0, "srb_going_remove: (0x%p) <%02i-%i> srb=%p\n",
+                srb->cmd, dcb->target_id, dcb->target_lun, srb);
 
         list_for_each_entry_safe(i, tmp, &dcb->srb_going_list, list)
                 if (i == srb) {
@@ -821,8 +821,8 @@ static void srb_waiting_remove(struct DeviceCtlBlk *dcb,
 {
         struct ScsiReqBlk *i;
         struct ScsiReqBlk *tmp;
-        dprintkdbg(DBG_0, "srb_waiting_remove: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+        dprintkdbg(DBG_0, "srb_waiting_remove: (0x%p) <%02i-%i> srb=%p\n",
+                srb->cmd, dcb->target_id, dcb->target_lun, srb);
 
         list_for_each_entry_safe(i, tmp, &dcb->srb_waiting_list, list)
                 if (i == srb) {
@@ -836,8 +836,8 @@ static void srb_going_to_waiting_move(struct DeviceCtlBlk *dcb,
                 struct ScsiReqBlk *srb)
 {
         dprintkdbg(DBG_0,
-                "srb_going_to_waiting_move: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+                "srb_going_to_waiting_move: (0x%p) <%02i-%i> srb=%p\n",
+                srb->cmd, dcb->target_id, dcb->target_lun, srb);
         list_move(&srb->list, &dcb->srb_waiting_list);
 }
 
@@ -846,8 +846,8 @@ static void srb_waiting_to_going_move(struct DeviceCtlBlk *dcb,
                 struct ScsiReqBlk *srb)
 {
         dprintkdbg(DBG_0,
-                "srb_waiting_to_going_move: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+                "srb_waiting_to_going_move: (0x%p) <%02i-%i> srb=%p\n",
+                srb->cmd, dcb->target_id, dcb->target_lun, srb);
         list_move(&srb->list, &dcb->srb_going_list);
 }
 
@@ -982,8 +982,8 @@ static void build_srb(struct scsi_cmnd *cmd, struct DeviceCtlBlk *dcb,
 {
         int nseg;
         enum dma_data_direction dir = cmd->sc_data_direction;
-        dprintkdbg(DBG_0, "build_srb: (pid#%li) <%02i-%i>\n",
-                cmd->serial_number, dcb->target_id, dcb->target_lun);
+        dprintkdbg(DBG_0, "build_srb: (0x%p) <%02i-%i>\n",
+                cmd, dcb->target_id, dcb->target_lun);
 
         srb->dcb = dcb;
         srb->cmd = cmd;
@@ -1086,8 +1086,8 @@ static int dc395x_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct s
         struct ScsiReqBlk *srb;
         struct AdapterCtlBlk *acb =
             (struct AdapterCtlBlk *)cmd->device->host->hostdata;
-        dprintkdbg(DBG_0, "queue_command: (pid#%li) <%02i-%i> cmnd=0x%02x\n",
-                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+        dprintkdbg(DBG_0, "queue_command: (0x%p) <%02i-%i> cmnd=0x%02x\n",
+                cmd, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
 
         /* Assume BAD_TARGET; will be cleared later */
         cmd->result = DID_BAD_TARGET << 16;
@@ -1140,7 +1140,7 @@ static int dc395x_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct s
                 /* process immediately */
                 send_srb(acb, srb);
         }
-        dprintkdbg(DBG_1, "queue_command: (pid#%li) done\n", cmd->serial_number);
+        dprintkdbg(DBG_1, "queue_command: (0x%p) done\n", cmd);
         return 0;
 
 complete:
@@ -1203,9 +1203,9 @@ static void dump_register_info(struct AdapterCtlBlk *acb,
                         dprintkl(KERN_INFO, "dump: srb=%p cmd=%p OOOPS!\n",
                                 srb, srb->cmd);
                 else
-                        dprintkl(KERN_INFO, "dump: srb=%p cmd=%p (pid#%li) "
+                        dprintkl(KERN_INFO, "dump: srb=%p cmd=%p "
                                  "cmnd=0x%02x <%02i-%i>\n",
-                                srb, srb->cmd, srb->cmd->serial_number,
+                                srb, srb->cmd,
                                 srb->cmd->cmnd[0], srb->cmd->device->id,
                                 srb->cmd->device->lun);
                 printk("  sglist=%p cnt=%i idx=%i len=%zu\n",
@@ -1301,8 +1301,8 @@ static int __dc395x_eh_bus_reset(struct scsi_cmnd *cmd)
         struct AdapterCtlBlk *acb =
                 (struct AdapterCtlBlk *)cmd->device->host->hostdata;
         dprintkl(KERN_INFO,
-                "eh_bus_reset: (pid#%li) target=<%02i-%i> cmd=%p\n",
-                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd);
+                "eh_bus_reset: (0%p) target=<%02i-%i> cmd=%p\n",
+                cmd, cmd->device->id, cmd->device->lun, cmd);
 
         if (timer_pending(&acb->waiting_timer))
                 del_timer(&acb->waiting_timer);
@@ -1368,8 +1368,8 @@ static int dc395x_eh_abort(struct scsi_cmnd *cmd)
             (struct AdapterCtlBlk *)cmd->device->host->hostdata;
         struct DeviceCtlBlk *dcb;
         struct ScsiReqBlk *srb;
-        dprintkl(KERN_INFO, "eh_abort: (pid#%li) target=<%02i-%i> cmd=%p\n",
-                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd);
+        dprintkl(KERN_INFO, "eh_abort: (0x%p) target=<%02i-%i> cmd=%p\n",
+                cmd, cmd->device->id, cmd->device->lun, cmd);
 
         dcb = find_dcb(acb, cmd->device->id, cmd->device->lun);
         if (!dcb) {
@@ -1495,8 +1495,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
         u16 s_stat2, return_code;
         u8 s_stat, scsicommand, i, identify_message;
         u8 *ptr;
-        dprintkdbg(DBG_0, "start_scsi: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+        dprintkdbg(DBG_0, "start_scsi: (0x%p) <%02i-%i> srb=%p\n",
+                dcb->target_id, dcb->target_lun, srb);
 
         srb->tag_number = TAG_NONE;     /* acb->tag_max_num: had error read in eeprom */
 
@@ -1505,8 +1505,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
         s_stat2 = DC395x_read16(acb, TRM_S1040_SCSI_STATUS);
 #if 1
         if (s_stat & 0x20 /* s_stat2 & 0x02000 */ ) {
-                dprintkdbg(DBG_KG, "start_scsi: (pid#%li) BUSY %02x %04x\n",
-                        srb->cmd->serial_number, s_stat, s_stat2);
+                dprintkdbg(DBG_KG, "start_scsi: (0x%p) BUSY %02x %04x\n",
+                        s_stat, s_stat2);
                 /*
                  * Try anyway?
                  *
@@ -1522,16 +1522,15 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
         }
 #endif
         if (acb->active_dcb) {
-                dprintkl(KERN_DEBUG, "start_scsi: (pid#%li) Attempt to start a"
-                        "command while another command (pid#%li) is active.",
-                        srb->cmd->serial_number,
+                dprintkl(KERN_DEBUG, "start_scsi: (0x%p) Attempt to start a"
+                        "command while another command (0x%p) is active.",
+                        srb->cmd,
                         acb->active_dcb->active_srb ?
-                            acb->active_dcb->active_srb->cmd->serial_number : 0);
+                            acb->active_dcb->active_srb->cmd : 0);
                 return 1;
         }
         if (DC395x_read16(acb, TRM_S1040_SCSI_STATUS) & SCSIINTERRUPT) {
-                dprintkdbg(DBG_KG, "start_scsi: (pid#%li) Failed (busy)\n",
-                        srb->cmd->serial_number);
+                dprintkdbg(DBG_KG, "start_scsi: (0x%p) Failed (busy)\n", srb->cmd);
                 return 1;
         }
         /* Allow starting of SCSI commands half a second before we allow the mid-level
@@ -1603,9 +1602,9 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
                         tag_number++;
                 }
                 if (tag_number >= dcb->max_command) {
-                        dprintkl(KERN_WARNING, "start_scsi: (pid#%li) "
+                        dprintkl(KERN_WARNING, "start_scsi: (0x%p) "
                                 "Out of tags target=<%02i-%i>)\n",
-                                srb->cmd->serial_number, srb->cmd->device->id,
+                                srb->cmd, srb->cmd->device->id,
                                 srb->cmd->device->lun);
                         srb->state = SRB_READY;
                         DC395x_write16(acb, TRM_S1040_SCSI_CONTROL,
@@ -1623,8 +1622,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
 #endif
 /*polling:*/
         /* Send CDB ..command block ......... */
-        dprintkdbg(DBG_KG, "start_scsi: (pid#%li) <%02i-%i> cmnd=0x%02x tag=%i\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun,
+        dprintkdbg(DBG_KG, "start_scsi: (0x%p) <%02i-%i> cmnd=0x%02x tag=%i\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun,
                 srb->cmd->cmnd[0], srb->tag_number);
         if (srb->flag & AUTO_REQSENSE) {
                 DC395x_write8(acb, TRM_S1040_SCSI_FIFO, REQUEST_SENSE);
@@ -1647,8 +1646,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
                  * we caught an interrupt (must be reset or reselection ... )
                  * : Let's process it first!
                  */
-                dprintkdbg(DBG_0, "start_scsi: (pid#%li) <%02i-%i> Failed - busy\n",
-                        srb->cmd->serial_number, dcb->target_id, dcb->target_lun);
+                dprintkdbg(DBG_0, "start_scsi: (0x%p) <%02i-%i> Failed - busy\n",
+                        srb->cmd, dcb->target_id, dcb->target_lun);
                 srb->state = SRB_READY;
                 free_tag(dcb, srb);
                 srb->msg_count = 0;
@@ -1843,7 +1842,7 @@ static irqreturn_t dc395x_interrupt(int irq, void *dev_id)
 static void msgout_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "msgout_phase0: (pid#%li)\n", srb->cmd->serial_number);
+        dprintkdbg(DBG_0, "msgout_phase0: (0x%p)\n", srb->cmd);
         if (srb->state & (SRB_UNEXPECT_RESEL + SRB_ABORT_SENT))
                 *pscsi_status = PH_BUS_FREE;    /*.. initial phase */
 
@@ -1857,18 +1856,18 @@ static void msgout_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 {
         u16 i;
         u8 *ptr;
-        dprintkdbg(DBG_0, "msgout_phase1: (pid#%li)\n", srb->cmd->serial_number);
+        dprintkdbg(DBG_0, "msgout_phase1: (0x%p)\n", srb->cmd);
 
         clear_fifo(acb, "msgout_phase1");
         if (!(srb->state & SRB_MSGOUT)) {
                 srb->state |= SRB_MSGOUT;
                 dprintkl(KERN_DEBUG,
-                        "msgout_phase1: (pid#%li) Phase unexpected\n",
-                        srb->cmd->serial_number);       /* So what ? */
+                        "msgout_phase1: (0x%p) Phase unexpected\n",
+                        srb->cmd);      /* So what ? */
         }
         if (!srb->msg_count) {
-                dprintkdbg(DBG_0, "msgout_phase1: (pid#%li) NOP msg\n",
-                        srb->cmd->serial_number);
+                dprintkdbg(DBG_0, "msgout_phase1: (0x%p) NOP msg\n",
+                        srb->cmd);
                 DC395x_write8(acb, TRM_S1040_SCSI_FIFO, MSG_NOP);
                 DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH);      /* it's important for atn stop */
                 DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_FIFO_OUT);
@@ -1888,7 +1887,7 @@ static void msgout_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 static void command_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "command_phase0: (pid#%li)\n", srb->cmd->serial_number);
+        dprintkdbg(DBG_0, "command_phase0: (0x%p)\n", srb->cmd);
         DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH);
 }
 
@@ -1899,7 +1898,7 @@ static void command_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
         struct DeviceCtlBlk *dcb;
         u8 *ptr;
         u16 i;
-        dprintkdbg(DBG_0, "command_phase1: (pid#%li)\n", srb->cmd->serial_number);
+        dprintkdbg(DBG_0, "command_phase1: (0x%p)\n", srb->cmd);
 
         clear_fifo(acb, "command_phase1");
         DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_CLRATN);
@@ -2041,8 +2040,8 @@ static void data_out_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
         struct DeviceCtlBlk *dcb = srb->dcb;
         u16 scsi_status = *pscsi_status;
         u32 d_left_counter = 0;
-        dprintkdbg(DBG_0, "data_out_phase0: (pid#%li) <%02i-%i>\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
+        dprintkdbg(DBG_0, "data_out_phase0: (0x%p) <%02i-%i>\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
 
         /*
          * KG: We need to drain the buffers before we draw any conclusions!
@@ -2171,8 +2170,8 @@ static void data_out_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 static void data_out_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "data_out_phase1: (pid#%li) <%02i-%i>\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
+        dprintkdbg(DBG_0, "data_out_phase1: (0x%p) <%02i-%i>\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
         clear_fifo(acb, "data_out_phase1");
         /* do prepare before transfer when data out phase */
         data_io_transfer(acb, srb, XFERDATAOUT);
@@ -2183,8 +2182,8 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 {
         u16 scsi_status = *pscsi_status;
 
-        dprintkdbg(DBG_0, "data_in_phase0: (pid#%li) <%02i-%i>\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
+        dprintkdbg(DBG_0, "data_in_phase0: (0x%p) <%02i-%i>\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
 
         /*
          * KG: DataIn is much more tricky than DataOut. When the device is finished
@@ -2204,8 +2203,8 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 unsigned int sc, fc;
 
                 if (scsi_status & PARITYERROR) {
-                        dprintkl(KERN_INFO, "data_in_phase0: (pid#%li) "
-                                "Parity Error\n", srb->cmd->serial_number);
+                        dprintkl(KERN_INFO, "data_in_phase0: (0x%p) "
+                                "Parity Error\n", srb->cmd);
                         srb->status |= PARITY_ERROR;
                 }
                 /*
@@ -2394,8 +2393,8 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 static void data_in_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "data_in_phase1: (pid#%li) <%02i-%i>\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
+        dprintkdbg(DBG_0, "data_in_phase1: (0x%p) <%02i-%i>\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
         data_io_transfer(acb, srb, XFERDATAIN);
 }
 
@@ -2406,8 +2405,8 @@ static void data_io_transfer(struct AdapterCtlBlk *acb,
         struct DeviceCtlBlk *dcb = srb->dcb;
         u8 bval;
         dprintkdbg(DBG_0,
-                "data_io_transfer: (pid#%li) <%02i-%i> %c len=%i, sg=(%i/%i)\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun,
+                "data_io_transfer: (0x%p) <%02i-%i> %c len=%i, sg=(%i/%i)\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun,
                 ((io_dir & DMACMD_DIR) ? 'r' : 'w'),
                 srb->total_xfer_length, srb->sg_index, srb->sg_count);
         if (srb == acb->tmp_srb)
@@ -2579,8 +2578,8 @@ static void data_io_transfer(struct AdapterCtlBlk *acb,
 static void status_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "status_phase0: (pid#%li) <%02i-%i>\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
+        dprintkdbg(DBG_0, "status_phase0: (0x%p) <%02i-%i>\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
         srb->target_status = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
         srb->end_message = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);      /* get message */
         srb->state = SRB_COMPLETED;
@@ -2593,8 +2592,8 @@ static void status_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 static void status_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "status_phase1: (pid#%li) <%02i-%i>\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
+        dprintkdbg(DBG_0, "status_phase1: (0x%p) <%02i-%i>\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
         srb->state = SRB_STATUS;
         DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH);      /* it's important for atn stop */
         DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_COMP);
@@ -2635,8 +2634,8 @@ static struct ScsiReqBlk *msgin_qtag(struct AdapterCtlBlk *acb,
 {
         struct ScsiReqBlk *srb = NULL;
         struct ScsiReqBlk *i;
-        dprintkdbg(DBG_0, "msgin_qtag: (pid#%li) tag=%i srb=%p\n",
-                   srb->cmd->serial_number, tag, srb);
+        dprintkdbg(DBG_0, "msgin_qtag: (0x%p) tag=%i srb=%p\n",
+                   srb->cmd, tag, srb);
 
         if (!(dcb->tag_mask & (1 << tag)))
                 dprintkl(KERN_DEBUG,
@@ -2654,8 +2653,8 @@ static struct ScsiReqBlk *msgin_qtag(struct AdapterCtlBlk *acb,
         if (!srb)
                 goto mingx0;
 
-        dprintkdbg(DBG_0, "msgin_qtag: (pid#%li) <%02i-%i>\n",
-                srb->cmd->serial_number, srb->dcb->target_id, srb->dcb->target_lun);
+        dprintkdbg(DBG_0, "msgin_qtag: (0x%p) <%02i-%i>\n",
+                srb->cmd, srb->dcb->target_id, srb->dcb->target_lun);
         if (dcb->flag & ABORT_DEV_) {
                 /*srb->state = SRB_ABORT_SENT; */
                 enable_msgout_abort(acb, srb);
@@ -2865,7 +2864,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
         struct DeviceCtlBlk *dcb = acb->active_dcb;
-        dprintkdbg(DBG_0, "msgin_phase0: (pid#%li)\n", srb->cmd->serial_number);
+        dprintkdbg(DBG_0, "msgin_phase0: (0x%p)\n", srb->cmd);
 
         srb->msgin_buf[acb->msg_len++] = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
         if (msgin_completed(srb->msgin_buf, acb->msg_len)) {
@@ -2931,9 +2930,9 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                          * SAVE POINTER may be ignored as we have the struct
                          * ScsiReqBlk* associated with the scsi command.
                          */
-                        dprintkdbg(DBG_0, "msgin_phase0: (pid#%li) "
+                        dprintkdbg(DBG_0, "msgin_phase0: (0x%p) "
                                 "SAVE POINTER rem=%i Ignore\n",
-                                srb->cmd->serial_number, srb->total_xfer_length);
+                                srb->cmd, srb->total_xfer_length);
                         break;
 
                 case RESTORE_POINTERS:
@@ -2941,9 +2940,9 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                         break;
 
                 case ABORT:
-                        dprintkdbg(DBG_0, "msgin_phase0: (pid#%li) "
+                        dprintkdbg(DBG_0, "msgin_phase0: (0x%p) "
                                 "<%02i-%i> ABORT msg\n",
-                                srb->cmd->serial_number, dcb->target_id,
+                                srb->cmd, dcb->target_id,
                                 dcb->target_lun);
                         dcb->flag |= ABORT_DEV_;
                         enable_msgout_abort(acb, srb);
@@ -2975,7 +2974,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 static void msgin_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "msgin_phase1: (pid#%li)\n", srb->cmd->serial_number);
+        dprintkdbg(DBG_0, "msgin_phase1: (0x%p)\n", srb->cmd);
         clear_fifo(acb, "msgin_phase1");
         DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, 1);
         if (!(srb->state & SRB_MSGIN)) {
@@ -3041,7 +3040,7 @@ static void disconnect(struct AdapterCtlBlk *acb)
         }
         srb = dcb->active_srb;
         acb->active_dcb = NULL;
-        dprintkdbg(DBG_0, "disconnect: (pid#%li)\n", srb->cmd->serial_number);
+        dprintkdbg(DBG_0, "disconnect: (0x%p)\n", srb->cmd);
 
         srb->scsi_phase = PH_BUS_FREE;  /* initial phase */
         clear_fifo(acb, "disconnect");
@@ -3071,14 +3070,14 @@ static void disconnect(struct AdapterCtlBlk *acb)
                             && srb->state != SRB_MSGOUT) {
                                 srb->state = SRB_READY;
                                 dprintkl(KERN_DEBUG,
-                                        "disconnect: (pid#%li) Unexpected\n",
-                                        srb->cmd->serial_number);
+                                        "disconnect: (0x%p) Unexpected\n",
+                                        srb->cmd);
                                 srb->target_status = SCSI_STAT_SEL_TIMEOUT;
                                 goto disc1;
                         } else {
                                 /* Normal selection timeout */
-                                dprintkdbg(DBG_KG, "disconnect: (pid#%li) "
-                                        "<%02i-%i> SelTO\n", srb->cmd->serial_number,
+                                dprintkdbg(DBG_KG, "disconnect: (0x%p) "
+                                        "<%02i-%i> SelTO\n", srb->cmd,
                                         dcb->target_id, dcb->target_lun);
                                 if (srb->retry_count++ > DC395x_MAX_RETRIES
                                     || acb->scan_devices) {
@@ -3089,8 +3088,8 @@ static void disconnect(struct AdapterCtlBlk *acb)
                                 free_tag(dcb, srb);
                                 srb_going_to_waiting_move(dcb, srb);
                                 dprintkdbg(DBG_KG,
-                                        "disconnect: (pid#%li) Retry\n",
-                                        srb->cmd->serial_number);
+                                        "disconnect: (0x%p) Retry\n",
+                                        srb->cmd);
                                 waiting_set_timer(acb, HZ / 20);
                         }
                 } else if (srb->state & SRB_DISCONNECT) {
@@ -3142,9 +3141,9 @@ static void reselect(struct AdapterCtlBlk *acb)
                 }
                 /* Why the if ? */
                 if (!acb->scan_devices) {
-                        dprintkdbg(DBG_KG, "reselect: (pid#%li) <%02i-%i> "
+                        dprintkdbg(DBG_KG, "reselect: (0x%p) <%02i-%i> "
                                 "Arb lost but Resel win rsel=%i stat=0x%04x\n",
-                                srb->cmd->serial_number, dcb->target_id,
+                                srb->cmd, dcb->target_id,
                                 dcb->target_lun, rsel_tar_lun_id,
                                 DC395x_read16(acb, TRM_S1040_SCSI_STATUS));
                         arblostflag = 1;
@@ -3318,7 +3317,7 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
         enum dma_data_direction dir = cmd->sc_data_direction;
         int ckc_only = 1;
 
-        dprintkdbg(DBG_1, "srb_done: (pid#%li) <%02i-%i>\n", srb->cmd->serial_number,
+        dprintkdbg(DBG_1, "srb_done: (0x%p) <%02i-%i>\n", srb->cmd,
                 srb->cmd->device->id, srb->cmd->device->lun);
         dprintkdbg(DBG_SG, "srb_done: srb=%p sg=%i(%i/%i) buf=%p\n",
                    srb, scsi_sg_count(cmd), srb->sg_index, srb->sg_count,
@@ -3497,9 +3496,9 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
         cmd->SCp.buffers_residual = 0;
         if (debug_enabled(DBG_KG)) {
                 if (srb->total_xfer_length)
-                        dprintkdbg(DBG_KG, "srb_done: (pid#%li) <%02i-%i> "
+                        dprintkdbg(DBG_KG, "srb_done: (0x%p) <%02i-%i> "
                                 "cmnd=0x%02x Missed %i bytes\n",
-                                cmd->serial_number, cmd->device->id, cmd->device->lun,
+                                cmd, cmd->device->id, cmd->device->lun,
                                 cmd->cmnd[0], srb->total_xfer_length);
         }
 
@@ -3508,8 +3507,8 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
         if (srb == acb->tmp_srb)
                 dprintkl(KERN_ERR, "srb_done: ERROR! Completed cmd with tmp_srb\n");
         else {
-                dprintkdbg(DBG_0, "srb_done: (pid#%li) done result=0x%08x\n",
-                        cmd->serial_number, cmd->result);
+                dprintkdbg(DBG_0, "srb_done: (0x%p) done result=0x%08x\n",
+                        cmd, cmd->result);
                 srb_free_insert(acb, srb);
         }
         pci_unmap_srb(acb, srb);
@@ -3538,7 +3537,7 @@ static void doing_srb_done(struct AdapterCtlBlk *acb, u8 did_flag,
                         p = srb->cmd;
                         dir = p->sc_data_direction;
                         result = MK_RES(0, did_flag, 0, 0);
-                        printk("G:%li(%02i-%i) ", p->serial_number,
+                        printk("G:%p(%02i-%i) ", p,
                                p->device->id, p->device->lun);
                         srb_going_remove(dcb, srb);
                         free_tag(dcb, srb);
@@ -3568,7 +3567,7 @@ static void doing_srb_done(struct AdapterCtlBlk *acb, u8 did_flag,
                         p = srb->cmd;
 
                         result = MK_RES(0, did_flag, 0, 0);
-                        printk("W:%li<%02i-%i>", p->serial_number, p->device->id,
+                        printk("W:%p<%02i-%i>", p, p->device->id,
                                p->device->lun);
                         srb_waiting_remove(dcb, srb);
                         srb_free_insert(acb, srb);
@@ -3677,8 +3676,8 @@ static void request_sense(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
                 struct ScsiReqBlk *srb)
 {
         struct scsi_cmnd *cmd = srb->cmd;
-        dprintkdbg(DBG_1, "request_sense: (pid#%li) <%02i-%i>\n",
-                cmd->serial_number, cmd->device->id, cmd->device->lun);
+        dprintkdbg(DBG_1, "request_sense: (0x%p) <%02i-%i>\n",
+                cmd, cmd->device->id, cmd->device->lun);
 
         srb->flag |= AUTO_REQSENSE;
         srb->adapter_status = 0;
@@ -3708,8 +3707,8 @@ static void request_sense(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
 
         if (start_scsi(acb, dcb, srb)) {        /* Should only happen, if sb. else grabs the bus */
                 dprintkl(KERN_DEBUG,
-                        "request_sense: (pid#%li) failed <%02i-%i>\n",
-                        srb->cmd->serial_number, dcb->target_id, dcb->target_lun);
+                        "request_sense: (0x%p) failed <%02i-%i>\n",
+                        srb->cmd, dcb->target_id, dcb->target_lun);
                 srb_going_to_waiting_move(dcb, srb);
                 waiting_set_timer(acb, HZ / 100);
         }
@@ -4717,13 +4716,13 @@ static int dc395x_proc_info(struct Scsi_Host *host, char *buffer,
                                 dcb->target_id, dcb->target_lun,
                                 list_size(&dcb->srb_waiting_list));
                 list_for_each_entry(srb, &dcb->srb_waiting_list, list)
-                        SPRINTF(" %li", srb->cmd->serial_number);
+                        SPRINTF(" %p", srb->cmd);
                 if (!list_empty(&dcb->srb_going_list))
                         SPRINTF("\nDCB (%02i-%i): Going  : %i:",
                                 dcb->target_id, dcb->target_lun,
                                 list_size(&dcb->srb_going_list));
                 list_for_each_entry(srb, &dcb->srb_going_list, list)
-                        SPRINTF(" %li", srb->cmd->serial_number);
+                        SPRINTF(" %p", srb->cmd);
                 if (!list_empty(&dcb->srb_waiting_list) || !list_empty(&dcb->srb_going_list))
                         SPRINTF("\n");
         }
diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c
index 42fe52902add..6fec9fe5dc39 100644
--- a/drivers/scsi/device_handler/scsi_dh_alua.c
+++ b/drivers/scsi/device_handler/scsi_dh_alua.c
@@ -782,7 +782,7 @@ static int alua_bus_attach(struct scsi_device *sdev)
         h->sdev = sdev;
 
         err = alua_initialize(sdev, h);
-        if (err != SCSI_DH_OK)
+        if ((err != SCSI_DH_OK) && (err != SCSI_DH_DEV_OFFLINED))
                 goto failed;
 
         if (!try_module_get(THIS_MODULE))
diff --git a/drivers/scsi/device_handler/scsi_dh_rdac.c b/drivers/scsi/device_handler/scsi_dh_rdac.c
index 293c183dfe6d..e7fc70d6b478 100644
--- a/drivers/scsi/device_handler/scsi_dh_rdac.c
+++ b/drivers/scsi/device_handler/scsi_dh_rdac.c
@@ -182,14 +182,24 @@ struct rdac_dh_data {
         struct rdac_controller  *ctlr;
 #define UNINITIALIZED_LUN       (1 << 8)
         unsigned                lun;
+
+#define RDAC_MODE               0
+#define RDAC_MODE_AVT           1
+#define RDAC_MODE_IOSHIP        2
+        unsigned char           mode;
+
 #define RDAC_STATE_ACTIVE       0
 #define RDAC_STATE_PASSIVE      1
         unsigned char           state;
 
 #define RDAC_LUN_UNOWNED        0
 #define RDAC_LUN_OWNED          1
-#define RDAC_LUN_AVT            2
         char                    lun_state;
+
+#define RDAC_PREFERRED          0
+#define RDAC_NON_PREFERRED      1
+        char                    preferred;
+
         unsigned char           sense[SCSI_SENSE_BUFFERSIZE];
         union                   {
                 struct c2_inquiry c2;
@@ -199,11 +209,15 @@ struct rdac_dh_data {
         } inq;
 };
 
+static const char *mode[] = {
+        "RDAC",
+        "AVT",
+        "IOSHIP",
+};
 static const char *lun_state[] =
 {
         "unowned",
         "owned",
-        "owned (AVT mode)",
 };
 
 struct rdac_queue_data {
@@ -458,25 +472,33 @@ static int check_ownership(struct scsi_device *sdev, struct rdac_dh_data *h)
         int err;
         struct c9_inquiry *inqp;
 
-        h->lun_state = RDAC_LUN_UNOWNED;
         h->state = RDAC_STATE_ACTIVE;
         err = submit_inquiry(sdev, 0xC9, sizeof(struct c9_inquiry), h);
         if (err == SCSI_DH_OK) {
                 inqp = &h->inq.c9;
-                if ((inqp->avte_cvp >> 7) == 0x1) {
-                        /* LUN in AVT mode */
-                        sdev_printk(KERN_NOTICE, sdev,
-                                    "%s: AVT mode detected\n",
-                                    RDAC_NAME);
-                        h->lun_state = RDAC_LUN_AVT;
-                } else if ((inqp->avte_cvp & 0x1) != 0) {
-                        /* LUN was owned by the controller */
+                /* detect the operating mode */
+                if ((inqp->avte_cvp >> 5) & 0x1)
+                        h->mode = RDAC_MODE_IOSHIP; /* LUN in IOSHIP mode */
+                else if (inqp->avte_cvp >> 7)
+                        h->mode = RDAC_MODE_AVT; /* LUN in AVT mode */
+                else
+                        h->mode = RDAC_MODE; /* LUN in RDAC mode */
+
+                /* Update ownership */
+                if (inqp->avte_cvp & 0x1)
                         h->lun_state = RDAC_LUN_OWNED;
+                else {
+                        h->lun_state = RDAC_LUN_UNOWNED;
+                        if (h->mode == RDAC_MODE)
+                                h->state = RDAC_STATE_PASSIVE;
                 }
-        }
 
-        if (h->lun_state == RDAC_LUN_UNOWNED)
-                h->state = RDAC_STATE_PASSIVE;
+                /* Update path prio*/
+                if (inqp->path_prio & 0x1)
+                        h->preferred = RDAC_PREFERRED;
+                else
+                        h->preferred = RDAC_NON_PREFERRED;
+        }
 
         return err;
 }
@@ -648,12 +670,27 @@ static int rdac_activate(struct scsi_device *sdev,
 {
         struct rdac_dh_data *h = get_rdac_data(sdev);
         int err = SCSI_DH_OK;
+        int act = 0;
 
         err = check_ownership(sdev, h);
         if (err != SCSI_DH_OK)
                 goto done;
 
-        if (h->lun_state == RDAC_LUN_UNOWNED) {
+        switch (h->mode) {
+        case RDAC_MODE:
+                if (h->lun_state == RDAC_LUN_UNOWNED)
+                        act = 1;
+                break;
+        case RDAC_MODE_IOSHIP:
+                if ((h->lun_state == RDAC_LUN_UNOWNED) &&
+                    (h->preferred == RDAC_PREFERRED))
+                        act = 1;
+                break;
+        default:
+                break;
+        }
+
+        if (act) {
                 err = queue_mode_select(sdev, fn, data);
                 if (err == SCSI_DH_OK)
                         return 0;
@@ -836,8 +873,9 @@ static int rdac_bus_attach(struct scsi_device *sdev)
         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 
         sdev_printk(KERN_NOTICE, sdev,
-                    "%s: LUN %d (%s)\n",
-                    RDAC_NAME, h->lun, lun_state[(int)h->lun_state]);
+                    "%s: LUN %d (%s) (%s)\n",
+                    RDAC_NAME, h->lun, mode[(int)h->mode],
+                    lun_state[(int)h->lun_state]);
 
         return 0;
 
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index cffcb108ac96..b4f6c9a84e71 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -780,7 +780,7 @@ static int adpt_abort(struct scsi_cmnd * cmd)
                 return FAILED;
         }
         pHba = (adpt_hba*) cmd->device->host->hostdata[0];
-        printk(KERN_INFO"%s: Trying to Abort cmd=%ld\n",pHba->name, cmd->serial_number);
+        printk(KERN_INFO"%s: Trying to Abort\n",pHba->name);
         if ((dptdevice = (void*) (cmd->device->hostdata)) == NULL) {
                 printk(KERN_ERR "%s: Unable to abort: No device in cmnd\n",pHba->name);
                 return FAILED;
@@ -802,10 +802,10 @@ static int adpt_abort(struct scsi_cmnd * cmd)
                         printk(KERN_INFO"%s: Abort cmd not supported\n",pHba->name);
                         return FAILED;
                 }
-                printk(KERN_INFO"%s: Abort cmd=%ld failed.\n",pHba->name, cmd->serial_number);
+                printk(KERN_INFO"%s: Abort failed.\n",pHba->name);
                 return FAILED;
         } 
-        printk(KERN_INFO"%s: Abort cmd=%ld complete.\n",pHba->name, cmd->serial_number);
+        printk(KERN_INFO"%s: Abort complete.\n",pHba->name);
         return SUCCESS;
 }
 
diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index 0eb4fe6a4c8a..94de88955a99 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -1766,8 +1766,8 @@ static int eata2x_queuecommand_lck(struct scsi_cmnd *SCpnt,
         struct mscp *cpp;
 
         if (SCpnt->host_scribble)
-                panic("%s: qcomm, pid %ld, SCpnt %p already active.\n",
-                      ha->board_name, SCpnt->serial_number, SCpnt);
+                panic("%s: qcomm, SCpnt %p already active.\n",
+                      ha->board_name, SCpnt);
 
         /* i is the mailbox number, look for the first free mailbox
            starting from last_cp_used */
@@ -1801,7 +1801,7 @@ static int eata2x_queuecommand_lck(struct scsi_cmnd *SCpnt,
 
         if (do_trace)
                 scmd_printk(KERN_INFO, SCpnt,
-                        "qcomm, mbox %d, pid %ld.\n", i, SCpnt->serial_number);
+                        "qcomm, mbox %d.\n", i);
 
         cpp->reqsen = 1;
         cpp->dispri = 1;
@@ -1833,8 +1833,7 @@ static int eata2x_queuecommand_lck(struct scsi_cmnd *SCpnt,
         if (do_dma(shost->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
                 unmap_dma(i, ha);
                 SCpnt->host_scribble = NULL;
-                scmd_printk(KERN_INFO, SCpnt,
-                        "qcomm, pid %ld, adapter busy.\n", SCpnt->serial_number);
+                scmd_printk(KERN_INFO, SCpnt, "qcomm, adapter busy.\n");
                 return 1;
         }
 
@@ -1851,14 +1850,12 @@ static int eata2x_eh_abort(struct scsi_cmnd *SCarg)
         unsigned int i;
 
         if (SCarg->host_scribble == NULL) {
-                scmd_printk(KERN_INFO, SCarg,
-                        "abort, pid %ld inactive.\n", SCarg->serial_number);
+                scmd_printk(KERN_INFO, SCarg, "abort, cmd inactive.\n");
                 return SUCCESS;
         }
 
         i = *(unsigned int *)SCarg->host_scribble;
-        scmd_printk(KERN_WARNING, SCarg,
-                "abort, mbox %d, pid %ld.\n", i, SCarg->serial_number);
+        scmd_printk(KERN_WARNING, SCarg, "abort, mbox %d.\n", i);
 
         if (i >= shost->can_queue)
                 panic("%s: abort, invalid SCarg->host_scribble.\n", ha->board_name);
@@ -1902,8 +1899,8 @@ static int eata2x_eh_abort(struct scsi_cmnd *SCarg)
                 SCarg->result = DID_ABORT << 16;
                 SCarg->host_scribble = NULL;
                 ha->cp_stat[i] = FREE;
-                printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n",
-                       ha->board_name, i, SCarg->serial_number);
+                printk("%s, abort, mbox %d ready, DID_ABORT, done.\n",
+                       ha->board_name, i);
                 SCarg->scsi_done(SCarg);
                 return SUCCESS;
         }
@@ -1919,13 +1916,12 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
         struct Scsi_Host *shost = SCarg->device->host;
         struct hostdata *ha = (struct hostdata *)shost->hostdata;
 
-        scmd_printk(KERN_INFO, SCarg,
-                "reset, enter, pid %ld.\n", SCarg->serial_number);
+        scmd_printk(KERN_INFO, SCarg, "reset, enter.\n");
 
         spin_lock_irq(shost->host_lock);
 
         if (SCarg->host_scribble == NULL)
-                printk("%s: reset, pid %ld inactive.\n", ha->board_name, SCarg->serial_number);
+                printk("%s: reset, inactive.\n", ha->board_name);
 
         if (ha->in_reset) {
                 printk("%s: reset, exit, already in reset.\n", ha->board_name);
@@ -1964,14 +1960,14 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
 
                 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
                         ha->cp_stat[i] = ABORTING;
-                        printk("%s: reset, mbox %d aborting, pid %ld.\n",
-                               ha->board_name, i, SCpnt->serial_number);
+                        printk("%s: reset, mbox %d aborting.\n",
+                               ha->board_name, i);
                 }
 
                 else {
                         ha->cp_stat[i] = IN_RESET;
-                        printk("%s: reset, mbox %d in reset, pid %ld.\n",
-                               ha->board_name, i, SCpnt->serial_number);
+                        printk("%s: reset, mbox %d in reset.\n",
+                               ha->board_name, i);
                 }
 
                 if (SCpnt->host_scribble == NULL)
@@ -2025,8 +2021,8 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
                         ha->cp_stat[i] = LOCKED;
 
                         printk
-                            ("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n",
-                             ha->board_name, i, SCpnt->serial_number);
+                            ("%s, reset, mbox %d locked, DID_RESET, done.\n",
+                             ha->board_name, i);
                 }
 
                 else if (ha->cp_stat[i] == ABORTING) {
@@ -2039,8 +2035,8 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
                         ha->cp_stat[i] = FREE;
 
                         printk
-                            ("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n",
-                             ha->board_name, i, SCpnt->serial_number);
+                            ("%s, reset, mbox %d aborting, DID_RESET, done.\n",
+                             ha->board_name, i);
                 }
 
                 else
@@ -2054,7 +2050,7 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
         do_trace = 0;
 
         if (arg_done)
-                printk("%s: reset, exit, pid %ld done.\n", ha->board_name, SCarg->serial_number);
+                printk("%s: reset, exit, done.\n", ha->board_name);
         else
                 printk("%s: reset, exit.\n", ha->board_name);
 
@@ -2238,10 +2234,10 @@ static int reorder(struct hostdata *ha, unsigned long cursec,
                         cpp = &ha->cp[k];
                         SCpnt = cpp->SCpnt;
                         scmd_printk(KERN_INFO, SCpnt,
-                            "%s pid %ld mb %d fc %d nr %d sec %ld ns %u"
+                            "%s mb %d fc %d nr %d sec %ld ns %u"
                              " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
                              (ihdlr ? "ihdlr" : "qcomm"),
-                             SCpnt->serial_number, k, flushcount,
+                             k, flushcount,
                              n_ready, blk_rq_pos(SCpnt->request),
                              blk_rq_sectors(SCpnt->request), cursec, YESNO(s),
                              YESNO(r), YESNO(rev), YESNO(input_only),
@@ -2285,10 +2281,10 @@ static void flush_dev(struct scsi_device *dev, unsigned long cursec,
 
                 if (do_dma(dev->host->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
                         scmd_printk(KERN_INFO, SCpnt,
-                            "%s, pid %ld, mbox %d, adapter"
+                            "%s, mbox %d, adapter"
                              " busy, will abort.\n",
                              (ihdlr ? "ihdlr" : "qcomm"),
-                             SCpnt->serial_number, k);
+                             k);
                         ha->cp_stat[k] = ABORTING;
                         continue;
                 }
@@ -2398,12 +2394,12 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
                 panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
 
         if (SCpnt->host_scribble == NULL)
-                panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", ha->board_name,
-                      i, SCpnt->serial_number, SCpnt);
+                panic("%s: ihdlr, mbox %d, SCpnt %p garbled.\n", ha->board_name,
+                      i, SCpnt);
 
         if (*(unsigned int *)SCpnt->host_scribble != i)
-                panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n",
-                      ha->board_name, i, SCpnt->serial_number,
+                panic("%s: ihdlr, mbox %d, index mismatch %d.\n",
+                      ha->board_name, i,
                       *(unsigned int *)SCpnt->host_scribble);
 
         sync_dma(i, ha);
@@ -2449,11 +2445,11 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
                 if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
                     (!(tstatus == CHECK_CONDITION && ha->iocount <= 1000 &&
                        (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
-                        printk("%s: ihdlr, target %d.%d:%d, pid %ld, "
+                        printk("%s: ihdlr, target %d.%d:%d, "
                                "target_status 0x%x, sense key 0x%x.\n",
                                ha->board_name,
                                SCpnt->device->channel, SCpnt->device->id,
-                               SCpnt->device->lun, SCpnt->serial_number,
+                               SCpnt->device->lun,
                                spp->target_status, SCpnt->sense_buffer[2]);
 
                 ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0;
@@ -2522,9 +2518,9 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
             do_trace || msg_byte(spp->target_status))
 #endif
                 scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"
-                       " pid %ld, reg 0x%x, count %d.\n",
+                       " reg 0x%x, count %d.\n",
                        i, spp->adapter_status, spp->target_status,
-                       SCpnt->serial_number, reg, ha->iocount);
+                       reg, ha->iocount);
 
         unmap_dma(i, ha);
 
diff --git a/drivers/scsi/eata_pio.c b/drivers/scsi/eata_pio.c
index 4a9641e69f54..d5f8362335d3 100644
--- a/drivers/scsi/eata_pio.c
+++ b/drivers/scsi/eata_pio.c
@@ -372,8 +372,7 @@ static int eata_pio_queue_lck(struct scsi_cmnd *cmd,
         cp->status = USED;      /* claim free slot */
 
         DBG(DBG_QUEUE, scmd_printk(KERN_DEBUG, cmd,
-                "eata_pio_queue pid %ld, y %d\n",
-                cmd->serial_number, y));
+                "eata_pio_queue 0x%p, y %d\n", cmd, y));
 
         cmd->scsi_done = (void *) done;
 
@@ -417,8 +416,8 @@ static int eata_pio_queue_lck(struct scsi_cmnd *cmd,
         if (eata_pio_send_command(base, EATA_CMD_PIO_SEND_CP)) {
                 cmd->result = DID_BUS_BUSY << 16;
                 scmd_printk(KERN_NOTICE, cmd,
-                        "eata_pio_queue pid %ld, HBA busy, "
-                        "returning DID_BUS_BUSY, done.\n", cmd->serial_number);
+                        "eata_pio_queue pid 0x%p, HBA busy, "
+                        "returning DID_BUS_BUSY, done.\n", cmd);
                 done(cmd);
                 cp->status = FREE;
                 return 0;
@@ -432,8 +431,8 @@ static int eata_pio_queue_lck(struct scsi_cmnd *cmd,
                 outw(0, base + HA_RDATA);
 
         DBG(DBG_QUEUE, scmd_printk(KERN_DEBUG, cmd,
-                "Queued base %#.4lx pid: %ld "
-                "slot %d irq %d\n", sh->base, cmd->serial_number, y, sh->irq));
+                "Queued base %#.4lx cmd: 0x%p "
+                "slot %d irq %d\n", sh->base, cmd, y, sh->irq));
 
         return 0;
 }
@@ -445,8 +444,7 @@ static int eata_pio_abort(struct scsi_cmnd *cmd)
         unsigned int loop = 100;
 
         DBG(DBG_ABNORM, scmd_printk(KERN_WARNING, cmd,
-                "eata_pio_abort called pid: %ld\n",
-                cmd->serial_number));
+                "eata_pio_abort called pid: 0x%p\n", cmd));
 
         while (inb(cmd->device->host->base + HA_RAUXSTAT) & HA_ABUSY)
                 if (--loop == 0) {
@@ -481,8 +479,7 @@ static int eata_pio_host_reset(struct scsi_cmnd *cmd)
         struct Scsi_Host *host = cmd->device->host;
 
         DBG(DBG_ABNORM, scmd_printk(KERN_WARNING, cmd,
-                "eata_pio_reset called pid:%ld\n",
-                cmd->serial_number));
+                "eata_pio_reset called\n"));
 
         spin_lock_irq(host->host_lock);
 
@@ -501,7 +498,7 @@ static int eata_pio_host_reset(struct scsi_cmnd *cmd)
 
                 sp = HD(cmd)->ccb[x].cmd;
                 HD(cmd)->ccb[x].status = RESET;
-                printk(KERN_WARNING "eata_pio_reset: slot %d in reset, pid %ld.\n", x, sp->serial_number);
+                printk(KERN_WARNING "eata_pio_reset: slot %d in reset.\n", x);
 
                 if (sp == NULL)
                         panic("eata_pio_reset: slot %d, sp==NULL.\n", x);
diff --git a/drivers/scsi/esp_scsi.c b/drivers/scsi/esp_scsi.c
index 57558523c1b8..9a1af1d6071a 100644
--- a/drivers/scsi/esp_scsi.c
+++ b/drivers/scsi/esp_scsi.c
@@ -708,8 +708,7 @@ static void esp_maybe_execute_command(struct esp *esp)
         tp = &esp->target[tgt];
         lp = dev->hostdata;
 
-        list_del(&ent->list);
-        list_add(&ent->list, &esp->active_cmds);
+        list_move(&ent->list, &esp->active_cmds);
 
         esp->active_cmd = ent;
 
@@ -1244,8 +1243,7 @@ static int esp_finish_select(struct esp *esp)
                 /* Now that the state is unwound properly, put back onto
                  * the issue queue.  This command is no longer active.
                  */
-                list_del(&ent->list);
-                list_add(&ent->list, &esp->queued_cmds);
+                list_move(&ent->list, &esp->queued_cmds);
                 esp->active_cmd = NULL;
 
                 /* Return value ignored by caller, it directly invokes
diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c
index bde6ee5333eb..5d3700dc6f8c 100644
--- a/drivers/scsi/fcoe/fcoe.c
+++ b/drivers/scsi/fcoe/fcoe.c
@@ -381,6 +381,42 @@ out:
 }
 
 /**
+ * fcoe_interface_release() - fcoe_port kref release function
+ * @kref: Embedded reference count in an fcoe_interface struct
+ */
+static void fcoe_interface_release(struct kref *kref)
+{
+        struct fcoe_interface *fcoe;
+        struct net_device *netdev;
+
+        fcoe = container_of(kref, struct fcoe_interface, kref);
+        netdev = fcoe->netdev;
+        /* tear-down the FCoE controller */
+        fcoe_ctlr_destroy(&fcoe->ctlr);
+        kfree(fcoe);
+        dev_put(netdev);
+        module_put(THIS_MODULE);
+}
+
+/**
+ * fcoe_interface_get() - Get a reference to a FCoE interface
+ * @fcoe: The FCoE interface to be held
+ */
+static inline void fcoe_interface_get(struct fcoe_interface *fcoe)
+{
+        kref_get(&fcoe->kref);
+}
+
+/**
+ * fcoe_interface_put() - Put a reference to a FCoE interface
+ * @fcoe: The FCoE interface to be released
+ */
+static inline void fcoe_interface_put(struct fcoe_interface *fcoe)
+{
+        kref_put(&fcoe->kref, fcoe_interface_release);
+}
+
+/**
  * fcoe_interface_cleanup() - Clean up a FCoE interface
  * @fcoe: The FCoE interface to be cleaned up
  *
@@ -392,6 +428,21 @@ void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
         struct fcoe_ctlr *fip = &fcoe->ctlr;
         u8 flogi_maddr[ETH_ALEN];
         const struct net_device_ops *ops;
+        struct fcoe_port *port = lport_priv(fcoe->ctlr.lp);
+
+        FCOE_NETDEV_DBG(netdev, "Destroying interface\n");
+
+        /* Logout of the fabric */
+        fc_fabric_logoff(fcoe->ctlr.lp);
+
+        /* Cleanup the fc_lport */
+        fc_lport_destroy(fcoe->ctlr.lp);
+
+        /* Stop the transmit retry timer */
+        del_timer_sync(&port->timer);
+
+        /* Free existing transmit skbs */
+        fcoe_clean_pending_queue(fcoe->ctlr.lp);
 
         /*
          * Don't listen for Ethernet packets anymore.
@@ -414,6 +465,9 @@ void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
         } else
                 dev_mc_del(netdev, FIP_ALL_ENODE_MACS);
 
+        if (!is_zero_ether_addr(port->data_src_addr))
+                dev_uc_del(netdev, port->data_src_addr);
+
         /* Tell the LLD we are done w/ FCoE */
         ops = netdev->netdev_ops;
         if (ops->ndo_fcoe_disable) {
@@ -421,42 +475,7 @@ void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
                         FCOE_NETDEV_DBG(netdev, "Failed to disable FCoE"
                                         " specific feature for LLD.\n");
         }
-}
-
-/**
- * fcoe_interface_release() - fcoe_port kref release function
- * @kref: Embedded reference count in an fcoe_interface struct
- */
-static void fcoe_interface_release(struct kref *kref)
-{
-        struct fcoe_interface *fcoe;
-        struct net_device *netdev;
-
-        fcoe = container_of(kref, struct fcoe_interface, kref);
-        netdev = fcoe->netdev;
-        /* tear-down the FCoE controller */
-        fcoe_ctlr_destroy(&fcoe->ctlr);
-        kfree(fcoe);
-        dev_put(netdev);
-        module_put(THIS_MODULE);
-}
-
-/**
- * fcoe_interface_get() - Get a reference to a FCoE interface
- * @fcoe: The FCoE interface to be held
- */
-static inline void fcoe_interface_get(struct fcoe_interface *fcoe)
-{
-        kref_get(&fcoe->kref);
-}
-
-/**
- * fcoe_interface_put() - Put a reference to a FCoE interface
- * @fcoe: The FCoE interface to be released
- */
-static inline void fcoe_interface_put(struct fcoe_interface *fcoe)
-{
-        kref_put(&fcoe->kref, fcoe_interface_release);
+        fcoe_interface_put(fcoe);
 }
 
 /**
@@ -821,39 +840,9 @@ skip_oem:
  * fcoe_if_destroy() - Tear down a SW FCoE instance
  * @lport: The local port to be destroyed
  *
- * Locking: must be called with the RTNL mutex held and RTNL mutex
- * needed to be dropped by this function since not dropping RTNL
- * would cause circular locking warning on synchronous fip worker
- * cancelling thru fcoe_interface_put invoked by this function.
- *
  */
 static void fcoe_if_destroy(struct fc_lport *lport)
 {
-        struct fcoe_port *port = lport_priv(lport);
-        struct fcoe_interface *fcoe = port->priv;
-        struct net_device *netdev = fcoe->netdev;
-
-        FCOE_NETDEV_DBG(netdev, "Destroying interface\n");
-
-        /* Logout of the fabric */
-        fc_fabric_logoff(lport);
-
-        /* Cleanup the fc_lport */
-        fc_lport_destroy(lport);
-
-        /* Stop the transmit retry timer */
-        del_timer_sync(&port->timer);
-
-        /* Free existing transmit skbs */
-        fcoe_clean_pending_queue(lport);
-
-        if (!is_zero_ether_addr(port->data_src_addr))
-                dev_uc_del(netdev, port->data_src_addr);
-        rtnl_unlock();
-
-        /* receives may not be stopped until after this */
-        fcoe_interface_put(fcoe);
-
         /* Free queued packets for the per-CPU receive threads */
         fcoe_percpu_clean(lport);
 
@@ -1783,23 +1772,8 @@ static int fcoe_disable(struct net_device *netdev)
         int rc = 0;
 
         mutex_lock(&fcoe_config_mutex);
-#ifdef CONFIG_FCOE_MODULE
-        /*
-         * Make sure the module has been initialized, and is not about to be
-         * removed.  Module paramter sysfs files are writable before the
-         * module_init function is called and after module_exit.
-         */
-        if (THIS_MODULE->state != MODULE_STATE_LIVE) {
-                rc = -ENODEV;
-                goto out_nodev;
-        }
-#endif
-
-        if (!rtnl_trylock()) {
-                mutex_unlock(&fcoe_config_mutex);
-                return -ERESTARTSYS;
-        }
 
+        rtnl_lock();
         fcoe = fcoe_hostlist_lookup_port(netdev);
         rtnl_unlock();
 
@@ -1809,7 +1783,6 @@ static int fcoe_disable(struct net_device *netdev)
         } else
                 rc = -ENODEV;
 
-out_nodev:
         mutex_unlock(&fcoe_config_mutex);
         return rc;
 }
@@ -1828,22 +1801,7 @@ static int fcoe_enable(struct net_device *netdev)
         int rc = 0;
 
         mutex_lock(&fcoe_config_mutex);
-#ifdef CONFIG_FCOE_MODULE
-        /*
-         * Make sure the module has been initialized, and is not about to be
-         * removed.  Module paramter sysfs files are writable before the
-         * module_init function is called and after module_exit.
-         */
-        if (THIS_MODULE->state != MODULE_STATE_LIVE) {
-                rc = -ENODEV;
-                goto out_nodev;
-        }
-#endif
-        if (!rtnl_trylock()) {
-                mutex_unlock(&fcoe_config_mutex);
-                return -ERESTARTSYS;
-        }
-
+        rtnl_lock();
         fcoe = fcoe_hostlist_lookup_port(netdev);
         rtnl_unlock();
 
@@ -1852,7 +1810,6 @@ static int fcoe_enable(struct net_device *netdev)
         else if (!fcoe_link_ok(fcoe->ctlr.lp))
                 fcoe_ctlr_link_up(&fcoe->ctlr);
 
-out_nodev:
         mutex_unlock(&fcoe_config_mutex);
         return rc;
 }
@@ -1868,35 +1825,22 @@ out_nodev:
 static int fcoe_destroy(struct net_device *netdev)
 {
         struct fcoe_interface *fcoe;
+        struct fc_lport *lport;
         int rc = 0;
 
         mutex_lock(&fcoe_config_mutex);
-#ifdef CONFIG_FCOE_MODULE
-        /*
-         * Make sure the module has been initialized, and is not about to be
-         * removed.  Module paramter sysfs files are writable before the
-         * module_init function is called and after module_exit.
-         */
-        if (THIS_MODULE->state != MODULE_STATE_LIVE) {
-                rc = -ENODEV;
-                goto out_nodev;
-        }
-#endif
-        if (!rtnl_trylock()) {
-                mutex_unlock(&fcoe_config_mutex);
-                return -ERESTARTSYS;
-        }
-
+        rtnl_lock();
         fcoe = fcoe_hostlist_lookup_port(netdev);
         if (!fcoe) {
                 rtnl_unlock();
                 rc = -ENODEV;
                 goto out_nodev;
         }
-        fcoe_interface_cleanup(fcoe);
+        lport = fcoe->ctlr.lp;
         list_del(&fcoe->list);
-        /* RTNL mutex is dropped by fcoe_if_destroy */
-        fcoe_if_destroy(fcoe->ctlr.lp);
+        fcoe_interface_cleanup(fcoe);
+        rtnl_unlock();
+        fcoe_if_destroy(lport);
 out_nodev:
         mutex_unlock(&fcoe_config_mutex);
         return rc;
@@ -1912,8 +1856,6 @@ static void fcoe_destroy_work(struct work_struct *work)
 
         port = container_of(work, struct fcoe_port, destroy_work);
         mutex_lock(&fcoe_config_mutex);
-        rtnl_lock();
-        /* RTNL mutex is dropped by fcoe_if_destroy */
         fcoe_if_destroy(port->lport);
         mutex_unlock(&fcoe_config_mutex);
 }
@@ -1948,23 +1890,7 @@ static int fcoe_create(struct net_device *netdev, enum fip_state fip_mode)
         struct fc_lport *lport;
 
         mutex_lock(&fcoe_config_mutex);
-
-        if (!rtnl_trylock()) {
-                mutex_unlock(&fcoe_config_mutex);
-                return -ERESTARTSYS;
-        }
-
-#ifdef CONFIG_FCOE_MODULE
-        /*
-         * Make sure the module has been initialized, and is not about to be
-         * removed.  Module paramter sysfs files are writable before the
-         * module_init function is called and after module_exit.
-         */
-        if (THIS_MODULE->state != MODULE_STATE_LIVE) {
-                rc = -ENODEV;
-                goto out_nodev;
-        }
-#endif
+        rtnl_lock();
 
         /* look for existing lport */
         if (fcoe_hostlist_lookup(netdev)) {
diff --git a/drivers/scsi/fcoe/fcoe_ctlr.c b/drivers/scsi/fcoe/fcoe_ctlr.c
index 9d38be2a41f9..229e4af5508a 100644
--- a/drivers/scsi/fcoe/fcoe_ctlr.c
+++ b/drivers/scsi/fcoe/fcoe_ctlr.c
@@ -978,10 +978,8 @@ static void fcoe_ctlr_recv_adv(struct fcoe_ctlr *fip, struct sk_buff *skb)
          * the FCF that answers multicast solicitations, not the others that
          * are sending periodic multicast advertisements.
          */
-        if (mtu_valid) {
-                list_del(&fcf->list);
-                list_add(&fcf->list, &fip->fcfs);
-        }
+        if (mtu_valid)
+                list_move(&fcf->list, &fip->fcfs);
 
         /*
          * If this is the first validated FCF, note the time and
diff --git a/drivers/scsi/fcoe/fcoe_transport.c b/drivers/scsi/fcoe/fcoe_transport.c
index 258684101bfd..f81f77c8569e 100644
--- a/drivers/scsi/fcoe/fcoe_transport.c
+++ b/drivers/scsi/fcoe/fcoe_transport.c
@@ -335,7 +335,7 @@ out_attach:
 EXPORT_SYMBOL(fcoe_transport_attach);
 
 /**
- * fcoe_transport_attach - Detaches an FCoE transport
+ * fcoe_transport_detach - Detaches an FCoE transport
  * @ft: The fcoe transport to be attached
  *
  * Returns : 0 for success
@@ -343,6 +343,7 @@ EXPORT_SYMBOL(fcoe_transport_attach);
 int fcoe_transport_detach(struct fcoe_transport *ft)
 {
         int rc = 0;
+        struct fcoe_netdev_mapping *nm = NULL, *tmp;
 
         mutex_lock(&ft_mutex);
         if (!ft->attached) {
@@ -352,6 +353,19 @@ int fcoe_transport_detach(struct fcoe_transport *ft)
                 goto out_attach;
         }
 
+        /* remove netdev mapping for this transport as it is going away */
+        mutex_lock(&fn_mutex);
+        list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) {
+                if (nm->ft == ft) {
+                        LIBFCOE_TRANSPORT_DBG("transport %s going away, "
+                                "remove its netdev mapping for %s\n",
+                                ft->name, nm->netdev->name);
+                        list_del(&nm->list);
+                        kfree(nm);
+                }
+        }
+        mutex_unlock(&fn_mutex);
+
         list_del(&ft->list);
         ft->attached = false;
         LIBFCOE_TRANSPORT_DBG("detaching transport %s\n", ft->name);
@@ -371,9 +385,9 @@ static int fcoe_transport_show(char *buffer, const struct kernel_param *kp)
         i = j = sprintf(buffer, "Attached FCoE transports:");
         mutex_lock(&ft_mutex);
         list_for_each_entry(ft, &fcoe_transports, list) {
-                i += snprintf(&buffer[i], IFNAMSIZ, "%s ", ft->name);
-                if (i >= PAGE_SIZE)
+                if (i >= PAGE_SIZE - IFNAMSIZ)
                         break;
+                i += snprintf(&buffer[i], IFNAMSIZ, "%s ", ft->name);
         }
         mutex_unlock(&ft_mutex);
         if (i == j)
@@ -530,9 +544,6 @@ static int fcoe_transport_create(const char *buffer, struct kernel_param *kp)
         struct fcoe_transport *ft = NULL;
         enum fip_state fip_mode = (enum fip_state)(long)kp->arg;
 
-        if (!mutex_trylock(&ft_mutex))
-                return restart_syscall();
-
 #ifdef CONFIG_LIBFCOE_MODULE
         /*
          * Make sure the module has been initialized, and is not about to be
@@ -543,6 +554,8 @@ static int fcoe_transport_create(const char *buffer, struct kernel_param *kp)
                 goto out_nodev;
 #endif
 
+        mutex_lock(&ft_mutex);
+
         netdev = fcoe_if_to_netdev(buffer);
         if (!netdev) {
                 LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buffer);
@@ -586,10 +599,7 @@ out_putdev:
         dev_put(netdev);
 out_nodev:
         mutex_unlock(&ft_mutex);
-        if (rc == -ERESTARTSYS)
-                return restart_syscall();
-        else
-                return rc;
+        return rc;
 }
 
 /**
@@ -608,9 +618,6 @@ static int fcoe_transport_destroy(const char *buffer, struct kernel_param *kp)
         struct net_device *netdev = NULL;
         struct fcoe_transport *ft = NULL;
 
-        if (!mutex_trylock(&ft_mutex))
-                return restart_syscall();
-
 #ifdef CONFIG_LIBFCOE_MODULE
         /*
          * Make sure the module has been initialized, and is not about to be
@@ -621,6 +628,8 @@ static int fcoe_transport_destroy(const char *buffer, struct kernel_param *kp)
                 goto out_nodev;
 #endif
 
+        mutex_lock(&ft_mutex);
+
         netdev = fcoe_if_to_netdev(buffer);
         if (!netdev) {
                 LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buffer);
@@ -645,11 +654,7 @@ out_putdev:
         dev_put(netdev);
 out_nodev:
         mutex_unlock(&ft_mutex);
-
-        if (rc == -ERESTARTSYS)
-                return restart_syscall();
-        else
-                return rc;
+        return rc;
 }
 
 /**
@@ -667,9 +672,6 @@ static int fcoe_transport_disable(const char *buffer, struct kernel_param *kp)
         struct net_device *netdev = NULL;
         struct fcoe_transport *ft = NULL;
 
-        if (!mutex_trylock(&ft_mutex))
-                return restart_syscall();
-
 #ifdef CONFIG_LIBFCOE_MODULE
         /*
          * Make sure the module has been initialized, and is not about to be
@@ -680,6 +682,8 @@ static int fcoe_transport_disable(const char *buffer, struct kernel_param *kp)
                 goto out_nodev;
 #endif
 
+        mutex_lock(&ft_mutex);
+
         netdev = fcoe_if_to_netdev(buffer);
         if (!netdev)
                 goto out_nodev;
@@ -716,9 +720,6 @@ static int fcoe_transport_enable(const char *buffer, struct kernel_param *kp)
         struct net_device *netdev = NULL;
         struct fcoe_transport *ft = NULL;
 
-        if (!mutex_trylock(&ft_mutex))
-                return restart_syscall();
-
 #ifdef CONFIG_LIBFCOE_MODULE
         /*
          * Make sure the module has been initialized, and is not about to be
@@ -729,6 +730,8 @@ static int fcoe_transport_enable(const char *buffer, struct kernel_param *kp)
                 goto out_nodev;
 #endif
 
+        mutex_lock(&ft_mutex);
+
         netdev = fcoe_if_to_netdev(buffer);
         if (!netdev)
                 goto out_nodev;
@@ -743,10 +746,7 @@ out_putdev:
         dev_put(netdev);
 out_nodev:
         mutex_unlock(&ft_mutex);
-        if (rc == -ERESTARTSYS)
-                return restart_syscall();
-        else
-                return rc;
+        return rc;
 }
 
 /**
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index 415ad4fb50d4..c6c0434d8034 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -273,7 +273,7 @@ static ssize_t host_show_transport_mode(struct device *dev,
                         "performant" : "simple");
 }
 
-/* List of controllers which cannot be reset on kexec with reset_devices */
+/* List of controllers which cannot be hard reset on kexec with reset_devices */
 static u32 unresettable_controller[] = {
         0x324a103C, /* Smart Array P712m */
         0x324b103C, /* SmartArray P711m */
@@ -291,16 +291,45 @@ static u32 unresettable_controller[] = {
         0x409D0E11, /* Smart Array 6400 EM */
 };
 
-static int ctlr_is_resettable(struct ctlr_info *h)
+/* List of controllers which cannot even be soft reset */
+static u32 soft_unresettable_controller[] = {
+        /* Exclude 640x boards.  These are two pci devices in one slot
+         * which share a battery backed cache module.  One controls the
+         * cache, the other accesses the cache through the one that controls
+         * it.  If we reset the one controlling the cache, the other will
+         * likely not be happy.  Just forbid resetting this conjoined mess.
+         * The 640x isn't really supported by hpsa anyway.
+         */
+        0x409C0E11, /* Smart Array 6400 */
+        0x409D0E11, /* Smart Array 6400 EM */
+};
+
+static int ctlr_is_hard_resettable(u32 board_id)
 {
         int i;
 
         for (i = 0; i < ARRAY_SIZE(unresettable_controller); i++)
-                if (unresettable_controller[i] == h->board_id)
+                if (unresettable_controller[i] == board_id)
+                        return 0;
+        return 1;
+}
+
+static int ctlr_is_soft_resettable(u32 board_id)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(soft_unresettable_controller); i++)
+                if (soft_unresettable_controller[i] == board_id)
                         return 0;
         return 1;
 }
 
+static int ctlr_is_resettable(u32 board_id)
+{
+        return ctlr_is_hard_resettable(board_id) ||
+                ctlr_is_soft_resettable(board_id);
+}
+
 static ssize_t host_show_resettable(struct device *dev,
         struct device_attribute *attr, char *buf)
 {
@@ -308,7 +337,7 @@ static ssize_t host_show_resettable(struct device *dev,
         struct Scsi_Host *shost = class_to_shost(dev);
 
         h = shost_to_hba(shost);
-        return snprintf(buf, 20, "%d\n", ctlr_is_resettable(h));
+        return snprintf(buf, 20, "%d\n", ctlr_is_resettable(h->board_id));
 }
 
 static inline int is_logical_dev_addr_mode(unsigned char scsi3addr[])
@@ -929,13 +958,6 @@ static void hpsa_slave_destroy(struct scsi_device *sdev)
         /* nothing to do. */
 }
 
-static void hpsa_scsi_setup(struct ctlr_info *h)
-{
-        h->ndevices = 0;
-        h->scsi_host = NULL;
-        spin_lock_init(&h->devlock);
-}
-
 static void hpsa_free_sg_chain_blocks(struct ctlr_info *h)
 {
         int i;
@@ -1006,8 +1028,7 @@ static void hpsa_unmap_sg_chain_block(struct ctlr_info *h,
         pci_unmap_single(h->pdev, temp64.val, chain_sg->Len, PCI_DMA_TODEVICE);
 }
 
-static void complete_scsi_command(struct CommandList *cp,
-        int timeout, u32 tag)
+static void complete_scsi_command(struct CommandList *cp)
 {
         struct scsi_cmnd *cmd;
         struct ctlr_info *h;
@@ -1308,7 +1329,7 @@ static void hpsa_scsi_do_simple_cmd_with_retry(struct ctlr_info *h,
         int retry_count = 0;
 
         do {
-                memset(c->err_info, 0, sizeof(c->err_info));
+                memset(c->err_info, 0, sizeof(*c->err_info));
                 hpsa_scsi_do_simple_cmd_core(h, c);
                 retry_count++;
         } while (check_for_unit_attention(h, c) && retry_count <= 3);
@@ -1570,6 +1591,7 @@ static unsigned char *msa2xxx_model[] = {
         "MSA2024",
         "MSA2312",
         "MSA2324",
+        "P2000 G3 SAS",
         NULL,
 };
 
@@ -2751,6 +2773,26 @@ static int hpsa_ioctl(struct scsi_device *dev, int cmd, void *arg)
         }
 }
 
+static int __devinit hpsa_send_host_reset(struct ctlr_info *h,
+        unsigned char *scsi3addr, u8 reset_type)
+{
+        struct CommandList *c;
+
+        c = cmd_alloc(h);
+        if (!c)
+                return -ENOMEM;
+        fill_cmd(c, HPSA_DEVICE_RESET_MSG, h, NULL, 0, 0,
+                RAID_CTLR_LUNID, TYPE_MSG);
+        c->Request.CDB[1] = reset_type; /* fill_cmd defaults to target reset */
+        c->waiting = NULL;
+        enqueue_cmd_and_start_io(h, c);
+        /* Don't wait for completion, the reset won't complete.  Don't free
+         * the command either.  This is the last command we will send before
+         * re-initializing everything, so it doesn't matter and won't leak.
+         */
+        return 0;
+}
+
 static void fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
         void *buff, size_t size, u8 page_code, unsigned char *scsi3addr,
         int cmd_type)
@@ -2828,7 +2870,8 @@ static void fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
                         c->Request.Type.Attribute = ATTR_SIMPLE;
                         c->Request.Type.Direction = XFER_NONE;
                         c->Request.Timeout = 0; /* Don't time out */
-                        c->Request.CDB[0] =  0x01; /* RESET_MSG is 0x01 */
+                        memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
+                        c->Request.CDB[0] =  cmd;
                         c->Request.CDB[1] = 0x03;  /* Reset target above */
                         /* If bytes 4-7 are zero, it means reset the */
                         /* LunID device */
@@ -2936,7 +2979,7 @@ static inline void finish_cmd(struct CommandList *c, u32 raw_tag)
 {
         removeQ(c);
         if (likely(c->cmd_type == CMD_SCSI))
-                complete_scsi_command(c, 0, raw_tag);
+                complete_scsi_command(c);
         else if (c->cmd_type == CMD_IOCTL_PEND)
                 complete(c->waiting);
 }
@@ -2994,6 +3037,63 @@ static inline u32 process_nonindexed_cmd(struct ctlr_info *h,
         return next_command(h);
 }
 
+/* Some controllers, like p400, will give us one interrupt
+ * after a soft reset, even if we turned interrupts off.
+ * Only need to check for this in the hpsa_xxx_discard_completions
+ * functions.
+ */
+static int ignore_bogus_interrupt(struct ctlr_info *h)
+{
+        if (likely(!reset_devices))
+                return 0;
+
+        if (likely(h->interrupts_enabled))
+                return 0;
+
+        dev_info(&h->pdev->dev, "Received interrupt while interrupts disabled "
+                "(known firmware bug.)  Ignoring.\n");
+
+        return 1;
+}
+
+static irqreturn_t hpsa_intx_discard_completions(int irq, void *dev_id)
+{
+        struct ctlr_info *h = dev_id;
+        unsigned long flags;
+        u32 raw_tag;
+
+        if (ignore_bogus_interrupt(h))
+                return IRQ_NONE;
+
+        if (interrupt_not_for_us(h))
+                return IRQ_NONE;
+        spin_lock_irqsave(&h->lock, flags);
+        while (interrupt_pending(h)) {
+                raw_tag = get_next_completion(h);
+                while (raw_tag != FIFO_EMPTY)
+                        raw_tag = next_command(h);
+        }
+        spin_unlock_irqrestore(&h->lock, flags);
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t hpsa_msix_discard_completions(int irq, void *dev_id)
+{
+        struct ctlr_info *h = dev_id;
+        unsigned long flags;
+        u32 raw_tag;
+
+        if (ignore_bogus_interrupt(h))
+                return IRQ_NONE;
+
+        spin_lock_irqsave(&h->lock, flags);
+        raw_tag = get_next_completion(h);
+        while (raw_tag != FIFO_EMPTY)
+                raw_tag = next_command(h);
+        spin_unlock_irqrestore(&h->lock, flags);
+        return IRQ_HANDLED;
+}
+
 static irqreturn_t do_hpsa_intr_intx(int irq, void *dev_id)
 {
         struct ctlr_info *h = dev_id;
@@ -3132,11 +3232,10 @@ static __devinit int hpsa_message(struct pci_dev *pdev, unsigned char opcode,
         return 0;
 }
 
-#define hpsa_soft_reset_controller(p) hpsa_message(p, 1, 0)
 #define hpsa_noop(p) hpsa_message(p, 3, 0)
 
 static int hpsa_controller_hard_reset(struct pci_dev *pdev,
-        void * __iomem vaddr, bool use_doorbell)
+        void * __iomem vaddr, u32 use_doorbell)
 {
         u16 pmcsr;
         int pos;
@@ -3147,8 +3246,7 @@ static int hpsa_controller_hard_reset(struct pci_dev *pdev,
                  * other way using the doorbell register.
                  */
                 dev_info(&pdev->dev, "using doorbell to reset controller\n");
-                writel(DOORBELL_CTLR_RESET, vaddr + SA5_DOORBELL);
-                msleep(1000);
+                writel(use_doorbell, vaddr + SA5_DOORBELL);
         } else { /* Try to do it the PCI power state way */
 
                 /* Quoting from the Open CISS Specification: "The Power
@@ -3179,12 +3277,63 @@ static int hpsa_controller_hard_reset(struct pci_dev *pdev,
                 pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
                 pmcsr |= PCI_D0;
                 pci_write_config_word(pdev, pos + PCI_PM_CTRL, pmcsr);
-
-                msleep(500);
         }
         return 0;
 }
 
+static __devinit void init_driver_version(char *driver_version, int len)
+{
+        memset(driver_version, 0, len);
+        strncpy(driver_version, "hpsa " HPSA_DRIVER_VERSION, len - 1);
+}
+
+static __devinit int write_driver_ver_to_cfgtable(
+        struct CfgTable __iomem *cfgtable)
+{
+        char *driver_version;
+        int i, size = sizeof(cfgtable->driver_version);
+
+        driver_version = kmalloc(size, GFP_KERNEL);
+        if (!driver_version)
+                return -ENOMEM;
+
+        init_driver_version(driver_version, size);
+        for (i = 0; i < size; i++)
+                writeb(driver_version[i], &cfgtable->driver_version[i]);
+        kfree(driver_version);
+        return 0;
+}
+
+static __devinit void read_driver_ver_from_cfgtable(
+        struct CfgTable __iomem *cfgtable, unsigned char *driver_ver)
+{
+        int i;
+
+        for (i = 0; i < sizeof(cfgtable->driver_version); i++)
+                driver_ver[i] = readb(&cfgtable->driver_version[i]);
+}
+
+static __devinit int controller_reset_failed(
+        struct CfgTable __iomem *cfgtable)
+{
+
+        char *driver_ver, *old_driver_ver;
+        int rc, size = sizeof(cfgtable->driver_version);
+
+        old_driver_ver = kmalloc(2 * size, GFP_KERNEL);
+        if (!old_driver_ver)
+                return -ENOMEM;
+        driver_ver = old_driver_ver + size;
+
+        /* After a reset, the 32 bytes of "driver version" in the cfgtable
+         * should have been changed, otherwise we know the reset failed.
+         */
+        init_driver_version(old_driver_ver, size);
+        read_driver_ver_from_cfgtable(cfgtable, driver_ver);
+        rc = !memcmp(driver_ver, old_driver_ver, size);
+        kfree(old_driver_ver);
+        return rc;
+}
 /* This does a hard reset of the controller using PCI power management
  * states or the using the doorbell register.
  */
@@ -3195,10 +3344,10 @@ static __devinit int hpsa_kdump_hard_reset_controller(struct pci_dev *pdev)
         u64 cfg_base_addr_index;
         void __iomem *vaddr;
         unsigned long paddr;
-        u32 misc_fw_support, active_transport;
+        u32 misc_fw_support;
         int rc;
         struct CfgTable __iomem *cfgtable;
-        bool use_doorbell;
+        u32 use_doorbell;
         u32 board_id;
         u16 command_register;
 
@@ -3215,20 +3364,15 @@ static __devinit int hpsa_kdump_hard_reset_controller(struct pci_dev *pdev)
          * using the doorbell register.
          */
 
-        /* Exclude 640x boards.  These are two pci devices in one slot
-         * which share a battery backed cache module.  One controls the
-         * cache, the other accesses the cache through the one that controls
-         * it.  If we reset the one controlling the cache, the other will
-         * likely not be happy.  Just forbid resetting this conjoined mess.
-         * The 640x isn't really supported by hpsa anyway.
-         */
         rc = hpsa_lookup_board_id(pdev, &board_id);
-        if (rc < 0) {
+        if (rc < 0 || !ctlr_is_resettable(board_id)) {
                 dev_warn(&pdev->dev, "Not resetting device.\n");
                 return -ENODEV;
         }
-        if (board_id == 0x409C0E11 || board_id == 0x409D0E11)
-                return -ENOTSUPP;
+
+        /* if controller is soft- but not hard resettable... */
+        if (!ctlr_is_hard_resettable(board_id))
+                return -ENOTSUPP; /* try soft reset later. */
 
         /* Save the PCI command register */
         pci_read_config_word(pdev, 4, &command_register);
@@ -3257,10 +3401,28 @@ static __devinit int hpsa_kdump_hard_reset_controller(struct pci_dev *pdev)
                 rc = -ENOMEM;
                 goto unmap_vaddr;
         }
+        rc = write_driver_ver_to_cfgtable(cfgtable);
+        if (rc)
+                goto unmap_vaddr;
 
-        /* If reset via doorbell register is supported, use that. */
+        /* If reset via doorbell register is supported, use that.
+         * There are two such methods.  Favor the newest method.
+         */
         misc_fw_support = readl(&cfgtable->misc_fw_support);
-        use_doorbell = misc_fw_support & MISC_FW_DOORBELL_RESET;
+        use_doorbell = misc_fw_support & MISC_FW_DOORBELL_RESET2;
+        if (use_doorbell) {
+                use_doorbell = DOORBELL_CTLR_RESET2;
+        } else {
+                use_doorbell = misc_fw_support & MISC_FW_DOORBELL_RESET;
+                if (use_doorbell) {
+                        dev_warn(&pdev->dev, "Controller claims that "
+                                "'Bit 2 doorbell reset' is "
+                                "supported, but not 'bit 5 doorbell reset'.  "
+                                "Firmware update is recommended.\n");
+                        rc = -ENOTSUPP; /* try soft reset */
+                        goto unmap_cfgtable;
+                }
+        }
 
         rc = hpsa_controller_hard_reset(pdev, vaddr, use_doorbell);
         if (rc)
@@ -3279,30 +3441,32 @@ static __devinit int hpsa_kdump_hard_reset_controller(struct pci_dev *pdev)
         msleep(HPSA_POST_RESET_PAUSE_MSECS);
 
         /* Wait for board to become not ready, then ready. */
-        dev_info(&pdev->dev, "Waiting for board to become ready.\n");
+        dev_info(&pdev->dev, "Waiting for board to reset.\n");
         rc = hpsa_wait_for_board_state(pdev, vaddr, BOARD_NOT_READY);
-        if (rc)
+        if (rc) {
                 dev_warn(&pdev->dev,
-                        "failed waiting for board to become not ready\n");
+                        "failed waiting for board to reset."
+                        " Will try soft reset.\n");
+                rc = -ENOTSUPP; /* Not expected, but try soft reset later */
+                goto unmap_cfgtable;
+        }
         rc = hpsa_wait_for_board_state(pdev, vaddr, BOARD_READY);
         if (rc) {
                 dev_warn(&pdev->dev,
-                        "failed waiting for board to become ready\n");
+                        "failed waiting for board to become ready "
+                        "after hard reset\n");
                 goto unmap_cfgtable;
         }
-        dev_info(&pdev->dev, "board ready.\n");
 
-        /* Controller should be in simple mode at this point.  If it's not,
-         * It means we're on one of those controllers which doesn't support
-         * the doorbell reset method and on which the PCI power management reset
-         * method doesn't work (P800, for example.)
-         * In those cases, don't try to proceed, as it generally doesn't work.
-         */
-        active_transport = readl(&cfgtable->TransportActive);
-        if (active_transport & PERFORMANT_MODE) {
-                dev_warn(&pdev->dev, "Unable to successfully reset controller,"
-                        " Ignoring controller.\n");
-                rc = -ENODEV;
+        rc = controller_reset_failed(vaddr);
+        if (rc < 0)
+                goto unmap_cfgtable;
+        if (rc) {
+                dev_warn(&pdev->dev, "Unable to successfully reset "
+                        "controller. Will try soft reset.\n");
+                rc = -ENOTSUPP;
+        } else {
+                dev_info(&pdev->dev, "board ready after hard reset.\n");
         }
 
 unmap_cfgtable:
@@ -3543,6 +3707,9 @@ static int __devinit hpsa_find_cfgtables(struct ctlr_info *h)
                        cfg_base_addr_index) + cfg_offset, sizeof(*h->cfgtable));
         if (!h->cfgtable)
                 return -ENOMEM;
+        rc = write_driver_ver_to_cfgtable(h->cfgtable);
+        if (rc)
+                return rc;
         /* Find performant mode table. */
         trans_offset = readl(&h->cfgtable->TransMethodOffset);
         h->transtable = remap_pci_mem(pci_resource_start(h->pdev,
@@ -3777,11 +3944,12 @@ static __devinit int hpsa_init_reset_devices(struct pci_dev *pdev)
          * due to concerns about shared bbwc between 6402/6404 pair.
          */
         if (rc == -ENOTSUPP)
-                return 0; /* just try to do the kdump anyhow. */
+                return rc; /* just try to do the kdump anyhow. */
         if (rc)
                 return -ENODEV;
 
         /* Now try to get the controller to respond to a no-op */
+        dev_warn(&pdev->dev, "Waiting for controller to respond to no-op\n");
         for (i = 0; i < HPSA_POST_RESET_NOOP_RETRIES; i++) {
                 if (hpsa_noop(pdev) == 0)
                         break;
@@ -3792,18 +3960,133 @@ static __devinit int hpsa_init_reset_devices(struct pci_dev *pdev)
         return 0;
 }
 
+static __devinit int hpsa_allocate_cmd_pool(struct ctlr_info *h)
+{
+        h->cmd_pool_bits = kzalloc(
+                DIV_ROUND_UP(h->nr_cmds, BITS_PER_LONG) *
+                sizeof(unsigned long), GFP_KERNEL);
+        h->cmd_pool = pci_alloc_consistent(h->pdev,
+                    h->nr_cmds * sizeof(*h->cmd_pool),
+                    &(h->cmd_pool_dhandle));
+        h->errinfo_pool = pci_alloc_consistent(h->pdev,
+                    h->nr_cmds * sizeof(*h->errinfo_pool),
+                    &(h->errinfo_pool_dhandle));
+        if ((h->cmd_pool_bits == NULL)
+            || (h->cmd_pool == NULL)
+            || (h->errinfo_pool == NULL)) {
+                dev_err(&h->pdev->dev, "out of memory in %s", __func__);
+                return -ENOMEM;
+        }
+        return 0;
+}
+
+static void hpsa_free_cmd_pool(struct ctlr_info *h)
+{
+        kfree(h->cmd_pool_bits);
+        if (h->cmd_pool)
+                pci_free_consistent(h->pdev,
+                            h->nr_cmds * sizeof(struct CommandList),
+                            h->cmd_pool, h->cmd_pool_dhandle);
+        if (h->errinfo_pool)
+                pci_free_consistent(h->pdev,
+                            h->nr_cmds * sizeof(struct ErrorInfo),
+                            h->errinfo_pool,
+                            h->errinfo_pool_dhandle);
+}
+
+static int hpsa_request_irq(struct ctlr_info *h,
+        irqreturn_t (*msixhandler)(int, void *),
+        irqreturn_t (*intxhandler)(int, void *))
+{
+        int rc;
+
+        if (h->msix_vector || h->msi_vector)
+                rc = request_irq(h->intr[h->intr_mode], msixhandler,
+                                IRQF_DISABLED, h->devname, h);
+        else
+                rc = request_irq(h->intr[h->intr_mode], intxhandler,
+                                IRQF_DISABLED, h->devname, h);
+        if (rc) {
+                dev_err(&h->pdev->dev, "unable to get irq %d for %s\n",
+                       h->intr[h->intr_mode], h->devname);
+                return -ENODEV;
+        }
+        return 0;
+}
+
+static int __devinit hpsa_kdump_soft_reset(struct ctlr_info *h)
+{
+        if (hpsa_send_host_reset(h, RAID_CTLR_LUNID,
+                HPSA_RESET_TYPE_CONTROLLER)) {
+                dev_warn(&h->pdev->dev, "Resetting array controller failed.\n");
+                return -EIO;
+        }
+
+        dev_info(&h->pdev->dev, "Waiting for board to soft reset.\n");
+        if (hpsa_wait_for_board_state(h->pdev, h->vaddr, BOARD_NOT_READY)) {
+                dev_warn(&h->pdev->dev, "Soft reset had no effect.\n");
+                return -1;
+        }
+
+        dev_info(&h->pdev->dev, "Board reset, awaiting READY status.\n");
+        if (hpsa_wait_for_board_state(h->pdev, h->vaddr, BOARD_READY)) {
+                dev_warn(&h->pdev->dev, "Board failed to become ready "
+                        "after soft reset.\n");
+                return -1;
+        }
+
+        return 0;
+}
+
+static void hpsa_undo_allocations_after_kdump_soft_reset(struct ctlr_info *h)
+{
+        free_irq(h->intr[h->intr_mode], h);
+#ifdef CONFIG_PCI_MSI
+        if (h->msix_vector)
+                pci_disable_msix(h->pdev);
+        else if (h->msi_vector)
+                pci_disable_msi(h->pdev);
+#endif /* CONFIG_PCI_MSI */
+        hpsa_free_sg_chain_blocks(h);
+        hpsa_free_cmd_pool(h);
+        kfree(h->blockFetchTable);
+        pci_free_consistent(h->pdev, h->reply_pool_size,
+                h->reply_pool, h->reply_pool_dhandle);
+        if (h->vaddr)
+                iounmap(h->vaddr);
+        if (h->transtable)
+                iounmap(h->transtable);
+        if (h->cfgtable)
+                iounmap(h->cfgtable);
+        pci_release_regions(h->pdev);
+        kfree(h);
+}
+
 static int __devinit hpsa_init_one(struct pci_dev *pdev,
                                     const struct pci_device_id *ent)
 {
         int dac, rc;
         struct ctlr_info *h;
+        int try_soft_reset = 0;
+        unsigned long flags;
 
         if (number_of_controllers == 0)
                 printk(KERN_INFO DRIVER_NAME "\n");
 
         rc = hpsa_init_reset_devices(pdev);
-        if (rc)
-                return rc;
+        if (rc) {
+                if (rc != -ENOTSUPP)
+                        return rc;
+                /* If the reset fails in a particular way (it has no way to do
+                 * a proper hard reset, so returns -ENOTSUPP) we can try to do
+                 * a soft reset once we get the controller configured up to the
+                 * point that it can accept a command.
+                 */
+                try_soft_reset = 1;
+                rc = 0;
+        }
+
+reinit_after_soft_reset:
 
         /* Command structures must be aligned on a 32-byte boundary because
          * the 5 lower bits of the address are used by the hardware. and by
@@ -3847,54 +4130,82 @@ static int __devinit hpsa_init_one(struct pci_dev *pdev,
         /* make sure the board interrupts are off */
         h->access.set_intr_mask(h, HPSA_INTR_OFF);
 
-        if (h->msix_vector || h->msi_vector)
-                rc = request_irq(h->intr[h->intr_mode], do_hpsa_intr_msi,
-                                IRQF_DISABLED, h->devname, h);
-        else
-                rc = request_irq(h->intr[h->intr_mode], do_hpsa_intr_intx,
-                                IRQF_DISABLED, h->devname, h);
-        if (rc) {
-                dev_err(&pdev->dev, "unable to get irq %d for %s\n",
-                       h->intr[h->intr_mode], h->devname);
+        if (hpsa_request_irq(h, do_hpsa_intr_msi, do_hpsa_intr_intx))
                 goto clean2;
-        }
-
         dev_info(&pdev->dev, "%s: <0x%x> at IRQ %d%s using DAC\n",
                h->devname, pdev->device,
                h->intr[h->intr_mode], dac ? "" : " not");
-
-        h->cmd_pool_bits =
-            kmalloc(((h->nr_cmds + BITS_PER_LONG -
-                      1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL);
-        h->cmd_pool = pci_alloc_consistent(h->pdev,
-                    h->nr_cmds * sizeof(*h->cmd_pool),
-                    &(h->cmd_pool_dhandle));
-        h->errinfo_pool = pci_alloc_consistent(h->pdev,
-                    h->nr_cmds * sizeof(*h->errinfo_pool),
-                    &(h->errinfo_pool_dhandle));
-        if ((h->cmd_pool_bits == NULL)
-            || (h->cmd_pool == NULL)
-            || (h->errinfo_pool == NULL)) {
-                dev_err(&pdev->dev, "out of memory");
-                rc = -ENOMEM;
+        if (hpsa_allocate_cmd_pool(h))
                 goto clean4;
-        }
         if (hpsa_allocate_sg_chain_blocks(h))
                 goto clean4;
         init_waitqueue_head(&h->scan_wait_queue);
         h->scan_finished = 1; /* no scan currently in progress */
 
         pci_set_drvdata(pdev, h);
-        memset(h->cmd_pool_bits, 0,
-               ((h->nr_cmds + BITS_PER_LONG -
-                 1) / BITS_PER_LONG) * sizeof(unsigned long));
+        h->ndevices = 0;
+        h->scsi_host = NULL;
+        spin_lock_init(&h->devlock);
+        hpsa_put_ctlr_into_performant_mode(h);
+
+        /* At this point, the controller is ready to take commands.
+         * Now, if reset_devices and the hard reset didn't work, try
+         * the soft reset and see if that works.
+         */
+        if (try_soft_reset) {
+
+                /* This is kind of gross.  We may or may not get a completion
+                 * from the soft reset command, and if we do, then the value
+                 * from the fifo may or may not be valid.  So, we wait 10 secs
+                 * after the reset throwing away any completions we get during
+                 * that time.  Unregister the interrupt handler and register
+                 * fake ones to scoop up any residual completions.
+                 */
+                spin_lock_irqsave(&h->lock, flags);
+                h->access.set_intr_mask(h, HPSA_INTR_OFF);
+                spin_unlock_irqrestore(&h->lock, flags);
+                free_irq(h->intr[h->intr_mode], h);
+                rc = hpsa_request_irq(h, hpsa_msix_discard_completions,
+                                        hpsa_intx_discard_completions);
+                if (rc) {
+                        dev_warn(&h->pdev->dev, "Failed to request_irq after "
+                                "soft reset.\n");
+                        goto clean4;
+                }
+
+                rc = hpsa_kdump_soft_reset(h);
+                if (rc)
+                        /* Neither hard nor soft reset worked, we're hosed. */
+                        goto clean4;
+
+                dev_info(&h->pdev->dev, "Board READY.\n");
+                dev_info(&h->pdev->dev,
+                        "Waiting for stale completions to drain.\n");
+                h->access.set_intr_mask(h, HPSA_INTR_ON);
+                msleep(10000);
+                h->access.set_intr_mask(h, HPSA_INTR_OFF);
+
+                rc = controller_reset_failed(h->cfgtable);
+                if (rc)
+                        dev_info(&h->pdev->dev,
+                                "Soft reset appears to have failed.\n");
+
+                /* since the controller's reset, we have to go back and re-init
+                 * everything.  Easiest to just forget what we've done and do it
+                 * all over again.
+                 */
+                hpsa_undo_allocations_after_kdump_soft_reset(h);
+                try_soft_reset = 0;
+                if (rc)
+                        /* don't go to clean4, we already unallocated */
+                        return -ENODEV;
 
-        hpsa_scsi_setup(h);
+                goto reinit_after_soft_reset;
+        }
 
         /* Turn the interrupts on so we can service requests */
         h->access.set_intr_mask(h, HPSA_INTR_ON);
 
-        hpsa_put_ctlr_into_performant_mode(h);
         hpsa_hba_inquiry(h);
         hpsa_register_scsi(h);  /* hook ourselves into SCSI subsystem */
         h->busy_initializing = 0;
@@ -3902,16 +4213,7 @@ static int __devinit hpsa_init_one(struct pci_dev *pdev,
 
 clean4:
         hpsa_free_sg_chain_blocks(h);
-        kfree(h->cmd_pool_bits);
-        if (h->cmd_pool)
-                pci_free_consistent(h->pdev,
-                            h->nr_cmds * sizeof(struct CommandList),
-                            h->cmd_pool, h->cmd_pool_dhandle);
-        if (h->errinfo_pool)
-                pci_free_consistent(h->pdev,
-                            h->nr_cmds * sizeof(struct ErrorInfo),
-                            h->errinfo_pool,
-                            h->errinfo_pool_dhandle);
+        hpsa_free_cmd_pool(h);
         free_irq(h->intr[h->intr_mode], h);
 clean2:
 clean1:
diff --git a/drivers/scsi/hpsa.h b/drivers/scsi/hpsa.h
index 621a1530054a..6d8dcd4dd06b 100644
--- a/drivers/scsi/hpsa.h
+++ b/drivers/scsi/hpsa.h
@@ -127,10 +127,12 @@ struct ctlr_info {
 };
 #define HPSA_ABORT_MSG 0
 #define HPSA_DEVICE_RESET_MSG 1
-#define HPSA_BUS_RESET_MSG 2
-#define HPSA_HOST_RESET_MSG 3
+#define HPSA_RESET_TYPE_CONTROLLER 0x00
+#define HPSA_RESET_TYPE_BUS 0x01
+#define HPSA_RESET_TYPE_TARGET 0x03
+#define HPSA_RESET_TYPE_LUN 0x04
 #define HPSA_MSG_SEND_RETRY_LIMIT 10
-#define HPSA_MSG_SEND_RETRY_INTERVAL_MSECS 1000
+#define HPSA_MSG_SEND_RETRY_INTERVAL_MSECS (10000)
 
 /* Maximum time in seconds driver will wait for command completions
  * when polling before giving up.
@@ -155,7 +157,7 @@ struct ctlr_info {
  * HPSA_BOARD_READY_ITERATIONS are derived from those.
  */
 #define HPSA_BOARD_READY_WAIT_SECS (120)
-#define HPSA_BOARD_NOT_READY_WAIT_SECS (10)
+#define HPSA_BOARD_NOT_READY_WAIT_SECS (100)
 #define HPSA_BOARD_READY_POLL_INTERVAL_MSECS (100)
 #define HPSA_BOARD_READY_POLL_INTERVAL \
         ((HPSA_BOARD_READY_POLL_INTERVAL_MSECS * HZ) / 1000)
@@ -212,6 +214,7 @@ static void SA5_submit_command(struct ctlr_info *h,
         dev_dbg(&h->pdev->dev, "Sending %x, tag = %x\n", c->busaddr,
                 c->Header.Tag.lower);
         writel(c->busaddr, h->vaddr + SA5_REQUEST_PORT_OFFSET);
+        (void) readl(h->vaddr + SA5_REQUEST_PORT_OFFSET);
         h->commands_outstanding++;
         if (h->commands_outstanding > h->max_outstanding)
                 h->max_outstanding = h->commands_outstanding;
@@ -227,10 +230,12 @@ static void SA5_intr_mask(struct ctlr_info *h, unsigned long val)
         if (val) { /* Turn interrupts on */
                 h->interrupts_enabled = 1;
                 writel(0, h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
+                (void) readl(h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
         } else { /* Turn them off */
                 h->interrupts_enabled = 0;
                 writel(SA5_INTR_OFF,
                         h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
+                (void) readl(h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
         }
 }
 
@@ -239,10 +244,12 @@ static void SA5_performant_intr_mask(struct ctlr_info *h, unsigned long val)
         if (val) { /* turn on interrupts */
                 h->interrupts_enabled = 1;
                 writel(0, h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
+                (void) readl(h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
         } else {
                 h->interrupts_enabled = 0;
                 writel(SA5_PERF_INTR_OFF,
                         h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
+                (void) readl(h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
         }
 }
 
diff --git a/drivers/scsi/hpsa_cmd.h b/drivers/scsi/hpsa_cmd.h
index 18464900e761..55d741b019db 100644
--- a/drivers/scsi/hpsa_cmd.h
+++ b/drivers/scsi/hpsa_cmd.h
@@ -101,6 +101,7 @@
 #define CFGTBL_ChangeReq        0x00000001l
 #define CFGTBL_AccCmds          0x00000001l
 #define DOORBELL_CTLR_RESET     0x00000004l
+#define DOORBELL_CTLR_RESET2    0x00000020l
 
 #define CFGTBL_Trans_Simple     0x00000002l
 #define CFGTBL_Trans_Performant 0x00000004l
@@ -256,14 +257,6 @@ struct ErrorInfo {
 #define CMD_IOCTL_PEND  0x01
 #define CMD_SCSI        0x03
 
-/* This structure needs to be divisible by 32 for new
- * indexing method and performant mode.
- */
-#define PAD32 32
-#define PAD64DIFF 0
-#define USEEXTRA ((sizeof(void *) - 4)/4)
-#define PADSIZE (PAD32 + PAD64DIFF * USEEXTRA)
-
 #define DIRECT_LOOKUP_SHIFT 5
 #define DIRECT_LOOKUP_BIT 0x10
 #define DIRECT_LOOKUP_MASK (~((1 << DIRECT_LOOKUP_SHIFT) - 1))
@@ -345,6 +338,8 @@ struct CfgTable {
         u8              reserved[0x78 - 0x58];
         u32             misc_fw_support; /* offset 0x78 */
 #define                 MISC_FW_DOORBELL_RESET (0x02)
+#define                 MISC_FW_DOORBELL_RESET2 (0x010)
+        u8              driver_version[32];
 };
 
 #define NUM_BLOCKFETCH_ENTRIES 8
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index 041958453e2a..3d391dc3f11f 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -1849,8 +1849,7 @@ static void ibmvscsi_do_work(struct ibmvscsi_host_data *hostdata)
                 rc = ibmvscsi_ops->reset_crq_queue(&hostdata->queue, hostdata);
                 if (!rc)
                         rc = ibmvscsi_ops->send_crq(hostdata, 0xC001000000000000LL, 0);
-                if (!rc)
-                        rc = vio_enable_interrupts(to_vio_dev(hostdata->dev));
+                vio_enable_interrupts(to_vio_dev(hostdata->dev));
         } else if (hostdata->reenable_crq) {
                 smp_rmb();
                 action = "enable";
diff --git a/drivers/scsi/in2000.c b/drivers/scsi/in2000.c
index 6568aab745a0..92109b126391 100644
--- a/drivers/scsi/in2000.c
+++ b/drivers/scsi/in2000.c
@@ -343,7 +343,7 @@ static int in2000_queuecommand_lck(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
         instance = cmd->device->host;
         hostdata = (struct IN2000_hostdata *) instance->hostdata;
 
-        DB(DB_QUEUE_COMMAND, scmd_printk(KERN_DEBUG, cmd, "Q-%02x-%ld(", cmd->cmnd[0], cmd->serial_number))
+        DB(DB_QUEUE_COMMAND, scmd_printk(KERN_DEBUG, cmd, "Q-%02x(", cmd->cmnd[0]))
 
 /* Set up a few fields in the Scsi_Cmnd structure for our own use:
  *  - host_scribble is the pointer to the next cmd in the input queue
@@ -427,7 +427,7 @@ static int in2000_queuecommand_lck(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
 
         in2000_execute(cmd->device->host);
 
-        DB(DB_QUEUE_COMMAND, printk(")Q-%ld ", cmd->serial_number))
+        DB(DB_QUEUE_COMMAND, printk(")Q "))
             return 0;
 }
 
@@ -705,7 +705,7 @@ static void in2000_execute(struct Scsi_Host *instance)
          * to search the input_Q again...
          */
 
-        DB(DB_EXECUTE, printk("%s%ld)EX-2 ", (cmd->SCp.phase) ? "d:" : "", cmd->serial_number))
+        DB(DB_EXECUTE, printk("%s)EX-2 ", (cmd->SCp.phase) ? "d:" : ""))
 
 }
 
@@ -1149,7 +1149,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
         case CSR_XFER_DONE | PHS_COMMAND:
         case CSR_UNEXP | PHS_COMMAND:
         case CSR_SRV_REQ | PHS_COMMAND:
-                DB(DB_INTR, printk("CMND-%02x,%ld", cmd->cmnd[0], cmd->serial_number))
+                DB(DB_INTR, printk("CMND-%02x", cmd->cmnd[0]))
                     transfer_pio(cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, hostdata);
                 hostdata->state = S_CONNECTED;
                 break;
@@ -1191,7 +1191,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
                 switch (msg) {
 
                 case COMMAND_COMPLETE:
-                        DB(DB_INTR, printk("CCMP-%ld", cmd->serial_number))
+                        DB(DB_INTR, printk("CCMP"))
                             write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
                         hostdata->state = S_PRE_CMP_DISC;
                         break;
@@ -1329,7 +1329,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
 
                 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
                 if (phs == 0x60) {
-                        DB(DB_INTR, printk("SX-DONE-%ld", cmd->serial_number))
+                        DB(DB_INTR, printk("SX-DONE"))
                             cmd->SCp.Message = COMMAND_COMPLETE;
                         lun = read_3393(hostdata, WD_TARGET_LUN);
                         DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun))
@@ -1350,7 +1350,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
 
                         in2000_execute(instance);
                 } else {
-                        printk("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE phase!!---", asr, sr, phs, cmd->serial_number);
+                        printk("%02x:%02x:%02x: Unknown SEL_XFER_DONE phase!!---", asr, sr, phs);
                 }
                 break;
 
@@ -1417,7 +1417,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
                         spin_unlock_irqrestore(instance->host_lock, flags);
                         return IRQ_HANDLED;
                 }
-                DB(DB_INTR, printk("UNEXP_DISC-%ld", cmd->serial_number))
+                DB(DB_INTR, printk("UNEXP_DISC"))
                     hostdata->connected = NULL;
                 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
                 hostdata->state = S_UNCONNECTED;
@@ -1442,7 +1442,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
  */
 
                 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
-                DB(DB_INTR, printk("DISC-%ld", cmd->serial_number))
+                DB(DB_INTR, printk("DISC"))
                     if (cmd == NULL) {
                         printk(" - Already disconnected! ");
                         hostdata->state = S_UNCONNECTED;
@@ -1575,7 +1575,6 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
                 } else
                         hostdata->state = S_CONNECTED;
 
-                DB(DB_INTR, printk("-%ld", cmd->serial_number))
                     break;
 
         default:
@@ -1704,7 +1703,7 @@ static int __in2000_abort(Scsi_Cmnd * cmd)
                                 prev->host_scribble = cmd->host_scribble;
                         cmd->host_scribble = NULL;
                         cmd->result = DID_ABORT << 16;
-                        printk(KERN_WARNING "scsi%d: Abort - removing command %ld from input_Q. ", instance->host_no, cmd->serial_number);
+                        printk(KERN_WARNING "scsi%d: Abort - removing command from input_Q. ", instance->host_no);
                         cmd->scsi_done(cmd);
                         return SUCCESS;
                 }
@@ -1725,7 +1724,7 @@ static int __in2000_abort(Scsi_Cmnd * cmd)
 
         if (hostdata->connected == cmd) {
 
-                printk(KERN_WARNING "scsi%d: Aborting connected command %ld - ", instance->host_no, cmd->serial_number);
+                printk(KERN_WARNING "scsi%d: Aborting connected command - ", instance->host_no);
 
                 printk("sending wd33c93 ABORT command - ");
                 write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
@@ -2270,7 +2269,7 @@ static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start,
                 strcat(bp, "\nconnected:     ");
                 if (hd->connected) {
                         cmd = (Scsi_Cmnd *) hd->connected;
-                        sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+                        sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
                         strcat(bp, tbuf);
                 }
         }
@@ -2278,7 +2277,7 @@ static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start,
                 strcat(bp, "\ninput_Q:       ");
                 cmd = (Scsi_Cmnd *) hd->input_Q;
                 while (cmd) {
-                        sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+                        sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
                         strcat(bp, tbuf);
                         cmd = (Scsi_Cmnd *) cmd->host_scribble;
                 }
@@ -2287,7 +2286,7 @@ static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start,
                 strcat(bp, "\ndisconnected_Q:");
                 cmd = (Scsi_Cmnd *) hd->disconnected_Q;
                 while (cmd) {
-                        sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+                        sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
                         strcat(bp, tbuf);
                         cmd = (Scsi_Cmnd *) cmd->host_scribble;
                 }
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 0621238fac4a..12868ca46110 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -60,6 +60,7 @@
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
+#include <linux/vmalloc.h>
 #include <linux/ioport.h>
 #include <linux/delay.h>
 #include <linux/pci.h>
@@ -2717,13 +2718,18 @@ static int ipr_sdt_copy(struct ipr_ioa_cfg *ioa_cfg,
                         unsigned long pci_address, u32 length)
 {
         int bytes_copied = 0;
-        int cur_len, rc, rem_len, rem_page_len;
+        int cur_len, rc, rem_len, rem_page_len, max_dump_size;
         __be32 *page;
         unsigned long lock_flags = 0;
         struct ipr_ioa_dump *ioa_dump = &ioa_cfg->dump->ioa_dump;
 
+        if (ioa_cfg->sis64)
+                max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
+        else
+                max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
+
         while (bytes_copied < length &&
-               (ioa_dump->hdr.len + bytes_copied) < IPR_MAX_IOA_DUMP_SIZE) {
+               (ioa_dump->hdr.len + bytes_copied) < max_dump_size) {
                 if (ioa_dump->page_offset >= PAGE_SIZE ||
                     ioa_dump->page_offset == 0) {
                         page = (__be32 *)__get_free_page(GFP_ATOMIC);
@@ -2885,8 +2891,8 @@ static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
         unsigned long lock_flags = 0;
         struct ipr_driver_dump *driver_dump = &dump->driver_dump;
         struct ipr_ioa_dump *ioa_dump = &dump->ioa_dump;
-        u32 num_entries, start_off, end_off;
-        u32 bytes_to_copy, bytes_copied, rc;
+        u32 num_entries, max_num_entries, start_off, end_off;
+        u32 max_dump_size, bytes_to_copy, bytes_copied, rc;
         struct ipr_sdt *sdt;
         int valid = 1;
         int i;
@@ -2947,8 +2953,18 @@ static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
          on entries in this table */
         sdt = &ioa_dump->sdt;
 
+        if (ioa_cfg->sis64) {
+                max_num_entries = IPR_FMT3_NUM_SDT_ENTRIES;
+                max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
+        } else {
+                max_num_entries = IPR_FMT2_NUM_SDT_ENTRIES;
+                max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
+        }
+
+        bytes_to_copy = offsetof(struct ipr_sdt, entry) +
+                        (max_num_entries * sizeof(struct ipr_sdt_entry));
         rc = ipr_get_ldump_data_section(ioa_cfg, start_addr, (__be32 *)sdt,
-                                        sizeof(struct ipr_sdt) / sizeof(__be32));
+                                        bytes_to_copy / sizeof(__be32));
 
         /* Smart Dump table is ready to use and the first entry is valid */
         if (rc || ((be32_to_cpu(sdt->hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
@@ -2964,13 +2980,20 @@ static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
 
         num_entries = be32_to_cpu(sdt->hdr.num_entries_used);
 
-        if (num_entries > IPR_NUM_SDT_ENTRIES)
-                num_entries = IPR_NUM_SDT_ENTRIES;
+        if (num_entries > max_num_entries)
+                num_entries = max_num_entries;
+
+        /* Update dump length to the actual data to be copied */
+        dump->driver_dump.hdr.len += sizeof(struct ipr_sdt_header);
+        if (ioa_cfg->sis64)
+                dump->driver_dump.hdr.len += num_entries * sizeof(struct ipr_sdt_entry);
+        else
+                dump->driver_dump.hdr.len += max_num_entries * sizeof(struct ipr_sdt_entry);
 
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
 
         for (i = 0; i < num_entries; i++) {
-                if (ioa_dump->hdr.len > IPR_MAX_IOA_DUMP_SIZE) {
+                if (ioa_dump->hdr.len > max_dump_size) {
                         driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
                         break;
                 }
@@ -2989,7 +3012,7 @@ static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
                                         valid = 0;
                         }
                         if (valid) {
-                                if (bytes_to_copy > IPR_MAX_IOA_DUMP_SIZE) {
+                                if (bytes_to_copy > max_dump_size) {
                                         sdt->entry[i].flags &= ~IPR_SDT_VALID_ENTRY;
                                         continue;
                                 }
@@ -3044,6 +3067,7 @@ static void ipr_release_dump(struct kref *kref)
         for (i = 0; i < dump->ioa_dump.next_page_index; i++)
                 free_page((unsigned long) dump->ioa_dump.ioa_data[i]);
 
+        vfree(dump->ioa_dump.ioa_data);
         kfree(dump);
         LEAVE;
 }
@@ -3835,7 +3859,7 @@ static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
         struct ipr_dump *dump;
         unsigned long lock_flags = 0;
         char *src;
-        int len;
+        int len, sdt_end;
         size_t rc = count;
 
         if (!capable(CAP_SYS_ADMIN))
@@ -3875,9 +3899,17 @@ static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
 
         off -= sizeof(dump->driver_dump);
 
-        if (count && off < offsetof(struct ipr_ioa_dump, ioa_data)) {
-                if (off + count > offsetof(struct ipr_ioa_dump, ioa_data))
-                        len = offsetof(struct ipr_ioa_dump, ioa_data) - off;
+        if (ioa_cfg->sis64)
+                sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
+                          (be32_to_cpu(dump->ioa_dump.sdt.hdr.num_entries_used) *
+                           sizeof(struct ipr_sdt_entry));
+        else
+                sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
+                          (IPR_FMT2_NUM_SDT_ENTRIES * sizeof(struct ipr_sdt_entry));
+
+        if (count && off < sdt_end) {
+                if (off + count > sdt_end)
+                        len = sdt_end - off;
                 else
                         len = count;
                 src = (u8 *)&dump->ioa_dump + off;
@@ -3887,7 +3919,7 @@ static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
                 count -= len;
         }
 
-        off -= offsetof(struct ipr_ioa_dump, ioa_data);
+        off -= sdt_end;
 
         while (count) {
                 if ((off & PAGE_MASK) != ((off + count) & PAGE_MASK))
@@ -3916,6 +3948,7 @@ static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
 static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
 {
         struct ipr_dump *dump;
+        __be32 **ioa_data;
         unsigned long lock_flags = 0;
 
         dump = kzalloc(sizeof(struct ipr_dump), GFP_KERNEL);
@@ -3925,6 +3958,19 @@ static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
                 return -ENOMEM;
         }
 
+        if (ioa_cfg->sis64)
+                ioa_data = vmalloc(IPR_FMT3_MAX_NUM_DUMP_PAGES * sizeof(__be32 *));
+        else
+                ioa_data = vmalloc(IPR_FMT2_MAX_NUM_DUMP_PAGES * sizeof(__be32 *));
+
+        if (!ioa_data) {
+                ipr_err("Dump memory allocation failed\n");
+                kfree(dump);
+                return -ENOMEM;
+        }
+
+        dump->ioa_dump.ioa_data = ioa_data;
+
         kref_init(&dump->kref);
         dump->ioa_cfg = ioa_cfg;
 
@@ -3932,6 +3978,7 @@ static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
 
         if (INACTIVE != ioa_cfg->sdt_state) {
                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+                vfree(dump->ioa_dump.ioa_data);
                 kfree(dump);
                 return 0;
         }
@@ -4953,9 +5000,35 @@ static int ipr_eh_abort(struct scsi_cmnd * scsi_cmd)
  *      IRQ_NONE / IRQ_HANDLED
  **/
 static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
-                                              volatile u32 int_reg)
+                                              u32 int_reg)
 {
         irqreturn_t rc = IRQ_HANDLED;
+        u32 int_mask_reg;
+
+        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
+        int_reg &= ~int_mask_reg;
+
+        /* If an interrupt on the adapter did not occur, ignore it.
+         * Or in the case of SIS 64, check for a stage change interrupt.
+         */
+        if ((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0) {
+                if (ioa_cfg->sis64) {
+                        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
+                        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
+                        if (int_reg & IPR_PCII_IPL_STAGE_CHANGE) {
+
+                                /* clear stage change */
+                                writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_reg);
+                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
+                                list_del(&ioa_cfg->reset_cmd->queue);
+                                del_timer(&ioa_cfg->reset_cmd->timer);
+                                ipr_reset_ioa_job(ioa_cfg->reset_cmd);
+                                return IRQ_HANDLED;
+                        }
+                }
+
+                return IRQ_NONE;
+        }
 
         if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
                 /* Mask the interrupt */
@@ -4968,6 +5041,13 @@ static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
                 list_del(&ioa_cfg->reset_cmd->queue);
                 del_timer(&ioa_cfg->reset_cmd->timer);
                 ipr_reset_ioa_job(ioa_cfg->reset_cmd);
+        } else if ((int_reg & IPR_PCII_HRRQ_UPDATED) == int_reg) {
+                if (ipr_debug && printk_ratelimit())
+                        dev_err(&ioa_cfg->pdev->dev,
+                                "Spurious interrupt detected. 0x%08X\n", int_reg);
+                writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg32);
+                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
+                return IRQ_NONE;
         } else {
                 if (int_reg & IPR_PCII_IOA_UNIT_CHECKED)
                         ioa_cfg->ioa_unit_checked = 1;
@@ -5016,10 +5096,11 @@ static irqreturn_t ipr_isr(int irq, void *devp)
 {
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)devp;
         unsigned long lock_flags = 0;
-        volatile u32 int_reg, int_mask_reg;
+        u32 int_reg = 0;
         u32 ioasc;
         u16 cmd_index;
         int num_hrrq = 0;
+        int irq_none = 0;
         struct ipr_cmnd *ipr_cmd;
         irqreturn_t rc = IRQ_NONE;
 
@@ -5031,33 +5112,6 @@ static irqreturn_t ipr_isr(int irq, void *devp)
                 return IRQ_NONE;
         }
 
-        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
-        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32) & ~int_mask_reg;
-
-        /* If an interrupt on the adapter did not occur, ignore it.
-         * Or in the case of SIS 64, check for a stage change interrupt.
-         */
-        if (unlikely((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0)) {
-                if (ioa_cfg->sis64) {
-                        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
-                        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
-                        if (int_reg & IPR_PCII_IPL_STAGE_CHANGE) {
-
-                                /* clear stage change */
-                                writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_reg);
-                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
-                                list_del(&ioa_cfg->reset_cmd->queue);
-                                del_timer(&ioa_cfg->reset_cmd->timer);
-                                ipr_reset_ioa_job(ioa_cfg->reset_cmd);
-                                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-                                return IRQ_HANDLED;
-                        }
-                }
-
-                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-                return IRQ_NONE;
-        }
-
         while (1) {
                 ipr_cmd = NULL;
 
@@ -5097,7 +5151,7 @@ static irqreturn_t ipr_isr(int irq, void *devp)
                         /* Clear the PCI interrupt */
                         do {
                                 writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg32);
-                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32) & ~int_mask_reg;
+                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
                         } while (int_reg & IPR_PCII_HRRQ_UPDATED &&
                                         num_hrrq++ < IPR_MAX_HRRQ_RETRIES);
 
@@ -5107,6 +5161,9 @@ static irqreturn_t ipr_isr(int irq, void *devp)
                                 return IRQ_HANDLED;
                         }
 
+                } else if (rc == IRQ_NONE && irq_none == 0) {
+                        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
+                        irq_none++;
                 } else
                         break;
         }
@@ -5143,7 +5200,8 @@ static int ipr_build_ioadl64(struct ipr_ioa_cfg *ioa_cfg,
 
         nseg = scsi_dma_map(scsi_cmd);
         if (nseg < 0) {
-                dev_err(&ioa_cfg->pdev->dev, "pci_map_sg failed!\n");
+                if (printk_ratelimit())
+                        dev_err(&ioa_cfg->pdev->dev, "pci_map_sg failed!\n");
                 return -1;
         }
 
@@ -5773,7 +5831,8 @@ static int ipr_queuecommand_lck(struct scsi_cmnd *scsi_cmd,
                 }
 
                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
-                ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST;
+                if (ipr_is_gscsi(res))
+                        ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST;
                 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_ALIGNED_BFR;
                 ioarcb->cmd_pkt.flags_lo |= ipr_get_task_attributes(scsi_cmd);
         }
@@ -7516,7 +7575,7 @@ static int ipr_reset_get_unit_check_job(struct ipr_cmnd *ipr_cmd)
 static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
-        volatile u32 int_reg;
+        u32 int_reg;
 
         ENTER;
         ioa_cfg->pdev->state_saved = true;
@@ -7555,7 +7614,10 @@ static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
                 ipr_cmd->job_step = ipr_reset_enable_ioa;
 
                 if (GET_DUMP == ioa_cfg->sdt_state) {
-                        ipr_reset_start_timer(ipr_cmd, IPR_DUMP_TIMEOUT);
+                        if (ioa_cfg->sis64)
+                                ipr_reset_start_timer(ipr_cmd, IPR_SIS64_DUMP_TIMEOUT);
+                        else
+                                ipr_reset_start_timer(ipr_cmd, IPR_SIS32_DUMP_TIMEOUT);
                         ipr_cmd->job_step = ipr_reset_wait_for_dump;
                         schedule_work(&ioa_cfg->work_q);
                         return IPR_RC_JOB_RETURN;
diff --git a/drivers/scsi/ipr.h b/drivers/scsi/ipr.h
index 13f425fb8851..f93f8637c5a1 100644
--- a/drivers/scsi/ipr.h
+++ b/drivers/scsi/ipr.h
@@ -38,8 +38,8 @@
 /*
  * Literals
  */
-#define IPR_DRIVER_VERSION "2.5.1"
-#define IPR_DRIVER_DATE "(August 10, 2010)"
+#define IPR_DRIVER_VERSION "2.5.2"
+#define IPR_DRIVER_DATE "(April 27, 2011)"
 
 /*
  * IPR_MAX_CMD_PER_LUN: This defines the maximum number of outstanding
@@ -217,7 +217,8 @@
 #define IPR_CHECK_FOR_RESET_TIMEOUT             (HZ / 10)
 #define IPR_WAIT_FOR_BIST_TIMEOUT               (2 * HZ)
 #define IPR_PCI_RESET_TIMEOUT                   (HZ / 2)
-#define IPR_DUMP_TIMEOUT                        (15 * HZ)
+#define IPR_SIS32_DUMP_TIMEOUT                  (15 * HZ)
+#define IPR_SIS64_DUMP_TIMEOUT                  (40 * HZ)
 #define IPR_DUMP_DELAY_SECONDS                  4
 #define IPR_DUMP_DELAY_TIMEOUT                  (IPR_DUMP_DELAY_SECONDS * HZ)
 
@@ -285,9 +286,12 @@ IPR_PCII_NO_HOST_RRQ | IPR_PCII_IOARRIN_LOST | IPR_PCII_MMIO_ERROR)
 /*
  * Dump literals
  */
-#define IPR_MAX_IOA_DUMP_SIZE                           (4 * 1024 * 1024)
-#define IPR_NUM_SDT_ENTRIES                             511
-#define IPR_MAX_NUM_DUMP_PAGES  ((IPR_MAX_IOA_DUMP_SIZE / PAGE_SIZE) + 1)
+#define IPR_FMT2_MAX_IOA_DUMP_SIZE                      (4 * 1024 * 1024)
+#define IPR_FMT3_MAX_IOA_DUMP_SIZE                      (32 * 1024 * 1024)
+#define IPR_FMT2_NUM_SDT_ENTRIES                        511
+#define IPR_FMT3_NUM_SDT_ENTRIES                        0xFFF
+#define IPR_FMT2_MAX_NUM_DUMP_PAGES     ((IPR_FMT2_MAX_IOA_DUMP_SIZE / PAGE_SIZE) + 1)
+#define IPR_FMT3_MAX_NUM_DUMP_PAGES     ((IPR_FMT3_MAX_IOA_DUMP_SIZE / PAGE_SIZE) + 1)
 
 /*
  * Misc literals
@@ -474,7 +478,7 @@ struct ipr_cmd_pkt {
 
         u8 flags_lo;
 #define IPR_FLAGS_LO_ALIGNED_BFR                0x20
-#define IPR_FLAGS_LO_DELAY_AFTER_RST    0x10
+#define IPR_FLAGS_LO_DELAY_AFTER_RST            0x10
 #define IPR_FLAGS_LO_UNTAGGED_TASK              0x00
 #define IPR_FLAGS_LO_SIMPLE_TASK                0x02
 #define IPR_FLAGS_LO_ORDERED_TASK               0x04
@@ -1164,7 +1168,7 @@ struct ipr_sdt_header {
 
 struct ipr_sdt {
         struct ipr_sdt_header hdr;
-        struct ipr_sdt_entry entry[IPR_NUM_SDT_ENTRIES];
+        struct ipr_sdt_entry entry[IPR_FMT3_NUM_SDT_ENTRIES];
 }__attribute__((packed, aligned (4)));
 
 struct ipr_uc_sdt {
@@ -1608,7 +1612,7 @@ struct ipr_driver_dump {
 struct ipr_ioa_dump {
         struct ipr_dump_entry_header hdr;
         struct ipr_sdt sdt;
-        __be32 *ioa_data[IPR_MAX_NUM_DUMP_PAGES];
+        __be32 **ioa_data;
         u32 reserved;
         u32 next_page_index;
         u32 page_offset;
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index 5b799a37ad09..2a3a4720a771 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -57,9 +57,6 @@ static struct kmem_cache *scsi_pkt_cachep;
 #define FC_SRB_READ             (1 << 1)
 #define FC_SRB_WRITE            (1 << 0)
 
-/* constant added to e_d_tov timeout to get rec_tov value */
-#define REC_TOV_CONST           1
-
 /*
  * The SCp.ptr should be tested and set under the scsi_pkt_queue lock
  */
@@ -248,7 +245,7 @@ static inline void fc_fcp_unlock_pkt(struct fc_fcp_pkt *fsp)
 /**
  * fc_fcp_timer_set() - Start a timer for a fcp_pkt
  * @fsp:   The FCP packet to start a timer for
- * @delay: The timeout period for the timer
+ * @delay: The timeout period in jiffies
  */
 static void fc_fcp_timer_set(struct fc_fcp_pkt *fsp, unsigned long delay)
 {
@@ -335,22 +332,23 @@ static void fc_fcp_ddp_done(struct fc_fcp_pkt *fsp)
 /**
  * fc_fcp_can_queue_ramp_up() - increases can_queue
  * @lport: lport to ramp up can_queue
- *
- * Locking notes: Called with Scsi_Host lock held
  */
 static void fc_fcp_can_queue_ramp_up(struct fc_lport *lport)
 {
         struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
+        unsigned long flags;
         int can_queue;
 
+        spin_lock_irqsave(lport->host->host_lock, flags);
+
         if (si->last_can_queue_ramp_up_time &&
             (time_before(jiffies, si->last_can_queue_ramp_up_time +
                          FC_CAN_QUEUE_PERIOD)))
-                return;
+                goto unlock;
 
         if (time_before(jiffies, si->last_can_queue_ramp_down_time +
                         FC_CAN_QUEUE_PERIOD))
-                return;
+                goto unlock;
 
         si->last_can_queue_ramp_up_time = jiffies;
 
@@ -362,6 +360,9 @@ static void fc_fcp_can_queue_ramp_up(struct fc_lport *lport)
         lport->host->can_queue = can_queue;
         shost_printk(KERN_ERR, lport->host, "libfc: increased "
                      "can_queue to %d.\n", can_queue);
+
+unlock:
+        spin_unlock_irqrestore(lport->host->host_lock, flags);
 }
 
 /**
@@ -373,18 +374,19 @@ static void fc_fcp_can_queue_ramp_up(struct fc_lport *lport)
  * commands complete or timeout, then try again with a reduced
  * can_queue. Eventually we will hit the point where we run
  * on all reserved structs.
- *
- * Locking notes: Called with Scsi_Host lock held
  */
 static void fc_fcp_can_queue_ramp_down(struct fc_lport *lport)
 {
         struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
+        unsigned long flags;
         int can_queue;
 
+        spin_lock_irqsave(lport->host->host_lock, flags);
+
         if (si->last_can_queue_ramp_down_time &&
             (time_before(jiffies, si->last_can_queue_ramp_down_time +
                          FC_CAN_QUEUE_PERIOD)))
-                return;
+                goto unlock;
 
         si->last_can_queue_ramp_down_time = jiffies;
 
@@ -395,6 +397,9 @@ static void fc_fcp_can_queue_ramp_down(struct fc_lport *lport)
         lport->host->can_queue = can_queue;
         shost_printk(KERN_ERR, lport->host, "libfc: Could not allocate frame.\n"
                      "Reducing can_queue to %d.\n", can_queue);
+
+unlock:
+        spin_unlock_irqrestore(lport->host->host_lock, flags);
 }
 
 /*
@@ -409,16 +414,13 @@ static inline struct fc_frame *fc_fcp_frame_alloc(struct fc_lport *lport,
                                                   size_t len)
 {
         struct fc_frame *fp;
-        unsigned long flags;
 
         fp = fc_frame_alloc(lport, len);
         if (likely(fp))
                 return fp;
 
         /* error case */
-        spin_lock_irqsave(lport->host->host_lock, flags);
         fc_fcp_can_queue_ramp_down(lport);
-        spin_unlock_irqrestore(lport->host->host_lock, flags);
         return NULL;
 }
 
@@ -1093,16 +1095,14 @@ static int fc_fcp_pkt_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp)
 /**
  * get_fsp_rec_tov() - Helper function to get REC_TOV
  * @fsp: the FCP packet
+ *
+ * Returns rec tov in jiffies as rpriv->e_d_tov + 1 second
  */
 static inline unsigned int get_fsp_rec_tov(struct fc_fcp_pkt *fsp)
 {
-        struct fc_rport *rport;
-        struct fc_rport_libfc_priv *rpriv;
-
-        rport = fsp->rport;
-        rpriv = rport->dd_data;
+        struct fc_rport_libfc_priv *rpriv = fsp->rport->dd_data;
 
-        return rpriv->e_d_tov + REC_TOV_CONST;
+        return msecs_to_jiffies(rpriv->e_d_tov) + HZ;
 }
 
 /**
@@ -1122,7 +1122,6 @@ static int fc_fcp_cmd_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
         struct fc_rport_libfc_priv *rpriv;
         const size_t len = sizeof(fsp->cdb_cmd);
         int rc = 0;
-        unsigned int rec_tov;
 
         if (fc_fcp_lock_pkt(fsp))
                 return 0;
@@ -1153,12 +1152,9 @@ static int fc_fcp_cmd_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
         fsp->seq_ptr = seq;
         fc_fcp_pkt_hold(fsp);   /* hold for fc_fcp_pkt_destroy */
 
-        rec_tov = get_fsp_rec_tov(fsp);
-
         setup_timer(&fsp->timer, fc_fcp_timeout, (unsigned long)fsp);
-
         if (rpriv->flags & FC_RP_FLAGS_REC_SUPPORTED)
-                fc_fcp_timer_set(fsp, rec_tov);
+                fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
 
 unlock:
         fc_fcp_unlock_pkt(fsp);
@@ -1235,16 +1231,14 @@ static void fc_lun_reset_send(unsigned long data)
 {
         struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
         struct fc_lport *lport = fsp->lp;
-        unsigned int rec_tov;
 
         if (lport->tt.fcp_cmd_send(lport, fsp, fc_tm_done)) {
                 if (fsp->recov_retry++ >= FC_MAX_RECOV_RETRY)
                         return;
                 if (fc_fcp_lock_pkt(fsp))
                         return;
-                rec_tov = get_fsp_rec_tov(fsp);
                 setup_timer(&fsp->timer, fc_lun_reset_send, (unsigned long)fsp);
-                fc_fcp_timer_set(fsp, rec_tov);
+                fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
                 fc_fcp_unlock_pkt(fsp);
         }
 }
@@ -1536,12 +1530,11 @@ static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
                         }
                         fc_fcp_srr(fsp, r_ctl, offset);
                 } else if (e_stat & ESB_ST_SEQ_INIT) {
-                        unsigned int rec_tov = get_fsp_rec_tov(fsp);
                         /*
                          * The remote port has the initiative, so just
                          * keep waiting for it to complete.
                          */
-                        fc_fcp_timer_set(fsp, rec_tov);
+                        fc_fcp_timer_set(fsp,  get_fsp_rec_tov(fsp));
                 } else {
 
                         /*
@@ -1705,7 +1698,6 @@ static void fc_fcp_srr_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
 {
         struct fc_fcp_pkt *fsp = arg;
         struct fc_frame_header *fh;
-        unsigned int rec_tov;
 
         if (IS_ERR(fp)) {
                 fc_fcp_srr_error(fsp, fp);
@@ -1732,8 +1724,7 @@ static void fc_fcp_srr_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
         switch (fc_frame_payload_op(fp)) {
         case ELS_LS_ACC:
                 fsp->recov_retry = 0;
-                rec_tov = get_fsp_rec_tov(fsp);
-                fc_fcp_timer_set(fsp, rec_tov);
+                fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
                 break;
         case ELS_LS_RJT:
         default:
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index 906bbcad0e2d..389ab80aef0a 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -1590,7 +1590,6 @@ void fc_lport_enter_flogi(struct fc_lport *lport)
  */
 int fc_lport_config(struct fc_lport *lport)
 {
-        INIT_LIST_HEAD(&lport->ema_list);
         INIT_DELAYED_WORK(&lport->retry_work, fc_lport_timeout);
         mutex_init(&lport->lp_mutex);
 
diff --git a/drivers/scsi/lpfc/lpfc.h b/drivers/scsi/lpfc/lpfc.h
index 60e98a62f308..02d53d89534f 100644
--- a/drivers/scsi/lpfc/lpfc.h
+++ b/drivers/scsi/lpfc/lpfc.h
@@ -805,6 +805,8 @@ struct lpfc_hba {
         struct dentry *idiag_root;
         struct dentry *idiag_pci_cfg;
         struct dentry *idiag_que_info;
+        struct dentry *idiag_que_acc;
+        struct dentry *idiag_drb_acc;
 #endif
 
         /* Used for deferred freeing of ELS data buffers */
diff --git a/drivers/scsi/lpfc/lpfc_bsg.c b/drivers/scsi/lpfc/lpfc_bsg.c
index 77b2871d96b7..37e2a1272f86 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.c
+++ b/drivers/scsi/lpfc/lpfc_bsg.c
@@ -2426,6 +2426,7 @@ lpfc_bsg_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
 {
         struct bsg_job_data *dd_data;
         struct fc_bsg_job *job;
+        struct lpfc_mbx_nembed_cmd *nembed_sge;
         uint32_t size;
         unsigned long flags;
         uint8_t *to;
@@ -2469,9 +2470,8 @@ lpfc_bsg_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
                         memcpy(to, from, size);
                 } else if ((phba->sli_rev == LPFC_SLI_REV4) &&
                         (pmboxq->u.mb.mbxCommand == MBX_SLI4_CONFIG)) {
-                        struct lpfc_mbx_nembed_cmd *nembed_sge =
-                                (struct lpfc_mbx_nembed_cmd *)
-                                &pmboxq->u.mb.un.varWords[0];
+                        nembed_sge = (struct lpfc_mbx_nembed_cmd *)
+                                        &pmboxq->u.mb.un.varWords[0];
 
                         from = (uint8_t *)dd_data->context_un.mbox.dmp->dma.
                                                 virt;
@@ -2496,16 +2496,18 @@ lpfc_bsg_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
                                         job->reply_payload.sg_cnt,
                                         from, size);
                 job->reply->result = 0;
-
+                /* need to hold the lock until we set job->dd_data to NULL
+                 * to hold off the timeout handler returning to the mid-layer
+                 * while we are still processing the job.
+                 */
                 job->dd_data = NULL;
+                dd_data->context_un.mbox.set_job = NULL;
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
                 job->job_done(job);
+        } else {
+                dd_data->context_un.mbox.set_job = NULL;
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
         }
-        dd_data->context_un.mbox.set_job = NULL;
-        /* need to hold the lock until we call job done to hold off
-         * the timeout handler returning to the midlayer while
-         * we are stillprocessing the job
-         */
-        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
 
         kfree(dd_data->context_un.mbox.mb);
         mempool_free(dd_data->context_un.mbox.pmboxq, phba->mbox_mem_pool);
@@ -2644,6 +2646,11 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
         struct ulp_bde64 *rxbpl = NULL;
         struct dfc_mbox_req *mbox_req = (struct dfc_mbox_req *)
                 job->request->rqst_data.h_vendor.vendor_cmd;
+        struct READ_EVENT_LOG_VAR *rdEventLog;
+        uint32_t transmit_length, receive_length, mode;
+        struct lpfc_mbx_nembed_cmd *nembed_sge;
+        struct mbox_header *header;
+        struct ulp_bde64 *bde;
         uint8_t *ext = NULL;
         int rc = 0;
         uint8_t *from;
@@ -2651,9 +2658,16 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
         /* in case no data is transferred */
         job->reply->reply_payload_rcv_len = 0;
 
+        /* sanity check to protect driver */
+        if (job->reply_payload.payload_len > BSG_MBOX_SIZE ||
+            job->request_payload.payload_len > BSG_MBOX_SIZE) {
+                rc = -ERANGE;
+                goto job_done;
+        }
+
         /* check if requested extended data lengths are valid */
-        if ((mbox_req->inExtWLen > MAILBOX_EXT_SIZE) ||
-                (mbox_req->outExtWLen > MAILBOX_EXT_SIZE)) {
+        if ((mbox_req->inExtWLen > BSG_MBOX_SIZE/sizeof(uint32_t)) ||
+            (mbox_req->outExtWLen > BSG_MBOX_SIZE/sizeof(uint32_t))) {
                 rc = -ERANGE;
                 goto job_done;
         }
@@ -2744,8 +2758,8 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
          * use ours
          */
         if (pmb->mbxCommand == MBX_RUN_BIU_DIAG64) {
-                uint32_t transmit_length = pmb->un.varWords[1];
-                uint32_t receive_length = pmb->un.varWords[4];
+                transmit_length = pmb->un.varWords[1];
+                receive_length = pmb->un.varWords[4];
                 /* transmit length cannot be greater than receive length or
                  * mailbox extension size
                  */
@@ -2795,10 +2809,9 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                 from += sizeof(MAILBOX_t);
                 memcpy((uint8_t *)dmp->dma.virt, from, transmit_length);
         } else if (pmb->mbxCommand == MBX_READ_EVENT_LOG) {
-                struct READ_EVENT_LOG_VAR *rdEventLog =
-                        &pmb->un.varRdEventLog ;
-                uint32_t receive_length = rdEventLog->rcv_bde64.tus.f.bdeSize;
-                uint32_t mode =  bf_get(lpfc_event_log, rdEventLog);
+                rdEventLog = &pmb->un.varRdEventLog;
+                receive_length = rdEventLog->rcv_bde64.tus.f.bdeSize;
+                mode = bf_get(lpfc_event_log, rdEventLog);
 
                 /* receive length cannot be greater than mailbox
                  * extension size
@@ -2843,7 +2856,7 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                         /* rebuild the command for sli4 using our own buffers
                         * like we do for biu diags
                         */
-                        uint32_t receive_length = pmb->un.varWords[2];
+                        receive_length = pmb->un.varWords[2];
                         /* receive length cannot be greater than mailbox
                          * extension size
                          */
@@ -2879,8 +2892,7 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                         pmb->un.varWords[4] = putPaddrHigh(dmp->dma.phys);
                 } else if ((pmb->mbxCommand == MBX_UPDATE_CFG) &&
                         pmb->un.varUpdateCfg.co) {
-                        struct ulp_bde64 *bde =
-                                (struct ulp_bde64 *)&pmb->un.varWords[4];
+                        bde = (struct ulp_bde64 *)&pmb->un.varWords[4];
 
                         /* bde size cannot be greater than mailbox ext size */
                         if (bde->tus.f.bdeSize > MAILBOX_EXT_SIZE) {
@@ -2921,10 +2933,6 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                         memcpy((uint8_t *)dmp->dma.virt, from,
                                 bde->tus.f.bdeSize);
                 } else if (pmb->mbxCommand == MBX_SLI4_CONFIG) {
-                        struct lpfc_mbx_nembed_cmd *nembed_sge;
-                        struct mbox_header *header;
-                        uint32_t receive_length;
-
                         /* rebuild the command for sli4 using our own buffers
                         * like we do for biu diags
                         */
@@ -3386,6 +3394,7 @@ no_dd_data:
         job->dd_data = NULL;
         return rc;
 }
+
 /**
  * lpfc_bsg_hst_vendor - process a vendor-specific fc_bsg_job
  * @job: fc_bsg_job to handle
diff --git a/drivers/scsi/lpfc/lpfc_bsg.h b/drivers/scsi/lpfc/lpfc_bsg.h
index a2c33e7c9152..b542aca6f5ae 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.h
+++ b/drivers/scsi/lpfc/lpfc_bsg.h
@@ -109,3 +109,133 @@ struct menlo_response {
         uint32_t xri; /* return the xri of the iocb exchange */
 };
 
+/*
+ * macros and data structures for handling sli-config mailbox command
+ * pass-through support, this header file is shared between user and
+ * kernel spaces, note the set of macros are duplicates from lpfc_hw4.h,
+ * with macro names prefixed with bsg_, as the macros defined in
+ * lpfc_hw4.h are not accessible from user space.
+ */
+
+/* Macros to deal with bit fields. Each bit field must have 3 #defines
+ * associated with it (_SHIFT, _MASK, and _WORD).
+ * EG. For a bit field that is in the 7th bit of the "field4" field of a
+ * structure and is 2 bits in size the following #defines must exist:
+ *      struct temp {
+ *              uint32_t        field1;
+ *              uint32_t        field2;
+ *              uint32_t        field3;
+ *              uint32_t        field4;
+ *      #define example_bit_field_SHIFT         7
+ *      #define example_bit_field_MASK          0x03
+ *      #define example_bit_field_WORD          field4
+ *              uint32_t        field5;
+ *      };
+ * Then the macros below may be used to get or set the value of that field.
+ * EG. To get the value of the bit field from the above example:
+ *      struct temp t1;
+ *      value = bsg_bf_get(example_bit_field, &t1);
+ * And then to set that bit field:
+ *      bsg_bf_set(example_bit_field, &t1, 2);
+ * Or clear that bit field:
+ *      bsg_bf_set(example_bit_field, &t1, 0);
+ */
+#define bsg_bf_get_le32(name, ptr) \
+        ((le32_to_cpu((ptr)->name##_WORD) >> name##_SHIFT) & name##_MASK)
+#define bsg_bf_get(name, ptr) \
+        (((ptr)->name##_WORD >> name##_SHIFT) & name##_MASK)
+#define bsg_bf_set_le32(name, ptr, value) \
+        ((ptr)->name##_WORD = cpu_to_le32(((((value) & \
+        name##_MASK) << name##_SHIFT) | (le32_to_cpu((ptr)->name##_WORD) & \
+        ~(name##_MASK << name##_SHIFT)))))
+#define bsg_bf_set(name, ptr, value) \
+        ((ptr)->name##_WORD = ((((value) & name##_MASK) << name##_SHIFT) | \
+        ((ptr)->name##_WORD & ~(name##_MASK << name##_SHIFT))))
+
+/*
+ * The sli_config structure specified here is based on the following
+ * restriction:
+ *
+ * -- SLI_CONFIG EMB=0, carrying MSEs, will carry subcommands without
+ *    carrying HBD.
+ * -- SLI_CONFIG EMB=1, not carrying MSE, will carry subcommands with or
+ *    without carrying HBDs.
+ */
+
+struct lpfc_sli_config_mse {
+        uint32_t pa_lo;
+        uint32_t pa_hi;
+        uint32_t buf_len;
+#define lpfc_mbox_sli_config_mse_len_SHIFT      0
+#define lpfc_mbox_sli_config_mse_len_MASK       0xffffff
+#define lpfc_mbox_sli_config_mse_len_WORD       buf_len
+};
+
+struct lpfc_sli_config_subcmd_hbd {
+        uint32_t buf_len;
+#define lpfc_mbox_sli_config_ecmn_hbd_len_SHIFT 0
+#define lpfc_mbox_sli_config_ecmn_hbd_len_MASK  0xffffff
+#define lpfc_mbox_sli_config_ecmn_hbd_len_WORD  buf_len
+        uint32_t pa_lo;
+        uint32_t pa_hi;
+};
+
+struct lpfc_sli_config_hdr {
+        uint32_t word1;
+#define lpfc_mbox_hdr_emb_SHIFT         0
+#define lpfc_mbox_hdr_emb_MASK          0x00000001
+#define lpfc_mbox_hdr_emb_WORD          word1
+#define lpfc_mbox_hdr_mse_cnt_SHIFT     3
+#define lpfc_mbox_hdr_mse_cnt_MASK      0x0000001f
+#define lpfc_mbox_hdr_mse_cnt_WORD      word1
+        uint32_t payload_length;
+        uint32_t tag_lo;
+        uint32_t tag_hi;
+        uint32_t reserved5;
+};
+
+struct lpfc_sli_config_generic {
+        struct lpfc_sli_config_hdr      sli_config_hdr;
+#define LPFC_MBX_SLI_CONFIG_MAX_MSE     19
+        struct lpfc_sli_config_mse      mse[LPFC_MBX_SLI_CONFIG_MAX_MSE];
+};
+
+struct lpfc_sli_config_subcmnd {
+        struct lpfc_sli_config_hdr      sli_config_hdr;
+        uint32_t word6;
+#define lpfc_subcmnd_opcode_SHIFT       0
+#define lpfc_subcmnd_opcode_MASK        0xff
+#define lpfc_subcmnd_opcode_WORD        word6
+#define lpfc_subcmnd_subsys_SHIFT       8
+#define lpfc_subcmnd_subsys_MASK        0xff
+#define lpfc_subcmnd_subsys_WORD        word6
+        uint32_t timeout;
+        uint32_t request_length;
+        uint32_t word9;
+#define lpfc_subcmnd_version_SHIFT      0
+#define lpfc_subcmnd_version_MASK       0xff
+#define lpfc_subcmnd_version_WORD       word9
+        uint32_t word10;
+#define lpfc_subcmnd_ask_rd_len_SHIFT   0
+#define lpfc_subcmnd_ask_rd_len_MASK    0xffffff
+#define lpfc_subcmnd_ask_rd_len_WORD    word10
+        uint32_t rd_offset;
+        uint32_t obj_name[26];
+        uint32_t hbd_count;
+#define LPFC_MBX_SLI_CONFIG_MAX_HBD     10
+        struct lpfc_sli_config_subcmd_hbd   hbd[LPFC_MBX_SLI_CONFIG_MAX_HBD];
+};
+
+struct lpfc_sli_config_mbox {
+        uint32_t word0;
+#define lpfc_mqe_status_SHIFT           16
+#define lpfc_mqe_status_MASK            0x0000FFFF
+#define lpfc_mqe_status_WORD            word0
+#define lpfc_mqe_command_SHIFT          8
+#define lpfc_mqe_command_MASK           0x000000FF
+#define lpfc_mqe_command_WORD           word0
+        union {
+                struct lpfc_sli_config_generic  sli_config_generic;
+                struct lpfc_sli_config_subcmnd  sli_config_subcmnd;
+        } un;
+};
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.c b/drivers/scsi/lpfc/lpfc_debugfs.c
index 3d967741c708..c93fca058603 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.c
+++ b/drivers/scsi/lpfc/lpfc_debugfs.c
@@ -1119,172 +1119,14 @@ lpfc_debugfs_dumpDataDif_release(struct inode *inode, struct file *file)
 }
 
 /*
+ * ---------------------------------
  * iDiag debugfs file access methods
- */
-
-/*
- * iDiag PCI config space register access methods:
- *
- * The PCI config space register accessees of read, write, read-modify-write
- * for set bits, and read-modify-write for clear bits to SLI4 PCI functions
- * are provided. In the proper SLI4 PCI function's debugfs iDiag directory,
- *
- *      /sys/kernel/debug/lpfc/fn<#>/iDiag
- *
- * the access is through the debugfs entry pciCfg:
- *
- * 1. For PCI config space register read access, there are two read methods:
- *    A) read a single PCI config space register in the size of a byte
- *    (8 bits), a word (16 bits), or a dword (32 bits); or B) browse through
- *    the 4K extended PCI config space.
- *
- *    A) Read a single PCI config space register consists of two steps:
- *
- *    Step-1: Set up PCI config space register read command, the command
- *    syntax is,
- *
- *        echo 1 <where> <count> > pciCfg
- *
- *    where, 1 is the iDiag command for PCI config space read, <where> is the
- *    offset from the beginning of the device's PCI config space to read from,
- *    and <count> is the size of PCI config space register data to read back,
- *    it will be 1 for reading a byte (8 bits), 2 for reading a word (16 bits
- *    or 2 bytes), or 4 for reading a dword (32 bits or 4 bytes).
- *
- *    Setp-2: Perform the debugfs read operation to execute the idiag command
- *    set up in Step-1,
- *
- *        cat pciCfg
- *
- *    Examples:
- *    To read PCI device's vendor-id and device-id from PCI config space,
- *
- *        echo 1 0 4 > pciCfg
- *        cat pciCfg
- *
- *    To read PCI device's currnt command from config space,
- *
- *        echo 1 4 2 > pciCfg
- *        cat pciCfg
- *
- *    B) Browse through the entire 4K extended PCI config space also consists
- *    of two steps:
- *
- *    Step-1: Set up PCI config space register browsing command, the command
- *    syntax is,
- *
- *        echo 1 0 4096 > pciCfg
- *
- *    where, 1 is the iDiag command for PCI config space read, 0 must be used
- *    as the offset for PCI config space register browse, and 4096 must be
- *    used as the count for PCI config space register browse.
- *
- *    Step-2: Repeately issue the debugfs read operation to browse through
- *    the entire PCI config space registers:
- *
- *        cat pciCfg
- *        cat pciCfg
- *        cat pciCfg
- *        ...
- *
- *    When browsing to the end of the 4K PCI config space, the browse method
- *    shall wrap around to start reading from beginning again, and again...
- *
- * 2. For PCI config space register write access, it supports a single PCI
- *    config space register write in the size of a byte (8 bits), a word
- *    (16 bits), or a dword (32 bits). The command syntax is,
- *
- *        echo 2 <where> <count> <value> > pciCfg
- *
- *    where, 2 is the iDiag command for PCI config space write, <where> is
- *    the offset from the beginning of the device's PCI config space to write
- *    into, <count> is the size of data to write into the PCI config space,
- *    it will be 1 for writing a byte (8 bits), 2 for writing a word (16 bits
- *    or 2 bytes), or 4 for writing a dword (32 bits or 4 bytes), and <value>
- *    is the data to be written into the PCI config space register at the
- *    offset.
- *
- *    Examples:
- *    To disable PCI device's interrupt assertion,
- *
- *    1) Read in device's PCI config space register command field <cmd>:
- *
- *           echo 1 4 2 > pciCfg
- *           cat pciCfg
- *
- *    2) Set bit 10 (Interrupt Disable bit) in the <cmd>:
- *
- *           <cmd> = <cmd> | (1 < 10)
- *
- *    3) Write the modified command back:
- *
- *           echo 2 4 2 <cmd> > pciCfg
- *
- * 3. For PCI config space register set bits access, it supports a single PCI
- *    config space register set bits in the size of a byte (8 bits), a word
- *    (16 bits), or a dword (32 bits). The command syntax is,
- *
- *        echo 3 <where> <count> <bitmask> > pciCfg
- *
- *    where, 3 is the iDiag command for PCI config space set bits, <where> is
- *    the offset from the beginning of the device's PCI config space to set
- *    bits into, <count> is the size of the bitmask to set into the PCI config
- *    space, it will be 1 for setting a byte (8 bits), 2 for setting a word
- *    (16 bits or 2 bytes), or 4 for setting a dword (32 bits or 4 bytes), and
- *    <bitmask> is the bitmask, indicating the bits to be set into the PCI
- *    config space register at the offset. The logic performed to the content
- *    of the PCI config space register, regval, is,
- *
- *        regval |= <bitmask>
- *
- * 4. For PCI config space register clear bits access, it supports a single
- *    PCI config space register clear bits in the size of a byte (8 bits),
- *    a word (16 bits), or a dword (32 bits). The command syntax is,
- *
- *        echo 4 <where> <count> <bitmask> > pciCfg
- *
- *    where, 4 is the iDiag command for PCI config space clear bits, <where>
- *    is the offset from the beginning of the device's PCI config space to
- *    clear bits from, <count> is the size of the bitmask to set into the PCI
- *    config space, it will be 1 for setting a byte (8 bits), 2 for setting
- *    a word(16 bits or 2 bytes), or 4 for setting a dword (32 bits or 4
- *    bytes), and <bitmask> is the bitmask, indicating the bits to be cleared
- *    from the PCI config space register at the offset. the logic performed
- *    to the content of the PCI config space register, regval, is,
- *
- *        regval &= ~<bitmask>
- *
- * Note, for all single register read, write, set bits, or clear bits access,
- * the offset (<where>) must be aligned with the size of the data:
- *
- * For data size of byte (8 bits), the offset must be aligned to the byte
- * boundary; for data size of word (16 bits), the offset must be aligned
- * to the word boundary; while for data size of dword (32 bits), the offset
- * must be aligned to the dword boundary. Otherwise, the interface will
- * return the error:
+ * ---------------------------------
  *
- *     "-bash: echo: write error: Invalid argument".
+ * All access methods are through the proper SLI4 PCI function's debugfs
+ * iDiag directory:
  *
- * For example:
- *
- *     echo 1 2 4 > pciCfg
- *     -bash: echo: write error: Invalid argument
- *
- * Note also, all of the numbers in the command fields for all read, write,
- * set bits, and clear bits PCI config space register command fields can be
- * either decimal or hex.
- *
- * For example,
- *     echo 1 0 4096 > pciCfg
- *
- * will be the same as
- *     echo 1 0 0x1000 > pciCfg
- *
- * And,
- *     echo 2 155 1 10 > pciCfg
- *
- * will be
- *     echo 2 0x9b 1 0xa > pciCfg
+ *     /sys/kernel/debug/lpfc/fn<#>/iDiag
  */
 
 /**
@@ -1331,10 +1173,10 @@ static int lpfc_idiag_cmd_get(const char __user *buf, size_t nbytes,
         for (i = 0; i < LPFC_IDIAG_CMD_DATA_SIZE; i++) {
                 step_str = strsep(&pbuf, "\t ");
                 if (!step_str)
-                        return 0;
+                        return i;
                 idiag_cmd->data[i] = simple_strtol(step_str, NULL, 0);
         }
-        return 0;
+        return i;
 }
 
 /**
@@ -1403,7 +1245,7 @@ lpfc_idiag_release(struct inode *inode, struct file *file)
  * Description:
  * This routine frees the buffer that was allocated when the debugfs file
  * was opened. It also reset the fields in the idiag command struct in the
- * case the command is not continuous browsing of the data structure.
+ * case of command for write operation.
  *
  * Returns:
  * This function returns zero.
@@ -1413,18 +1255,20 @@ lpfc_idiag_cmd_release(struct inode *inode, struct file *file)
 {
         struct lpfc_debug *debug = file->private_data;
 
-        /* Read PCI config register, if not read all, clear command fields */
-        if ((debug->op == LPFC_IDIAG_OP_RD) &&
-            (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_RD))
-                if ((idiag.cmd.data[1] == sizeof(uint8_t)) ||
-                    (idiag.cmd.data[1] == sizeof(uint16_t)) ||
-                    (idiag.cmd.data[1] == sizeof(uint32_t)))
+        if (debug->op == LPFC_IDIAG_OP_WR) {
+                switch (idiag.cmd.opcode) {
+                case LPFC_IDIAG_CMD_PCICFG_WR:
+                case LPFC_IDIAG_CMD_PCICFG_ST:
+                case LPFC_IDIAG_CMD_PCICFG_CL:
+                case LPFC_IDIAG_CMD_QUEACC_WR:
+                case LPFC_IDIAG_CMD_QUEACC_ST:
+                case LPFC_IDIAG_CMD_QUEACC_CL:
                         memset(&idiag, 0, sizeof(idiag));
-
-        /* Write PCI config register, clear command fields */
-        if ((debug->op == LPFC_IDIAG_OP_WR) &&
-            (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR))
-                memset(&idiag, 0, sizeof(idiag));
+                        break;
+                default:
+                        break;
+                }
+        }
 
         /* Free the buffers to the file operation */
         kfree(debug->buffer);
@@ -1504,7 +1348,7 @@ lpfc_idiag_pcicfg_read(struct file *file, char __user *buf, size_t nbytes,
                 len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
                                 "%03x: %08x\n", where, u32val);
                 break;
-        case LPFC_PCI_CFG_SIZE: /* browse all */
+        case LPFC_PCI_CFG_BROWSE: /* browse all */
                 goto pcicfg_browse;
                 break;
         default:
@@ -1586,16 +1430,21 @@ lpfc_idiag_pcicfg_write(struct file *file, const char __user *buf,
         debug->op = LPFC_IDIAG_OP_WR;
 
         rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
-        if (rc)
+        if (rc < 0)
                 return rc;
 
         if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_RD) {
+                /* Sanity check on PCI config read command line arguments */
+                if (rc != LPFC_PCI_CFG_RD_CMD_ARG)
+                        goto error_out;
                 /* Read command from PCI config space, set up command fields */
                 where = idiag.cmd.data[0];
                 count = idiag.cmd.data[1];
-                if (count == LPFC_PCI_CFG_SIZE) {
-                        if (where != 0)
+                if (count == LPFC_PCI_CFG_BROWSE) {
+                        if (where % sizeof(uint32_t))
                                 goto error_out;
+                        /* Starting offset to browse */
+                        idiag.offset.last_rd = where;
                 } else if ((count != sizeof(uint8_t)) &&
                            (count != sizeof(uint16_t)) &&
                            (count != sizeof(uint32_t)))
@@ -1621,6 +1470,9 @@ lpfc_idiag_pcicfg_write(struct file *file, const char __user *buf,
         } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR ||
                    idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST ||
                    idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) {
+                /* Sanity check on PCI config write command line arguments */
+                if (rc != LPFC_PCI_CFG_WR_CMD_ARG)
+                        goto error_out;
                 /* Write command to PCI config space, read-modify-write */
                 where = idiag.cmd.data[0];
                 count = idiag.cmd.data[1];
@@ -1753,10 +1605,12 @@ lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes,
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
                         "Slow-path EQ information:\n");
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\tID [%02d], EQE-COUNT [%04d], "
-                        "HOST-INDEX [%04x], PORT-INDEX [%04x]\n\n",
+                        "\tEQID[%02d], "
+                        "QE-COUNT[%04d], QE-SIZE[%04d], "
+                        "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n",
                         phba->sli4_hba.sp_eq->queue_id,
                         phba->sli4_hba.sp_eq->entry_count,
+                        phba->sli4_hba.sp_eq->entry_size,
                         phba->sli4_hba.sp_eq->host_index,
                         phba->sli4_hba.sp_eq->hba_index);
 
@@ -1765,10 +1619,12 @@ lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes,
                         "Fast-path EQ information:\n");
         for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++) {
                 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                                "\tID [%02d], EQE-COUNT [%04d], "
-                                "HOST-INDEX [%04x], PORT-INDEX [%04x]\n",
+                                "\tEQID[%02d], "
+                                "QE-COUNT[%04d], QE-SIZE[%04d], "
+                                "HOST-INDEX[%04d], PORT-INDEX[%04d]\n",
                                 phba->sli4_hba.fp_eq[fcp_qidx]->queue_id,
                                 phba->sli4_hba.fp_eq[fcp_qidx]->entry_count,
+                                phba->sli4_hba.fp_eq[fcp_qidx]->entry_size,
                                 phba->sli4_hba.fp_eq[fcp_qidx]->host_index,
                                 phba->sli4_hba.fp_eq[fcp_qidx]->hba_index);
         }
@@ -1776,89 +1632,101 @@ lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes,
 
         /* Get mailbox complete queue information */
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "Mailbox CQ information:\n");
+                        "Slow-path MBX CQ information:\n");
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\t\tAssociated EQ-ID [%02d]:\n",
+                        "Associated EQID[%02d]:\n",
                         phba->sli4_hba.mbx_cq->assoc_qid);
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\tID [%02d], CQE-COUNT [%04d], "
-                        "HOST-INDEX [%04x], PORT-INDEX [%04x]\n\n",
+                        "\tCQID[%02d], "
+                        "QE-COUNT[%04d], QE-SIZE[%04d], "
+                        "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n",
                         phba->sli4_hba.mbx_cq->queue_id,
                         phba->sli4_hba.mbx_cq->entry_count,
+                        phba->sli4_hba.mbx_cq->entry_size,
                         phba->sli4_hba.mbx_cq->host_index,
                         phba->sli4_hba.mbx_cq->hba_index);
 
         /* Get slow-path complete queue information */
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "Slow-path CQ information:\n");
+                        "Slow-path ELS CQ information:\n");
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\t\tAssociated EQ-ID [%02d]:\n",
+                        "Associated EQID[%02d]:\n",
                         phba->sli4_hba.els_cq->assoc_qid);
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\tID [%02d], CQE-COUNT [%04d], "
-                        "HOST-INDEX [%04x], PORT-INDEX [%04x]\n\n",
+                        "\tCQID [%02d], "
+                        "QE-COUNT[%04d], QE-SIZE[%04d], "
+                        "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n",
                         phba->sli4_hba.els_cq->queue_id,
                         phba->sli4_hba.els_cq->entry_count,
+                        phba->sli4_hba.els_cq->entry_size,
                         phba->sli4_hba.els_cq->host_index,
                         phba->sli4_hba.els_cq->hba_index);
 
         /* Get fast-path complete queue information */
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "Fast-path CQ information:\n");
+                        "Fast-path FCP CQ information:\n");
         for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++) {
                 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                                "\t\tAssociated EQ-ID [%02d]:\n",
+                                "Associated EQID[%02d]:\n",
                                 phba->sli4_hba.fcp_cq[fcp_qidx]->assoc_qid);
                 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                "\tID [%02d], EQE-COUNT [%04d], "
-                "HOST-INDEX [%04x], PORT-INDEX [%04x]\n",
-                phba->sli4_hba.fcp_cq[fcp_qidx]->queue_id,
-                phba->sli4_hba.fcp_cq[fcp_qidx]->entry_count,
-                phba->sli4_hba.fcp_cq[fcp_qidx]->host_index,
-                phba->sli4_hba.fcp_cq[fcp_qidx]->hba_index);
+                                "\tCQID[%02d], "
+                                "QE-COUNT[%04d], QE-SIZE[%04d], "
+                                "HOST-INDEX[%04d], PORT-INDEX[%04d]\n",
+                                phba->sli4_hba.fcp_cq[fcp_qidx]->queue_id,
+                                phba->sli4_hba.fcp_cq[fcp_qidx]->entry_count,
+                                phba->sli4_hba.fcp_cq[fcp_qidx]->entry_size,
+                                phba->sli4_hba.fcp_cq[fcp_qidx]->host_index,
+                                phba->sli4_hba.fcp_cq[fcp_qidx]->hba_index);
         }
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, "\n");
 
         /* Get mailbox queue information */
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "Mailbox MQ information:\n");
+                        "Slow-path MBX MQ information:\n");
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\t\tAssociated CQ-ID [%02d]:\n",
+                        "Associated CQID[%02d]:\n",
                         phba->sli4_hba.mbx_wq->assoc_qid);
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\tID [%02d], MQE-COUNT [%04d], "
-                        "HOST-INDEX [%04x], PORT-INDEX [%04x]\n\n",
+                        "\tWQID[%02d], "
+                        "QE-COUNT[%04d], QE-SIZE[%04d], "
+                        "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n",
                         phba->sli4_hba.mbx_wq->queue_id,
                         phba->sli4_hba.mbx_wq->entry_count,
+                        phba->sli4_hba.mbx_wq->entry_size,
                         phba->sli4_hba.mbx_wq->host_index,
                         phba->sli4_hba.mbx_wq->hba_index);
 
         /* Get slow-path work queue information */
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "Slow-path WQ information:\n");
+                        "Slow-path ELS WQ information:\n");
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\t\tAssociated CQ-ID [%02d]:\n",
+                        "Associated CQID[%02d]:\n",
                         phba->sli4_hba.els_wq->assoc_qid);
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\tID [%02d], WQE-COUNT [%04d], "
-                        "HOST-INDEX [%04x], PORT-INDEX [%04x]\n\n",
+                        "\tWQID[%02d], "
+                        "QE-COUNT[%04d], QE-SIZE[%04d], "
+                        "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n",
                         phba->sli4_hba.els_wq->queue_id,
                         phba->sli4_hba.els_wq->entry_count,
+                        phba->sli4_hba.els_wq->entry_size,
                         phba->sli4_hba.els_wq->host_index,
                         phba->sli4_hba.els_wq->hba_index);
 
         /* Get fast-path work queue information */
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "Fast-path WQ information:\n");
+                        "Fast-path FCP WQ information:\n");
         for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_wq_count; fcp_qidx++) {
                 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                                "\t\tAssociated CQ-ID [%02d]:\n",
+                                "Associated CQID[%02d]:\n",
                                 phba->sli4_hba.fcp_wq[fcp_qidx]->assoc_qid);
                 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                                "\tID [%02d], WQE-COUNT [%04d], "
-                                "HOST-INDEX [%04x], PORT-INDEX [%04x]\n",
+                                "\tWQID[%02d], "
+                                "QE-COUNT[%04d], WQE-SIZE[%04d], "
+                                "HOST-INDEX[%04d], PORT-INDEX[%04d]\n",
                                 phba->sli4_hba.fcp_wq[fcp_qidx]->queue_id,
                                 phba->sli4_hba.fcp_wq[fcp_qidx]->entry_count,
+                                phba->sli4_hba.fcp_wq[fcp_qidx]->entry_size,
                                 phba->sli4_hba.fcp_wq[fcp_qidx]->host_index,
                                 phba->sli4_hba.fcp_wq[fcp_qidx]->hba_index);
         }
@@ -1868,26 +1736,597 @@ lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes,
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
                         "Slow-path RQ information:\n");
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\t\tAssociated CQ-ID [%02d]:\n",
+                        "Associated CQID[%02d]:\n",
                         phba->sli4_hba.hdr_rq->assoc_qid);
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\tID [%02d], RHQE-COUNT [%04d], "
-                        "HOST-INDEX [%04x], PORT-INDEX [%04x]\n",
+                        "\tHQID[%02d], "
+                        "QE-COUNT[%04d], QE-SIZE[%04d], "
+                        "HOST-INDEX[%04d], PORT-INDEX[%04d]\n",
                         phba->sli4_hba.hdr_rq->queue_id,
                         phba->sli4_hba.hdr_rq->entry_count,
+                        phba->sli4_hba.hdr_rq->entry_size,
                         phba->sli4_hba.hdr_rq->host_index,
                         phba->sli4_hba.hdr_rq->hba_index);
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\tID [%02d], RDQE-COUNT [%04d], "
-                        "HOST-INDEX [%04x], PORT-INDEX [%04x]\n",
+                        "\tDQID[%02d], "
+                        "QE-COUNT[%04d], QE-SIZE[%04d], "
+                        "HOST-INDEX[%04d], PORT-INDEX[%04d]\n",
                         phba->sli4_hba.dat_rq->queue_id,
                         phba->sli4_hba.dat_rq->entry_count,
+                        phba->sli4_hba.dat_rq->entry_size,
                         phba->sli4_hba.dat_rq->host_index,
                         phba->sli4_hba.dat_rq->hba_index);
 
         return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
 }
 
+/**
+ * lpfc_idiag_que_param_check - queue access command parameter sanity check
+ * @q: The pointer to queue structure.
+ * @index: The index into a queue entry.
+ * @count: The number of queue entries to access.
+ *
+ * Description:
+ * The routine performs sanity check on device queue access method commands.
+ *
+ * Returns:
+ * This function returns -EINVAL when fails the sanity check, otherwise, it
+ * returns 0.
+ **/
+static int
+lpfc_idiag_que_param_check(struct lpfc_queue *q, int index, int count)
+{
+        /* Only support single entry read or browsing */
+        if ((count != 1) && (count != LPFC_QUE_ACC_BROWSE))
+                return -EINVAL;
+        if (index > q->entry_count - 1)
+                return -EINVAL;
+        return 0;
+}
+
+/**
+ * lpfc_idiag_queacc_read_qe - read a single entry from the given queue index
+ * @pbuffer: The pointer to buffer to copy the read data into.
+ * @pque: The pointer to the queue to be read.
+ * @index: The index into the queue entry.
+ *
+ * Description:
+ * This routine reads out a single entry from the given queue's index location
+ * and copies it into the buffer provided.
+ *
+ * Returns:
+ * This function returns 0 when it fails, otherwise, it returns the length of
+ * the data read into the buffer provided.
+ **/
+static int
+lpfc_idiag_queacc_read_qe(char *pbuffer, int len, struct lpfc_queue *pque,
+                          uint32_t index)
+{
+        int offset, esize;
+        uint32_t *pentry;
+
+        if (!pbuffer || !pque)
+                return 0;
+
+        esize = pque->entry_size;
+        len += snprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len,
+                        "QE-INDEX[%04d]:\n", index);
+
+        offset = 0;
+        pentry = pque->qe[index].address;
+        while (esize > 0) {
+                len += snprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len,
+                                "%08x ", *pentry);
+                pentry++;
+                offset += sizeof(uint32_t);
+                esize -= sizeof(uint32_t);
+                if (esize > 0 && !(offset % (4 * sizeof(uint32_t))))
+                        len += snprintf(pbuffer+len,
+                                        LPFC_QUE_ACC_BUF_SIZE-len, "\n");
+        }
+        len += snprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len, "\n");
+
+        return len;
+}
+
+/**
+ * lpfc_idiag_queacc_read - idiag debugfs read port queue
+ * @file: The file pointer to read from.
+ * @buf: The buffer to copy the data to.
+ * @nbytes: The number of bytes to read.
+ * @ppos: The position in the file to start reading from.
+ *
+ * Description:
+ * This routine reads data from the @phba device queue memory according to the
+ * idiag command, and copies to user @buf. Depending on the queue dump read
+ * command setup, it does either a single queue entry read or browing through
+ * all entries of the queue.
+ *
+ * Returns:
+ * This function returns the amount of data that was read (this could be less
+ * than @nbytes if the end of the file was reached) or a negative error value.
+ **/
+static ssize_t
+lpfc_idiag_queacc_read(struct file *file, char __user *buf, size_t nbytes,
+                       loff_t *ppos)
+{
+        struct lpfc_debug *debug = file->private_data;
+        uint32_t last_index, index, count;
+        struct lpfc_queue *pque = NULL;
+        char *pbuffer;
+        int len = 0;
+
+        /* This is a user read operation */
+        debug->op = LPFC_IDIAG_OP_RD;
+
+        if (!debug->buffer)
+                debug->buffer = kmalloc(LPFC_QUE_ACC_BUF_SIZE, GFP_KERNEL);
+        if (!debug->buffer)
+                return 0;
+        pbuffer = debug->buffer;
+
+        if (*ppos)
+                return 0;
+
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) {
+                index = idiag.cmd.data[2];
+                count = idiag.cmd.data[3];
+                pque = (struct lpfc_queue *)idiag.ptr_private;
+        } else
+                return 0;
+
+        /* Browse the queue starting from index */
+        if (count == LPFC_QUE_ACC_BROWSE)
+                goto que_browse;
+
+        /* Read a single entry from the queue */
+        len = lpfc_idiag_queacc_read_qe(pbuffer, len, pque, index);
+
+        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
+
+que_browse:
+
+        /* Browse all entries from the queue */
+        last_index = idiag.offset.last_rd;
+        index = last_index;
+
+        while (len < LPFC_QUE_ACC_SIZE - pque->entry_size) {
+                len = lpfc_idiag_queacc_read_qe(pbuffer, len, pque, index);
+                index++;
+                if (index > pque->entry_count - 1)
+                        break;
+        }
+
+        /* Set up the offset for next portion of pci cfg read */
+        if (index > pque->entry_count - 1)
+                index = 0;
+        idiag.offset.last_rd = index;
+
+        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
+}
+
+/**
+ * lpfc_idiag_queacc_write - Syntax check and set up idiag queacc commands
+ * @file: The file pointer to read from.
+ * @buf: The buffer to copy the user data from.
+ * @nbytes: The number of bytes to get.
+ * @ppos: The position in the file to start reading from.
+ *
+ * This routine get the debugfs idiag command struct from user space and then
+ * perform the syntax check for port queue read (dump) or write (set) command
+ * accordingly. In the case of port queue read command, it sets up the command
+ * in the idiag command struct for the following debugfs read operation. In
+ * the case of port queue write operation, it executes the write operation
+ * into the port queue entry accordingly.
+ *
+ * It returns the @nbytges passing in from debugfs user space when successful.
+ * In case of error conditions, it returns proper error code back to the user
+ * space.
+ **/
+static ssize_t
+lpfc_idiag_queacc_write(struct file *file, const char __user *buf,
+                        size_t nbytes, loff_t *ppos)
+{
+        struct lpfc_debug *debug = file->private_data;
+        struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
+        uint32_t qidx, quetp, queid, index, count, offset, value;
+        uint32_t *pentry;
+        struct lpfc_queue *pque;
+        int rc;
+
+        /* This is a user write operation */
+        debug->op = LPFC_IDIAG_OP_WR;
+
+        rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
+        if (rc < 0)
+                return rc;
+
+        /* Get and sanity check on command feilds */
+        quetp  = idiag.cmd.data[0];
+        queid  = idiag.cmd.data[1];
+        index  = idiag.cmd.data[2];
+        count  = idiag.cmd.data[3];
+        offset = idiag.cmd.data[4];
+        value  = idiag.cmd.data[5];
+
+        /* Sanity check on command line arguments */
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL) {
+                if (rc != LPFC_QUE_ACC_WR_CMD_ARG)
+                        goto error_out;
+                if (count != 1)
+                        goto error_out;
+        } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) {
+                if (rc != LPFC_QUE_ACC_RD_CMD_ARG)
+                        goto error_out;
+        } else
+                goto error_out;
+
+        switch (quetp) {
+        case LPFC_IDIAG_EQ:
+                /* Slow-path event queue */
+                if (phba->sli4_hba.sp_eq->queue_id == queid) {
+                        /* Sanity check */
+                        rc = lpfc_idiag_que_param_check(
+                                        phba->sli4_hba.sp_eq, index, count);
+                        if (rc)
+                                goto error_out;
+                        idiag.ptr_private = phba->sli4_hba.sp_eq;
+                        goto pass_check;
+                }
+                /* Fast-path event queue */
+                for (qidx = 0; qidx < phba->cfg_fcp_eq_count; qidx++) {
+                        if (phba->sli4_hba.fp_eq[qidx]->queue_id == queid) {
+                                /* Sanity check */
+                                rc = lpfc_idiag_que_param_check(
+                                                phba->sli4_hba.fp_eq[qidx],
+                                                index, count);
+                                if (rc)
+                                        goto error_out;
+                                idiag.ptr_private = phba->sli4_hba.fp_eq[qidx];
+                                goto pass_check;
+                        }
+                }
+                goto error_out;
+                break;
+        case LPFC_IDIAG_CQ:
+                /* MBX complete queue */
+                if (phba->sli4_hba.mbx_cq->queue_id == queid) {
+                        /* Sanity check */
+                        rc = lpfc_idiag_que_param_check(
+                                        phba->sli4_hba.mbx_cq, index, count);
+                        if (rc)
+                                goto error_out;
+                        idiag.ptr_private = phba->sli4_hba.mbx_cq;
+                        goto pass_check;
+                }
+                /* ELS complete queue */
+                if (phba->sli4_hba.els_cq->queue_id == queid) {
+                        /* Sanity check */
+                        rc = lpfc_idiag_que_param_check(
+                                        phba->sli4_hba.els_cq, index, count);
+                        if (rc)
+                                goto error_out;
+                        idiag.ptr_private = phba->sli4_hba.els_cq;
+                        goto pass_check;
+                }
+                /* FCP complete queue */
+                for (qidx = 0; qidx < phba->cfg_fcp_eq_count; qidx++) {
+                        if (phba->sli4_hba.fcp_cq[qidx]->queue_id == queid) {
+                                /* Sanity check */
+                                rc = lpfc_idiag_que_param_check(
+                                                phba->sli4_hba.fcp_cq[qidx],
+                                                index, count);
+                                if (rc)
+                                        goto error_out;
+                                idiag.ptr_private =
+                                                phba->sli4_hba.fcp_cq[qidx];
+                                goto pass_check;
+                        }
+                }
+                goto error_out;
+                break;
+        case LPFC_IDIAG_MQ:
+                /* MBX work queue */
+                if (phba->sli4_hba.mbx_wq->queue_id == queid) {
+                        /* Sanity check */
+                        rc = lpfc_idiag_que_param_check(
+                                        phba->sli4_hba.mbx_wq, index, count);
+                        if (rc)
+                                goto error_out;
+                        idiag.ptr_private = phba->sli4_hba.mbx_wq;
+                        goto pass_check;
+                }
+                break;
+        case LPFC_IDIAG_WQ:
+                /* ELS work queue */
+                if (phba->sli4_hba.els_wq->queue_id == queid) {
+                        /* Sanity check */
+                        rc = lpfc_idiag_que_param_check(
+                                        phba->sli4_hba.els_wq, index, count);
+                        if (rc)
+                                goto error_out;
+                        idiag.ptr_private = phba->sli4_hba.els_wq;
+                        goto pass_check;
+                }
+                /* FCP work queue */
+                for (qidx = 0; qidx < phba->cfg_fcp_wq_count; qidx++) {
+                        if (phba->sli4_hba.fcp_wq[qidx]->queue_id == queid) {
+                                /* Sanity check */
+                                rc = lpfc_idiag_que_param_check(
+                                                phba->sli4_hba.fcp_wq[qidx],
+                                                index, count);
+                                if (rc)
+                                        goto error_out;
+                                idiag.ptr_private =
+                                        phba->sli4_hba.fcp_wq[qidx];
+                                goto pass_check;
+                        }
+                }
+                goto error_out;
+                break;
+        case LPFC_IDIAG_RQ:
+                /* HDR queue */
+                if (phba->sli4_hba.hdr_rq->queue_id == queid) {
+                        /* Sanity check */
+                        rc = lpfc_idiag_que_param_check(
+                                        phba->sli4_hba.hdr_rq, index, count);
+                        if (rc)
+                                goto error_out;
+                        idiag.ptr_private = phba->sli4_hba.hdr_rq;
+                        goto pass_check;
+                }
+                /* DAT queue */
+                if (phba->sli4_hba.dat_rq->queue_id == queid) {
+                        /* Sanity check */
+                        rc = lpfc_idiag_que_param_check(
+                                        phba->sli4_hba.dat_rq, index, count);
+                        if (rc)
+                                goto error_out;
+                        idiag.ptr_private = phba->sli4_hba.dat_rq;
+                        goto pass_check;
+                }
+                goto error_out;
+                break;
+        default:
+                goto error_out;
+                break;
+        }
+
+pass_check:
+
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) {
+                if (count == LPFC_QUE_ACC_BROWSE)
+                        idiag.offset.last_rd = index;
+        }
+
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL) {
+                /* Additional sanity checks on write operation */
+                pque = (struct lpfc_queue *)idiag.ptr_private;
+                if (offset > pque->entry_size/sizeof(uint32_t) - 1)
+                        goto error_out;
+                pentry = pque->qe[index].address;
+                pentry += offset;
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR)
+                        *pentry = value;
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST)
+                        *pentry |= value;
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL)
+                        *pentry &= ~value;
+        }
+        return nbytes;
+
+error_out:
+        /* Clean out command structure on command error out */
+        memset(&idiag, 0, sizeof(idiag));
+        return -EINVAL;
+}
+
+/**
+ * lpfc_idiag_drbacc_read_reg - idiag debugfs read a doorbell register
+ * @phba: The pointer to hba structure.
+ * @pbuffer: The pointer to the buffer to copy the data to.
+ * @len: The lenght of bytes to copied.
+ * @drbregid: The id to doorbell registers.
+ *
+ * Description:
+ * This routine reads a doorbell register and copies its content to the
+ * user buffer pointed to by @pbuffer.
+ *
+ * Returns:
+ * This function returns the amount of data that was copied into @pbuffer.
+ **/
+static int
+lpfc_idiag_drbacc_read_reg(struct lpfc_hba *phba, char *pbuffer,
+                           int len, uint32_t drbregid)
+{
+
+        if (!pbuffer)
+                return 0;
+
+        switch (drbregid) {
+        case LPFC_DRB_EQCQ:
+                len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
+                                "EQCQ-DRB-REG: 0x%08x\n",
+                                readl(phba->sli4_hba.EQCQDBregaddr));
+                break;
+        case LPFC_DRB_MQ:
+                len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
+                                "MQ-DRB-REG:   0x%08x\n",
+                                readl(phba->sli4_hba.MQDBregaddr));
+                break;
+        case LPFC_DRB_WQ:
+                len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
+                                "WQ-DRB-REG:   0x%08x\n",
+                                readl(phba->sli4_hba.WQDBregaddr));
+                break;
+        case LPFC_DRB_RQ:
+                len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
+                                "RQ-DRB-REG:   0x%08x\n",
+                                readl(phba->sli4_hba.RQDBregaddr));
+                break;
+        default:
+                break;
+        }
+
+        return len;
+}
+
+/**
+ * lpfc_idiag_drbacc_read - idiag debugfs read port doorbell
+ * @file: The file pointer to read from.
+ * @buf: The buffer to copy the data to.
+ * @nbytes: The number of bytes to read.
+ * @ppos: The position in the file to start reading from.
+ *
+ * Description:
+ * This routine reads data from the @phba device doorbell register according
+ * to the idiag command, and copies to user @buf. Depending on the doorbell
+ * register read command setup, it does either a single doorbell register
+ * read or dump all doorbell registers.
+ *
+ * Returns:
+ * This function returns the amount of data that was read (this could be less
+ * than @nbytes if the end of the file was reached) or a negative error value.
+ **/
+static ssize_t
+lpfc_idiag_drbacc_read(struct file *file, char __user *buf, size_t nbytes,
+                       loff_t *ppos)
+{
+        struct lpfc_debug *debug = file->private_data;
+        struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
+        uint32_t drb_reg_id, i;
+        char *pbuffer;
+        int len = 0;
+
+        /* This is a user read operation */
+        debug->op = LPFC_IDIAG_OP_RD;
+
+        if (!debug->buffer)
+                debug->buffer = kmalloc(LPFC_DRB_ACC_BUF_SIZE, GFP_KERNEL);
+        if (!debug->buffer)
+                return 0;
+        pbuffer = debug->buffer;
+
+        if (*ppos)
+                return 0;
+
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_RD)
+                drb_reg_id = idiag.cmd.data[0];
+        else
+                return 0;
+
+        if (drb_reg_id == LPFC_DRB_ACC_ALL)
+                for (i = 1; i <= LPFC_DRB_MAX; i++)
+                        len = lpfc_idiag_drbacc_read_reg(phba,
+                                                         pbuffer, len, i);
+        else
+                len = lpfc_idiag_drbacc_read_reg(phba,
+                                                 pbuffer, len, drb_reg_id);
+
+        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
+}
+
+/**
+ * lpfc_idiag_drbacc_write - Syntax check and set up idiag drbacc commands
+ * @file: The file pointer to read from.
+ * @buf: The buffer to copy the user data from.
+ * @nbytes: The number of bytes to get.
+ * @ppos: The position in the file to start reading from.
+ *
+ * This routine get the debugfs idiag command struct from user space and then
+ * perform the syntax check for port doorbell register read (dump) or write
+ * (set) command accordingly. In the case of port queue read command, it sets
+ * up the command in the idiag command struct for the following debugfs read
+ * operation. In the case of port doorbell register write operation, it
+ * executes the write operation into the port doorbell register accordingly.
+ *
+ * It returns the @nbytges passing in from debugfs user space when successful.
+ * In case of error conditions, it returns proper error code back to the user
+ * space.
+ **/
+static ssize_t
+lpfc_idiag_drbacc_write(struct file *file, const char __user *buf,
+                        size_t nbytes, loff_t *ppos)
+{
+        struct lpfc_debug *debug = file->private_data;
+        struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
+        uint32_t drb_reg_id, value, reg_val;
+        void __iomem *drb_reg;
+        int rc;
+
+        /* This is a user write operation */
+        debug->op = LPFC_IDIAG_OP_WR;
+
+        rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
+        if (rc < 0)
+                return rc;
+
+        /* Sanity check on command line arguments */
+        drb_reg_id = idiag.cmd.data[0];
+        value = idiag.cmd.data[1];
+
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) {
+                if (rc != LPFC_DRB_ACC_WR_CMD_ARG)
+                        goto error_out;
+                if (drb_reg_id > LPFC_DRB_MAX)
+                        goto error_out;
+        } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_RD) {
+                if (rc != LPFC_DRB_ACC_RD_CMD_ARG)
+                        goto error_out;
+                if ((drb_reg_id > LPFC_DRB_MAX) &&
+                    (drb_reg_id != LPFC_DRB_ACC_ALL))
+                        goto error_out;
+        } else
+                goto error_out;
+
+        /* Perform the write access operation */
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) {
+                switch (drb_reg_id) {
+                case LPFC_DRB_EQCQ:
+                        drb_reg = phba->sli4_hba.EQCQDBregaddr;
+                        break;
+                case LPFC_DRB_MQ:
+                        drb_reg = phba->sli4_hba.MQDBregaddr;
+                        break;
+                case LPFC_DRB_WQ:
+                        drb_reg = phba->sli4_hba.WQDBregaddr;
+                        break;
+                case LPFC_DRB_RQ:
+                        drb_reg = phba->sli4_hba.RQDBregaddr;
+                        break;
+                default:
+                        goto error_out;
+                }
+
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR)
+                        reg_val = value;
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST) {
+                        reg_val = readl(drb_reg);
+                        reg_val |= value;
+                }
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) {
+                        reg_val = readl(drb_reg);
+                        reg_val &= ~value;
+                }
+                writel(reg_val, drb_reg);
+                readl(drb_reg); /* flush */
+        }
+        return nbytes;
+
+error_out:
+        /* Clean out command structure on command error out */
+        memset(&idiag, 0, sizeof(idiag));
+        return -EINVAL;
+}
+
 #undef lpfc_debugfs_op_disc_trc
 static const struct file_operations lpfc_debugfs_op_disc_trc = {
         .owner =        THIS_MODULE,
@@ -1986,6 +2425,26 @@ static const struct file_operations lpfc_idiag_op_queInfo = {
         .release =      lpfc_idiag_release,
 };
 
+#undef lpfc_idiag_op_queacc
+static const struct file_operations lpfc_idiag_op_queAcc = {
+        .owner =        THIS_MODULE,
+        .open =         lpfc_idiag_open,
+        .llseek =       lpfc_debugfs_lseek,
+        .read =         lpfc_idiag_queacc_read,
+        .write =        lpfc_idiag_queacc_write,
+        .release =      lpfc_idiag_cmd_release,
+};
+
+#undef lpfc_idiag_op_drbacc
+static const struct file_operations lpfc_idiag_op_drbAcc = {
+        .owner =        THIS_MODULE,
+        .open =         lpfc_idiag_open,
+        .llseek =       lpfc_debugfs_lseek,
+        .read =         lpfc_idiag_drbacc_read,
+        .write =        lpfc_idiag_drbacc_write,
+        .release =      lpfc_idiag_cmd_release,
+};
+
 #endif
 
 /**
@@ -2261,6 +2720,32 @@ lpfc_debugfs_initialize(struct lpfc_vport *vport)
                 }
         }
 
+        /* iDiag access PCI function queue */
+        snprintf(name, sizeof(name), "queAcc");
+        if (!phba->idiag_que_acc) {
+                phba->idiag_que_acc =
+                        debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
+                                phba->idiag_root, phba, &lpfc_idiag_op_queAcc);
+                if (!phba->idiag_que_acc) {
+                        lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
+                                         "2926 Can't create idiag debugfs\n");
+                        goto debug_failed;
+                }
+        }
+
+        /* iDiag access PCI function doorbell registers */
+        snprintf(name, sizeof(name), "drbAcc");
+        if (!phba->idiag_drb_acc) {
+                phba->idiag_drb_acc =
+                        debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
+                                phba->idiag_root, phba, &lpfc_idiag_op_drbAcc);
+                if (!phba->idiag_drb_acc) {
+                        lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
+                                         "2927 Can't create idiag debugfs\n");
+                        goto debug_failed;
+                }
+        }
+
 debug_failed:
         return;
 #endif
@@ -2339,6 +2824,16 @@ lpfc_debugfs_terminate(struct lpfc_vport *vport)
                  * iDiag release
                  */
                 if (phba->sli_rev == LPFC_SLI_REV4) {
+                        if (phba->idiag_drb_acc) {
+                                /* iDiag drbAcc */
+                                debugfs_remove(phba->idiag_drb_acc);
+                                phba->idiag_drb_acc = NULL;
+                        }
+                        if (phba->idiag_que_acc) {
+                                /* iDiag queAcc */
+                                debugfs_remove(phba->idiag_que_acc);
+                                phba->idiag_que_acc = NULL;
+                        }
                         if (phba->idiag_que_info) {
                                 /* iDiag queInfo */
                                 debugfs_remove(phba->idiag_que_info);
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.h b/drivers/scsi/lpfc/lpfc_debugfs.h
index 91b9a9427cda..6525a5e62d27 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.h
+++ b/drivers/scsi/lpfc/lpfc_debugfs.h
@@ -39,13 +39,42 @@
 /* hbqinfo output buffer size */
 #define LPFC_HBQINFO_SIZE 8192
 
-/* rdPciConf output buffer size */
+/* pciConf */
+#define LPFC_PCI_CFG_BROWSE 0xffff
+#define LPFC_PCI_CFG_RD_CMD_ARG 2
+#define LPFC_PCI_CFG_WR_CMD_ARG 3
 #define LPFC_PCI_CFG_SIZE 4096
 #define LPFC_PCI_CFG_RD_BUF_SIZE (LPFC_PCI_CFG_SIZE/2)
 #define LPFC_PCI_CFG_RD_SIZE (LPFC_PCI_CFG_SIZE/4)
 
-/* queue info output buffer size */
-#define LPFC_QUE_INFO_GET_BUF_SIZE 2048
+/* queue info */
+#define LPFC_QUE_INFO_GET_BUF_SIZE 4096
+
+/* queue acc */
+#define LPFC_QUE_ACC_BROWSE 0xffff
+#define LPFC_QUE_ACC_RD_CMD_ARG 4
+#define LPFC_QUE_ACC_WR_CMD_ARG 6
+#define LPFC_QUE_ACC_BUF_SIZE 4096
+#define LPFC_QUE_ACC_SIZE (LPFC_QUE_ACC_BUF_SIZE/2)
+
+#define LPFC_IDIAG_EQ 1
+#define LPFC_IDIAG_CQ 2
+#define LPFC_IDIAG_MQ 3
+#define LPFC_IDIAG_WQ 4
+#define LPFC_IDIAG_RQ 5
+
+/* doorbell acc */
+#define LPFC_DRB_ACC_ALL 0xffff
+#define LPFC_DRB_ACC_RD_CMD_ARG 1
+#define LPFC_DRB_ACC_WR_CMD_ARG 2
+#define LPFC_DRB_ACC_BUF_SIZE 256
+
+#define LPFC_DRB_EQCQ 1
+#define LPFC_DRB_MQ   2
+#define LPFC_DRB_WQ   3
+#define LPFC_DRB_RQ   4
+
+#define LPFC_DRB_MAX  4
 
 #define SIZE_U8  sizeof(uint8_t)
 #define SIZE_U16 sizeof(uint16_t)
@@ -73,13 +102,23 @@ struct lpfc_idiag_offset {
         uint32_t last_rd;
 };
 
-#define LPFC_IDIAG_CMD_DATA_SIZE 4
+#define LPFC_IDIAG_CMD_DATA_SIZE 8
 struct lpfc_idiag_cmd {
         uint32_t opcode;
 #define LPFC_IDIAG_CMD_PCICFG_RD 0x00000001
 #define LPFC_IDIAG_CMD_PCICFG_WR 0x00000002
 #define LPFC_IDIAG_CMD_PCICFG_ST 0x00000003
 #define LPFC_IDIAG_CMD_PCICFG_CL 0x00000004
+
+#define LPFC_IDIAG_CMD_QUEACC_RD 0x00000011
+#define LPFC_IDIAG_CMD_QUEACC_WR 0x00000012
+#define LPFC_IDIAG_CMD_QUEACC_ST 0x00000013
+#define LPFC_IDIAG_CMD_QUEACC_CL 0x00000014
+
+#define LPFC_IDIAG_CMD_DRBACC_RD 0x00000021
+#define LPFC_IDIAG_CMD_DRBACC_WR 0x00000022
+#define LPFC_IDIAG_CMD_DRBACC_ST 0x00000023
+#define LPFC_IDIAG_CMD_DRBACC_CL 0x00000024
         uint32_t data[LPFC_IDIAG_CMD_DATA_SIZE];
 };
 
@@ -87,6 +126,7 @@ struct lpfc_idiag {
         uint32_t active;
         struct lpfc_idiag_cmd cmd;
         struct lpfc_idiag_offset offset;
+        void *ptr_private;
 };
 #endif
 
diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
index d34b69f9cdb1..e2c452467c8b 100644
--- a/drivers/scsi/lpfc/lpfc_els.c
+++ b/drivers/scsi/lpfc/lpfc_els.c
@@ -670,6 +670,7 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                          * Driver needs to re-reg VPI in order for f/w
                          * to update the MAC address.
                          */
+                        lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
                         lpfc_register_new_vport(phba, vport, ndlp);
                         return 0;
         }
@@ -869,8 +870,8 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                  */
                 if ((phba->hba_flag & HBA_FIP_SUPPORT) &&
                     (phba->fcf.fcf_flag & FCF_DISCOVERY) &&
-                    (irsp->ulpStatus != IOSTAT_LOCAL_REJECT) &&
-                    (irsp->un.ulpWord[4] != IOERR_SLI_ABORTED)) {
+                    !((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
+                     (irsp->un.ulpWord[4] == IOERR_SLI_ABORTED))) {
                         lpfc_printf_log(phba, KERN_WARNING, LOG_FIP | LOG_ELS,
                                         "2611 FLOGI failed on FCF (x%x), "
                                         "status:x%x/x%x, tmo:x%x, perform "
@@ -1085,14 +1086,15 @@ lpfc_issue_els_flogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         if (sp->cmn.fcphHigh < FC_PH3)
                 sp->cmn.fcphHigh = FC_PH3;
 
-        if  ((phba->sli_rev == LPFC_SLI_REV4) &&
-             (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
-              LPFC_SLI_INTF_IF_TYPE_0)) {
-                elsiocb->iocb.ulpCt_h = ((SLI4_CT_FCFI >> 1) & 1);
-                elsiocb->iocb.ulpCt_l = (SLI4_CT_FCFI & 1);
-                /* FLOGI needs to be 3 for WQE FCFI */
-                /* Set the fcfi to the fcfi we registered with */
-                elsiocb->iocb.ulpContext = phba->fcf.fcfi;
+        if  (phba->sli_rev == LPFC_SLI_REV4) {
+                if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
+                    LPFC_SLI_INTF_IF_TYPE_0) {
+                        elsiocb->iocb.ulpCt_h = ((SLI4_CT_FCFI >> 1) & 1);
+                        elsiocb->iocb.ulpCt_l = (SLI4_CT_FCFI & 1);
+                        /* FLOGI needs to be 3 for WQE FCFI */
+                        /* Set the fcfi to the fcfi we registered with */
+                        elsiocb->iocb.ulpContext = phba->fcf.fcfi;
+                }
         } else if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
                 sp->cmn.request_multiple_Nport = 1;
                 /* For FLOGI, Let FLOGI rsp set the NPortID for VPI 0 */
@@ -4107,13 +4109,13 @@ lpfc_els_clear_rrq(struct lpfc_vport *vport,
         pcmd += sizeof(uint32_t);
         rrq = (struct RRQ *)pcmd;
         rrq->rrq_exchg = be32_to_cpu(rrq->rrq_exchg);
-        rxid = be16_to_cpu(bf_get(rrq_rxid, rrq));
+        rxid = bf_get(rrq_rxid, rrq);
 
         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
                         "2883 Clear RRQ for SID:x%x OXID:x%x RXID:x%x"
                         " x%x x%x\n",
                         be32_to_cpu(bf_get(rrq_did, rrq)),
-                        be16_to_cpu(bf_get(rrq_oxid, rrq)),
+                        bf_get(rrq_oxid, rrq),
                         rxid,
                         iocb->iotag, iocb->iocb.ulpContext);
 
@@ -4121,7 +4123,7 @@ lpfc_els_clear_rrq(struct lpfc_vport *vport,
                 "Clear RRQ:  did:x%x flg:x%x exchg:x%.08x",
                 ndlp->nlp_DID, ndlp->nlp_flag, rrq->rrq_exchg);
         if (vport->fc_myDID == be32_to_cpu(bf_get(rrq_did, rrq)))
-                xri = be16_to_cpu(bf_get(rrq_oxid, rrq));
+                xri = bf_get(rrq_oxid, rrq);
         else
                 xri = rxid;
         prrq = lpfc_get_active_rrq(vport, xri, ndlp->nlp_DID);
@@ -7290,8 +7292,9 @@ lpfc_cmpl_els_npiv_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
         struct lpfc_vport *vport = cmdiocb->vport;
         IOCB_t *irsp;
         struct lpfc_nodelist *ndlp;
-        ndlp = (struct lpfc_nodelist *)cmdiocb->context1;
+        struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 
+        ndlp = (struct lpfc_nodelist *)cmdiocb->context1;
         irsp = &rspiocb->iocb;
         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
                 "LOGO npiv cmpl:  status:x%x/x%x did:x%x",
@@ -7302,6 +7305,19 @@ lpfc_cmpl_els_npiv_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
 
         /* Trigger the release of the ndlp after logo */
         lpfc_nlp_put(ndlp);
+
+        /* NPIV LOGO completes to NPort <nlp_DID> */
+        lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
+                         "2928 NPIV LOGO completes to NPort x%x "
+                         "Data: x%x x%x x%x x%x\n",
+                         ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
+                         irsp->ulpTimeout, vport->num_disc_nodes);
+
+        if (irsp->ulpStatus == IOSTAT_SUCCESS) {
+                spin_lock_irq(shost->host_lock);
+                vport->fc_flag &= ~FC_FABRIC;
+                spin_unlock_irq(shost->host_lock);
+        }
 }
 
 /**
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index 301498301a8f..7a35df5e2038 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2009 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2011 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -3569,6 +3569,10 @@ lpfc_register_remote_port(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
                 "rport add:       did:x%x flg:x%x type x%x",
                 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_type);
 
+        /* Don't add the remote port if unloading. */
+        if (vport->load_flag & FC_UNLOADING)
+                return;
+
         ndlp->rport = rport = fc_remote_port_add(shost, 0, &rport_ids);
         if (!rport || !get_device(&rport->dev)) {
                 dev_printk(KERN_WARNING, &phba->pcidev->dev,
diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h
index 8433ac0d9fb4..4dff668ebdad 100644
--- a/drivers/scsi/lpfc/lpfc_hw4.h
+++ b/drivers/scsi/lpfc/lpfc_hw4.h
@@ -1059,6 +1059,11 @@ struct rq_context {
 #define lpfc_rq_context_rqe_size_SHIFT  8               /* Version 1 Only */
 #define lpfc_rq_context_rqe_size_MASK   0x0000000F
 #define lpfc_rq_context_rqe_size_WORD   word0
+#define LPFC_RQE_SIZE_8         2
+#define LPFC_RQE_SIZE_16        3
+#define LPFC_RQE_SIZE_32        4
+#define LPFC_RQE_SIZE_64        5
+#define LPFC_RQE_SIZE_128       6
 #define lpfc_rq_context_page_size_SHIFT 0               /* Version 1 Only */
 #define lpfc_rq_context_page_size_MASK  0x000000FF
 #define lpfc_rq_context_page_size_WORD  word0
@@ -2108,6 +2113,8 @@ struct lpfc_mbx_pc_sli4_params {
 #define sgl_pp_align_WORD                       word12
         uint32_t rsvd_13_63[51];
 };
+#define SLI4_PAGE_ALIGN(addr) (((addr)+((SLI4_PAGE_SIZE)-1)) \
+                               &(~((SLI4_PAGE_SIZE)-1)))
 
 struct lpfc_sli4_parameters {
         uint32_t word0;
@@ -2491,6 +2498,9 @@ struct wqe_common {
 #define wqe_reqtag_SHIFT      0
 #define wqe_reqtag_MASK       0x0000FFFF
 #define wqe_reqtag_WORD       word9
+#define wqe_temp_rpi_SHIFT    16
+#define wqe_temp_rpi_MASK     0x0000FFFF
+#define wqe_temp_rpi_WORD     word9
 #define wqe_rcvoxid_SHIFT     16
 #define wqe_rcvoxid_MASK      0x0000FFFF
 #define wqe_rcvoxid_WORD      word9
@@ -2524,7 +2534,7 @@ struct wqe_common {
 #define wqe_wqes_WORD         word10
 /* Note that this field overlaps above fields */
 #define wqe_wqid_SHIFT        1
-#define wqe_wqid_MASK         0x0000007f
+#define wqe_wqid_MASK         0x00007fff
 #define wqe_wqid_WORD         word10
 #define wqe_pri_SHIFT         16
 #define wqe_pri_MASK          0x00000007
@@ -2621,7 +2631,11 @@ struct xmit_els_rsp64_wqe {
         uint32_t rsvd4;
         struct wqe_did wqe_dest;
         struct wqe_common wqe_com; /* words 6-11 */
-        uint32_t rsvd_12_15[4];
+        uint32_t word12;
+#define wqe_rsp_temp_rpi_SHIFT    0
+#define wqe_rsp_temp_rpi_MASK     0x0000FFFF
+#define wqe_rsp_temp_rpi_WORD     word12
+        uint32_t rsvd_13_15[3];
 };
 
 struct xmit_bls_rsp64_wqe {
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index 505f88443b5c..7dda036a1af3 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -3209,9 +3209,9 @@ lpfc_sli4_async_link_evt(struct lpfc_hba *phba,
         phba->sli4_hba.link_state.logical_speed =
                         bf_get(lpfc_acqe_logical_link_speed, acqe_link);
         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
-                        "2900 Async FCoE Link event - Speed:%dGBit duplex:x%x "
-                        "LA Type:x%x Port Type:%d Port Number:%d Logical "
-                        "speed:%dMbps Fault:%d\n",
+                        "2900 Async FC/FCoE Link event - Speed:%dGBit "
+                        "duplex:x%x LA Type:x%x Port Type:%d Port Number:%d "
+                        "Logical speed:%dMbps Fault:%d\n",
                         phba->sli4_hba.link_state.speed,
                         phba->sli4_hba.link_state.topology,
                         phba->sli4_hba.link_state.status,
@@ -4906,6 +4906,7 @@ lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
         uint16_t rpi_limit, curr_rpi_range;
         struct lpfc_dmabuf *dmabuf;
         struct lpfc_rpi_hdr *rpi_hdr;
+        uint32_t rpi_count;
 
         rpi_limit = phba->sli4_hba.max_cfg_param.rpi_base +
                     phba->sli4_hba.max_cfg_param.max_rpi - 1;
@@ -4920,7 +4921,9 @@ lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
          * and to allow the full max_rpi range per port.
          */
         if ((curr_rpi_range + (LPFC_RPI_HDR_COUNT - 1)) > rpi_limit)
-                return NULL;
+                rpi_count = rpi_limit - curr_rpi_range;
+        else
+                rpi_count = LPFC_RPI_HDR_COUNT;
 
         /*
          * First allocate the protocol header region for the port.  The
@@ -4961,7 +4964,7 @@ lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
          * The next_rpi stores the next module-64 rpi value to post
          * in any subsequent rpi memory region postings.
          */
-        phba->sli4_hba.next_rpi += LPFC_RPI_HDR_COUNT;
+        phba->sli4_hba.next_rpi += rpi_count;
         spin_unlock_irq(&phba->hbalock);
         return rpi_hdr;
 
@@ -7004,7 +7007,8 @@ lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba)
                 lpfc_sli4_bar0_register_memmap(phba, if_type);
         }
 
-        if (pci_resource_start(pdev, 2)) {
+        if ((if_type == LPFC_SLI_INTF_IF_TYPE_0) &&
+            (pci_resource_start(pdev, 2))) {
                 /*
                  * Map SLI4 if type 0 HBA Control Register base to a kernel
                  * virtual address and setup the registers.
@@ -7021,7 +7025,8 @@ lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba)
                 lpfc_sli4_bar1_register_memmap(phba);
         }
 
-        if (pci_resource_start(pdev, 4)) {
+        if ((if_type == LPFC_SLI_INTF_IF_TYPE_0) &&
+            (pci_resource_start(pdev, 4))) {
                 /*
                  * Map SLI4 if type 0 HBA Doorbell Register base to a kernel
                  * virtual address and setup the registers.
diff --git a/drivers/scsi/lpfc/lpfc_mbox.c b/drivers/scsi/lpfc/lpfc_mbox.c
index fbab9734e9b4..e6ce9033f85e 100644
--- a/drivers/scsi/lpfc/lpfc_mbox.c
+++ b/drivers/scsi/lpfc/lpfc_mbox.c
@@ -1736,7 +1736,7 @@ lpfc_sli4_config(struct lpfc_hba *phba, struct lpfcMboxq *mbox,
         }
 
         /* Setup for the none-embedded mbox command */
-        pcount = (PAGE_ALIGN(length))/SLI4_PAGE_SIZE;
+        pcount = (SLI4_PAGE_ALIGN(length))/SLI4_PAGE_SIZE;
         pcount = (pcount > LPFC_SLI4_MBX_SGE_MAX_PAGES) ?
                                 LPFC_SLI4_MBX_SGE_MAX_PAGES : pcount;
         /* Allocate record for keeping SGE virtual addresses */
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index fe7cc84e773b..84e4481b2406 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -3238,9 +3238,8 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
         if (!lpfc_cmd) {
                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
                          "2873 SCSI Layer I/O Abort Request IO CMPL Status "
-                         "x%x ID %d "
-                         "LUN %d snum %#lx\n", ret, cmnd->device->id,
-                         cmnd->device->lun, cmnd->serial_number);
+                         "x%x ID %d LUN %d\n",
+                         ret, cmnd->device->id, cmnd->device->lun);
                 return SUCCESS;
         }
 
@@ -3318,16 +3317,15 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
                                  "0748 abort handler timed out waiting "
                                  "for abort to complete: ret %#x, ID %d, "
-                                 "LUN %d, snum %#lx\n",
-                                 ret, cmnd->device->id, cmnd->device->lun,
-                                 cmnd->serial_number);
+                                 "LUN %d\n",
+                                 ret, cmnd->device->id, cmnd->device->lun);
         }
 
  out:
         lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
                          "0749 SCSI Layer I/O Abort Request Status x%x ID %d "
-                         "LUN %d snum %#lx\n", ret, cmnd->device->id,
-                         cmnd->device->lun, cmnd->serial_number);
+                         "LUN %d\n", ret, cmnd->device->id,
+                         cmnd->device->lun);
         return ret;
 }
 
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index dacabbe0a586..837d272cb2d6 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -4769,8 +4769,7 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         else
                 phba->hba_flag &= ~HBA_FIP_SUPPORT;
 
-        if (phba->sli_rev != LPFC_SLI_REV4 ||
-            !(phba->hba_flag & HBA_FCOE_MODE)) {
+        if (phba->sli_rev != LPFC_SLI_REV4) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
                         "0376 READ_REV Error. SLI Level %d "
                         "FCoE enabled %d\n",
@@ -5018,10 +5017,11 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
                 lpfc_reg_fcfi(phba, mboxq);
                 mboxq->vport = phba->pport;
                 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
-                if (rc == MBX_SUCCESS)
-                        rc = 0;
-                else
+                if (rc != MBX_SUCCESS)
                         goto out_unset_queue;
+                rc = 0;
+                phba->fcf.fcfi = bf_get(lpfc_reg_fcfi_fcfi,
+                                        &mboxq->u.mqe.un.reg_fcfi);
         }
         /*
          * The port is ready, set the host's link state to LINK_DOWN
@@ -6402,6 +6402,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
         uint32_t els_id = LPFC_ELS_ID_DEFAULT;
         int numBdes, i;
         struct ulp_bde64 bde;
+        struct lpfc_nodelist *ndlp;
 
         fip = phba->hba_flag & HBA_FIP_SUPPORT;
         /* The fcp commands will set command type */
@@ -6447,6 +6448,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
 
         switch (iocbq->iocb.ulpCommand) {
         case CMD_ELS_REQUEST64_CR:
+                ndlp = (struct lpfc_nodelist *)iocbq->context1;
                 if (!iocbq->iocb.ulpLe) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "2007 Only Limited Edition cmd Format"
@@ -6472,6 +6474,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                         els_id = ((iocbq->iocb_flag & LPFC_FIP_ELS_ID_MASK)
                                         >> LPFC_FIP_ELS_ID_SHIFT);
                 }
+                bf_set(wqe_temp_rpi, &wqe->els_req.wqe_com, ndlp->nlp_rpi);
                 bf_set(wqe_els_id, &wqe->els_req.wqe_com, els_id);
                 bf_set(wqe_dbde, &wqe->els_req.wqe_com, 1);
                 bf_set(wqe_iod, &wqe->els_req.wqe_com, LPFC_WQE_IOD_READ);
@@ -6604,6 +6607,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 command_type = OTHER_COMMAND;
         break;
         case CMD_XMIT_ELS_RSP64_CX:
+                ndlp = (struct lpfc_nodelist *)iocbq->context1;
                 /* words0-2 BDE memcpy */
                 /* word3 iocb=iotag32 wqe=response_payload_len */
                 wqe->xmit_els_rsp.response_payload_len = xmit_len;
@@ -6626,6 +6630,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(wqe_lenloc, &wqe->xmit_els_rsp.wqe_com,
                        LPFC_WQE_LENLOC_WORD3);
                 bf_set(wqe_ebde_cnt, &wqe->xmit_els_rsp.wqe_com, 0);
+                bf_set(wqe_rsp_temp_rpi, &wqe->xmit_els_rsp, ndlp->nlp_rpi);
                 command_type = OTHER_COMMAND;
         break;
         case CMD_CLOSE_XRI_CN:
@@ -10522,8 +10527,8 @@ lpfc_cq_create(struct lpfc_hba *phba, struct lpfc_queue *cq,
         bf_set(lpfc_mbox_hdr_version, &shdr->request,
                phba->sli4_hba.pc_sli4_params.cqv);
         if (phba->sli4_hba.pc_sli4_params.cqv == LPFC_Q_CREATE_VERSION_2) {
-                bf_set(lpfc_mbx_cq_create_page_size, &cq_create->u.request,
-                       (PAGE_SIZE/SLI4_PAGE_SIZE));
+                /* FW only supports 1. Should be PAGE_SIZE/SLI4_PAGE_SIZE */
+                bf_set(lpfc_mbx_cq_create_page_size, &cq_create->u.request, 1);
                 bf_set(lpfc_cq_eq_id_2, &cq_create->u.request.context,
                        eq->queue_id);
         } else {
@@ -10967,6 +10972,12 @@ lpfc_rq_create(struct lpfc_hba *phba, struct lpfc_queue *hrq,
                        &rq_create->u.request.context,
                        hrq->entry_count);
                 rq_create->u.request.context.buffer_size = LPFC_HDR_BUF_SIZE;
+                bf_set(lpfc_rq_context_rqe_size,
+                       &rq_create->u.request.context,
+                       LPFC_RQE_SIZE_8);
+                bf_set(lpfc_rq_context_page_size,
+                       &rq_create->u.request.context,
+                       (PAGE_SIZE/SLI4_PAGE_SIZE));
         } else {
                 switch (hrq->entry_count) {
                 default:
@@ -11042,9 +11053,12 @@ lpfc_rq_create(struct lpfc_hba *phba, struct lpfc_queue *hrq,
                phba->sli4_hba.pc_sli4_params.rqv);
         if (phba->sli4_hba.pc_sli4_params.rqv == LPFC_Q_CREATE_VERSION_1) {
                 bf_set(lpfc_rq_context_rqe_count_1,
-                       &rq_create->u.request.context,
-                       hrq->entry_count);
+                       &rq_create->u.request.context, hrq->entry_count);
                 rq_create->u.request.context.buffer_size = LPFC_DATA_BUF_SIZE;
+                bf_set(lpfc_rq_context_rqe_size, &rq_create->u.request.context,
+                       LPFC_RQE_SIZE_8);
+                bf_set(lpfc_rq_context_page_size, &rq_create->u.request.context,
+                       (PAGE_SIZE/SLI4_PAGE_SIZE));
         } else {
                 switch (drq->entry_count) {
                 default:
diff --git a/drivers/scsi/lpfc/lpfc_version.h b/drivers/scsi/lpfc/lpfc_version.h
index 2404d1d65563..c03921b1232c 100644
--- a/drivers/scsi/lpfc/lpfc_version.h
+++ b/drivers/scsi/lpfc/lpfc_version.h
@@ -18,7 +18,7 @@
  * included with this package.                                     *
  *******************************************************************/
 
-#define LPFC_DRIVER_VERSION "8.3.22"
+#define LPFC_DRIVER_VERSION "8.3.23"
 #define LPFC_DRIVER_NAME                "lpfc"
 #define LPFC_SP_DRIVER_HANDLER_NAME     "lpfc:sp"
 #define LPFC_FP_DRIVER_HANDLER_NAME     "lpfc:fp"
diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index f2684dd09ed0..5c1776406c96 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -1469,8 +1469,8 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
                         if( scb->state & SCB_ABORT ) {
 
                                 printk(KERN_WARNING
-                                "megaraid: aborted cmd %lx[%x] complete.\n",
-                                        scb->cmd->serial_number, scb->idx);
+                                "megaraid: aborted cmd [%x] complete.\n",
+                                        scb->idx);
 
                                 scb->cmd->result = (DID_ABORT << 16);
 
@@ -1488,8 +1488,8 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
                         if( scb->state & SCB_RESET ) {
 
                                 printk(KERN_WARNING
-                                "megaraid: reset cmd %lx[%x] complete.\n",
-                                        scb->cmd->serial_number, scb->idx);
+                                "megaraid: reset cmd [%x] complete.\n",
+                                        scb->idx);
 
                                 scb->cmd->result = (DID_RESET << 16);
 
@@ -1958,8 +1958,8 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
         struct list_head        *pos, *next;
         scb_t                   *scb;
 
-        printk(KERN_WARNING "megaraid: %s-%lx cmd=%x <c=%d t=%d l=%d>\n",
-             (aor == SCB_ABORT)? "ABORTING":"RESET", cmd->serial_number,
+        printk(KERN_WARNING "megaraid: %s cmd=%x <c=%d t=%d l=%d>\n",
+             (aor == SCB_ABORT)? "ABORTING":"RESET",
              cmd->cmnd[0], cmd->device->channel, 
              cmd->device->id, cmd->device->lun);
 
@@ -1983,9 +1983,9 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
                         if( scb->state & SCB_ISSUED ) {
 
                                 printk(KERN_WARNING
-                                        "megaraid: %s-%lx[%x], fw owner.\n",
+                                        "megaraid: %s[%x], fw owner.\n",
                                         (aor==SCB_ABORT) ? "ABORTING":"RESET",
-                                        cmd->serial_number, scb->idx);
+                                        scb->idx);
 
                                 return FALSE;
                         }
@@ -1996,9 +1996,9 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
                                  * list
                                  */
                                 printk(KERN_WARNING
-                                        "megaraid: %s-%lx[%x], driver owner.\n",
+                                        "megaraid: %s-[%x], driver owner.\n",
                                         (aor==SCB_ABORT) ? "ABORTING":"RESET",
-                                        cmd->serial_number, scb->idx);
+                                        scb->idx);
 
                                 mega_free_scb(adapter, scb);
 
diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index 1dba32870b4c..2e6619eff3ea 100644
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -2315,8 +2315,8 @@ megaraid_mbox_dpc(unsigned long devp)
                 // Was an abort issued for this command earlier
                 if (scb->state & SCB_ABORT) {
                         con_log(CL_ANN, (KERN_NOTICE
-                        "megaraid: aborted cmd %lx[%x] completed\n",
-                                scp->serial_number, scb->sno));
+                        "megaraid: aborted cmd [%x] completed\n",
+                                scb->sno));
                 }
 
                 /*
@@ -2472,8 +2472,8 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
         raid_dev        = ADAP2RAIDDEV(adapter);
 
         con_log(CL_ANN, (KERN_WARNING
-                "megaraid: aborting-%ld cmd=%x <c=%d t=%d l=%d>\n",
-                scp->serial_number, scp->cmnd[0], SCP2CHANNEL(scp),
+                "megaraid: aborting cmd=%x <c=%d t=%d l=%d>\n",
+                scp->cmnd[0], SCP2CHANNEL(scp),
                 SCP2TARGET(scp), SCP2LUN(scp)));
 
         // If FW has stopped responding, simply return failure
@@ -2496,9 +2496,8 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
                         list_del_init(&scb->list);      // from completed list
 
                         con_log(CL_ANN, (KERN_WARNING
-                        "megaraid: %ld:%d[%d:%d], abort from completed list\n",
-                                scp->serial_number, scb->sno,
-                                scb->dev_channel, scb->dev_target));
+                        "megaraid: %d[%d:%d], abort from completed list\n",
+                                scb->sno, scb->dev_channel, scb->dev_target));
 
                         scp->result = (DID_ABORT << 16);
                         scp->scsi_done(scp);
@@ -2527,9 +2526,8 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
                         ASSERT(!(scb->state & SCB_ISSUED));
 
                         con_log(CL_ANN, (KERN_WARNING
-                                "megaraid abort: %ld[%d:%d], driver owner\n",
-                                scp->serial_number, scb->dev_channel,
-                                scb->dev_target));
+                                "megaraid abort: [%d:%d], driver owner\n",
+                                scb->dev_channel, scb->dev_target));
 
                         scp->result = (DID_ABORT << 16);
                         scp->scsi_done(scp);
@@ -2560,25 +2558,21 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
 
                         if (!(scb->state & SCB_ISSUED)) {
                                 con_log(CL_ANN, (KERN_WARNING
-                                "megaraid abort: %ld%d[%d:%d], invalid state\n",
-                                scp->serial_number, scb->sno, scb->dev_channel,
-                                scb->dev_target));
+                                "megaraid abort: %d[%d:%d], invalid state\n",
+                                scb->sno, scb->dev_channel, scb->dev_target));
                                 BUG();
                         }
                         else {
                                 con_log(CL_ANN, (KERN_WARNING
-                                "megaraid abort: %ld:%d[%d:%d], fw owner\n",
-                                scp->serial_number, scb->sno, scb->dev_channel,
-                                scb->dev_target));
+                                "megaraid abort: %d[%d:%d], fw owner\n",
+                                scb->sno, scb->dev_channel, scb->dev_target));
                         }
                 }
         }
         spin_unlock_irq(&adapter->lock);
 
         if (!found) {
-                con_log(CL_ANN, (KERN_WARNING
-                        "megaraid abort: scsi cmd:%ld, do now own\n",
-                        scp->serial_number));
+                con_log(CL_ANN, (KERN_WARNING "megaraid abort: do now own\n"));
 
                 // FIXME: Should there be a callback for this command?
                 return SUCCESS;
@@ -2649,9 +2643,8 @@ megaraid_reset_handler(struct scsi_cmnd *scp)
                 } else {
                         if (scb->scp == scp) {  // Found command
                                 con_log(CL_ANN, (KERN_WARNING
-                                        "megaraid: %ld:%d[%d:%d], reset from pending list\n",
-                                        scp->serial_number, scb->sno,
-                                        scb->dev_channel, scb->dev_target));
+                                        "megaraid: %d[%d:%d], reset from pending list\n",
+                                        scb->sno, scb->dev_channel, scb->dev_target));
                         } else {
                                 con_log(CL_ANN, (KERN_WARNING
                                 "megaraid: IO packet with %d[%d:%d] being reset\n",
diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 66d4cea4df98..89c623ebadbc 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -1751,10 +1751,9 @@ static int megasas_wait_for_outstanding(struct megasas_instance *instance)
                         list_del_init(&reset_cmd->list);
                         if (reset_cmd->scmd) {
                                 reset_cmd->scmd->result = DID_RESET << 16;
-                                printk(KERN_NOTICE "%d:%p reset [%02x], %#lx\n",
+                                printk(KERN_NOTICE "%d:%p reset [%02x]\n",
                                         reset_index, reset_cmd,
-                                        reset_cmd->scmd->cmnd[0],
-                                        reset_cmd->scmd->serial_number);
+                                        reset_cmd->scmd->cmnd[0]);
 
                                 reset_cmd->scmd->scsi_done(reset_cmd->scmd);
                                 megasas_return_cmd(instance, reset_cmd);
@@ -1879,8 +1878,8 @@ static int megasas_generic_reset(struct scsi_cmnd *scmd)
 
         instance = (struct megasas_instance *)scmd->device->host->hostdata;
 
-        scmd_printk(KERN_NOTICE, scmd, "megasas: RESET -%ld cmd=%x retries=%x\n",
-                 scmd->serial_number, scmd->cmnd[0], scmd->retries);
+        scmd_printk(KERN_NOTICE, scmd, "megasas: RESET cmd=%x retries=%x\n",
+                 scmd->cmnd[0], scmd->retries);
 
         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
                 printk(KERN_ERR "megasas: cannot recover from previous reset "
@@ -2349,9 +2348,9 @@ megasas_issue_pending_cmds_again(struct megasas_instance *instance)
                                                         cmd->frame_phys_addr ,
                                                         0, instance->reg_set);
                 } else if (cmd->scmd) {
-                        printk(KERN_NOTICE "megasas: %p scsi cmd [%02x],%#lx"
+                        printk(KERN_NOTICE "megasas: %p scsi cmd [%02x]"
                         "detected on the internal queue, issue again.\n",
-                        cmd, cmd->scmd->cmnd[0], cmd->scmd->serial_number);
+                        cmd, cmd->scmd->cmnd[0]);
 
                         atomic_inc(&instance->fw_outstanding);
                         instance->instancet->fire_cmd(instance,
diff --git a/drivers/scsi/mesh.c b/drivers/scsi/mesh.c
index 197aa1b3f0f3..494474779532 100644
--- a/drivers/scsi/mesh.c
+++ b/drivers/scsi/mesh.c
@@ -415,8 +415,7 @@ static void mesh_start_cmd(struct mesh_state *ms, struct scsi_cmnd *cmd)
 #if 1
         if (DEBUG_TARGET(cmd)) {
                 int i;
-                printk(KERN_DEBUG "mesh_start: %p ser=%lu tgt=%d cmd=",
-                       cmd, cmd->serial_number, id);
+                printk(KERN_DEBUG "mesh_start: %p tgt=%d cmd=", cmd, id);
                 for (i = 0; i < cmd->cmd_len; ++i)
                         printk(" %x", cmd->cmnd[i]);
                 printk(" use_sg=%d buffer=%p bufflen=%u\n",
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.c b/drivers/scsi/mpt2sas/mpt2sas_base.c
index 3346357031e9..efa0255491c2 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.c
@@ -522,7 +522,8 @@ _base_display_event_data(struct MPT2SAS_ADAPTER *ioc,
                 desc = "Device Status Change";
                 break;
         case MPI2_EVENT_IR_OPERATION_STATUS:
-                desc = "IR Operation Status";
+                if (!ioc->hide_ir_msg)
+                        desc = "IR Operation Status";
                 break;
         case MPI2_EVENT_SAS_DISCOVERY:
         {
@@ -553,16 +554,20 @@ _base_display_event_data(struct MPT2SAS_ADAPTER *ioc,
                 desc = "SAS Enclosure Device Status Change";
                 break;
         case MPI2_EVENT_IR_VOLUME:
-                desc = "IR Volume";
+                if (!ioc->hide_ir_msg)
+                        desc = "IR Volume";
                 break;
         case MPI2_EVENT_IR_PHYSICAL_DISK:
-                desc = "IR Physical Disk";
+                if (!ioc->hide_ir_msg)
+                        desc = "IR Physical Disk";
                 break;
         case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
-                desc = "IR Configuration Change List";
+                if (!ioc->hide_ir_msg)
+                        desc = "IR Configuration Change List";
                 break;
         case MPI2_EVENT_LOG_ENTRY_ADDED:
-                desc = "Log Entry Added";
+                if (!ioc->hide_ir_msg)
+                        desc = "Log Entry Added";
                 break;
         }
 
@@ -616,7 +621,10 @@ _base_sas_log_info(struct MPT2SAS_ADAPTER *ioc , u32 log_info)
                 originator_str = "PL";
                 break;
         case 2:
-                originator_str = "IR";
+                if (!ioc->hide_ir_msg)
+                        originator_str = "IR";
+                else
+                        originator_str = "WarpDrive";
                 break;
         }
 
@@ -1508,6 +1516,7 @@ mpt2sas_base_free_smid(struct MPT2SAS_ADAPTER *ioc, u16 smid)
                 }
                 ioc->scsi_lookup[i].cb_idx = 0xFF;
                 ioc->scsi_lookup[i].scmd = NULL;
+                ioc->scsi_lookup[i].direct_io = 0;
                 list_add_tail(&ioc->scsi_lookup[i].tracker_list,
                     &ioc->free_list);
                 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
@@ -1844,10 +1853,12 @@ _base_display_ioc_capabilities(struct MPT2SAS_ADAPTER *ioc)
         printk("), ");
         printk("Capabilities=(");
 
-        if (ioc->facts.IOCCapabilities &
-            MPI2_IOCFACTS_CAPABILITY_INTEGRATED_RAID) {
-                printk("Raid");
-                i++;
+        if (!ioc->hide_ir_msg) {
+                if (ioc->facts.IOCCapabilities &
+                    MPI2_IOCFACTS_CAPABILITY_INTEGRATED_RAID) {
+                        printk("Raid");
+                        i++;
+                }
         }
 
         if (ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR) {
@@ -3680,6 +3691,7 @@ _base_make_ioc_operational(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
         u32 reply_address;
         u16 smid;
         struct _tr_list *delayed_tr, *delayed_tr_next;
+        u8 hide_flag;
 
         dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
             __func__));
@@ -3706,6 +3718,7 @@ _base_make_ioc_operational(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
                 ioc->scsi_lookup[i].cb_idx = 0xFF;
                 ioc->scsi_lookup[i].smid = smid;
                 ioc->scsi_lookup[i].scmd = NULL;
+                ioc->scsi_lookup[i].direct_io = 0;
                 list_add_tail(&ioc->scsi_lookup[i].tracker_list,
                     &ioc->free_list);
         }
@@ -3766,6 +3779,15 @@ _base_make_ioc_operational(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
         if (sleep_flag == CAN_SLEEP)
                 _base_static_config_pages(ioc);
 
+        if (ioc->wait_for_port_enable_to_complete && ioc->is_warpdrive) {
+                if (ioc->manu_pg10.OEMIdentifier  == 0x80) {
+                        hide_flag = (u8) (ioc->manu_pg10.OEMSpecificFlags0 &
+                            MFG_PAGE10_HIDE_SSDS_MASK);
+                        if (hide_flag != MFG_PAGE10_HIDE_SSDS_MASK)
+                                ioc->mfg_pg10_hide_flag = hide_flag;
+                }
+        }
+
         if (ioc->wait_for_port_enable_to_complete) {
                 if (diag_buffer_enable != 0)
                         mpt2sas_enable_diag_buffer(ioc, diag_buffer_enable);
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.h b/drivers/scsi/mpt2sas/mpt2sas_base.h
index 500328245f61..2a3c05f6db8b 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.h
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.h
@@ -69,11 +69,11 @@
 #define MPT2SAS_DRIVER_NAME             "mpt2sas"
 #define MPT2SAS_AUTHOR  "LSI Corporation <DL-MPTFusionLinux@lsi.com>"
 #define MPT2SAS_DESCRIPTION     "LSI MPT Fusion SAS 2.0 Device Driver"
-#define MPT2SAS_DRIVER_VERSION          "08.100.00.00"
+#define MPT2SAS_DRIVER_VERSION          "08.100.00.01"
 #define MPT2SAS_MAJOR_VERSION           08
 #define MPT2SAS_MINOR_VERSION           100
 #define MPT2SAS_BUILD_VERSION           00
-#define MPT2SAS_RELEASE_VERSION         00
+#define MPT2SAS_RELEASE_VERSION         01
 
 /*
  * Set MPT2SAS_SG_DEPTH value based on user input.
@@ -189,6 +189,16 @@
 #define MPT2SAS_HP_DAUGHTER_2_4_INTERNAL_SSDID        0x0046
 
 /*
+ *  WarpDrive Specific Log codes
+ */
+
+#define MPT2_WARPDRIVE_LOGENTRY         (0x8002)
+#define MPT2_WARPDRIVE_LC_SSDT          (0x41)
+#define MPT2_WARPDRIVE_LC_SSDLW         (0x43)
+#define MPT2_WARPDRIVE_LC_SSDLF         (0x44)
+#define MPT2_WARPDRIVE_LC_BRMF          (0x4D)
+
+/*
  * per target private data
  */
 #define MPT_TARGET_FLAGS_RAID_COMPONENT 0x01
@@ -199,6 +209,7 @@
  * struct MPT2SAS_TARGET - starget private hostdata
  * @starget: starget object
  * @sas_address: target sas address
+ * @raid_device: raid_device pointer to access volume data
  * @handle: device handle
  * @num_luns: number luns
  * @flags: MPT_TARGET_FLAGS_XXX flags
@@ -208,6 +219,7 @@
 struct MPT2SAS_TARGET {
         struct scsi_target *starget;
         u64     sas_address;
+        struct _raid_device *raid_device;
         u16     handle;
         int     num_luns;
         u32     flags;
@@ -215,6 +227,7 @@ struct MPT2SAS_TARGET {
         u8      tm_busy;
 };
 
+
 /*
  * per device private data
  */
@@ -262,6 +275,12 @@ typedef struct _MPI2_CONFIG_PAGE_MAN_10 {
   MPI2_POINTER PTR_MPI2_CONFIG_PAGE_MAN_10,
   Mpi2ManufacturingPage10_t, MPI2_POINTER pMpi2ManufacturingPage10_t;
 
+#define MFG_PAGE10_HIDE_SSDS_MASK       (0x00000003)
+#define MFG_PAGE10_HIDE_ALL_DISKS       (0x00)
+#define MFG_PAGE10_EXPOSE_ALL_DISKS     (0x01)
+#define MFG_PAGE10_HIDE_IF_VOL_PRESENT  (0x02)
+
+
 struct MPT2SAS_DEVICE {
         struct MPT2SAS_TARGET *sas_target;
         unsigned int    lun;
@@ -341,6 +360,7 @@ struct _sas_device {
  * @sdev: scsi device struct (volumes are single lun)
  * @wwid: unique identifier for the volume
  * @handle: device handle
+ * @block_size: Block size of the volume
  * @id: target id
  * @channel: target channel
  * @volume_type: the raid level
@@ -348,20 +368,33 @@ struct _sas_device {
  * @num_pds: number of hidden raid components
  * @responding: used in _scsih_raid_device_mark_responding
  * @percent_complete: resync percent complete
+ * @direct_io_enabled: Whether direct io to PDs are allowed or not
+ * @stripe_exponent: X where 2powX is the stripe sz in blocks
+ * @max_lba: Maximum number of LBA in the volume
+ * @stripe_sz: Stripe Size of the volume
+ * @device_info: Device info of the volume member disk
+ * @pd_handle: Array of handles of the physical drives for direct I/O in le16
  */
+#define MPT_MAX_WARPDRIVE_PDS           8
 struct _raid_device {
         struct list_head list;
         struct scsi_target *starget;
         struct scsi_device *sdev;
         u64     wwid;
         u16     handle;
+        u16     block_sz;
         int     id;
         int     channel;
         u8      volume_type;
-        u32     device_info;
         u8      num_pds;
         u8      responding;
         u8      percent_complete;
+        u8      direct_io_enabled;
+        u8      stripe_exponent;
+        u64     max_lba;
+        u32     stripe_sz;
+        u32     device_info;
+        u16     pd_handle[MPT_MAX_WARPDRIVE_PDS];
 };
 
 /**
@@ -470,6 +503,7 @@ struct chain_tracker {
  * @smid: system message id
  * @scmd: scsi request pointer
  * @cb_idx: callback index
+ * @direct_io: To indicate whether I/O is direct (WARPDRIVE)
  * @chain_list: list of chains associated to this IO
  * @tracker_list: list of free request (ioc->free_list)
  */
@@ -477,14 +511,14 @@ struct scsiio_tracker {
         u16     smid;
         struct scsi_cmnd *scmd;
         u8      cb_idx;
+        u8      direct_io;
         struct list_head chain_list;
         struct list_head tracker_list;
 };
 
 /**
- * struct request_tracker - misc mf request tracker
+ * struct request_tracker - firmware request tracker
  * @smid: system message id
- * @scmd: scsi request pointer
  * @cb_idx: callback index
  * @tracker_list: list of free request (ioc->free_list)
  */
@@ -832,6 +866,11 @@ struct MPT2SAS_ADAPTER {
         u32             diagnostic_flags[MPI2_DIAG_BUF_TYPE_COUNT];
         u32             ring_buffer_offset;
         u32             ring_buffer_sz;
+        u8              is_warpdrive;
+        u8              hide_ir_msg;
+        u8              mfg_pg10_hide_flag;
+        u8              hide_drives;
+
 };
 
 typedef u8 (*MPT_CALLBACK)(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
diff --git a/drivers/scsi/mpt2sas/mpt2sas_ctl.c b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
index d72f1f2b1392..437c2d94c45a 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_ctl.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
@@ -1041,7 +1041,10 @@ _ctl_getiocinfo(void __user *arg)
             __func__));
 
         memset(&karg, 0 , sizeof(karg));
-        karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2;
+        if (ioc->is_warpdrive)
+                karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2_SSS6200;
+        else
+                karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2;
         if (ioc->pfacts)
                 karg.port_number = ioc->pfacts[0].PortNumber;
         pci_read_config_byte(ioc->pdev, PCI_CLASS_REVISION, &revision);
diff --git a/drivers/scsi/mpt2sas/mpt2sas_ctl.h b/drivers/scsi/mpt2sas/mpt2sas_ctl.h
index 69916e46e04f..11ff1d5fb8f0 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_ctl.h
+++ b/drivers/scsi/mpt2sas/mpt2sas_ctl.h
@@ -133,6 +133,7 @@ struct mpt2_ioctl_pci_info {
 #define MPT2_IOCTL_INTERFACE_FC_IP      (0x02)
 #define MPT2_IOCTL_INTERFACE_SAS        (0x03)
 #define MPT2_IOCTL_INTERFACE_SAS2       (0x04)
+#define MPT2_IOCTL_INTERFACE_SAS2_SSS6200       (0x05)
 #define MPT2_IOCTL_VERSION_LENGTH       (32)
 
 /**
diff --git a/drivers/scsi/mpt2sas/mpt2sas_scsih.c b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
index d2064a0533ae..f12e02358d6d 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_scsih.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
@@ -233,6 +233,9 @@ static struct pci_device_id scsih_pci_table[] = {
                 PCI_ANY_ID, PCI_ANY_ID },
         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_3,
                 PCI_ANY_ID, PCI_ANY_ID },
+        /* SSS6200 */
+        { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SSS6200,
+                PCI_ANY_ID, PCI_ANY_ID },
         {0}     /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(pci, scsih_pci_table);
@@ -1256,6 +1259,7 @@ _scsih_target_alloc(struct scsi_target *starget)
                         sas_target_priv_data->handle = raid_device->handle;
                         sas_target_priv_data->sas_address = raid_device->wwid;
                         sas_target_priv_data->flags |= MPT_TARGET_FLAGS_VOLUME;
+                        sas_target_priv_data->raid_device = raid_device;
                         raid_device->starget = starget;
                 }
                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
@@ -1455,7 +1459,10 @@ static int
 _scsih_is_raid(struct device *dev)
 {
         struct scsi_device *sdev = to_scsi_device(dev);
+        struct MPT2SAS_ADAPTER *ioc = shost_priv(sdev->host);
 
+        if (ioc->is_warpdrive)
+                return 0;
         return (sdev->channel == RAID_CHANNEL) ? 1 : 0;
 }
 
@@ -1480,7 +1487,7 @@ _scsih_get_resync(struct device *dev)
             sdev->channel);
         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
 
-        if (!raid_device)
+        if (!raid_device || ioc->is_warpdrive)
                 goto out;
 
         if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
@@ -1640,6 +1647,212 @@ _scsih_get_volume_capabilities(struct MPT2SAS_ADAPTER *ioc,
 
         kfree(vol_pg0);
 }
+/**
+ * _scsih_disable_ddio - Disable direct I/O for all the volumes
+ * @ioc: per adapter object
+ */
+static void
+_scsih_disable_ddio(struct MPT2SAS_ADAPTER *ioc)
+{
+        Mpi2RaidVolPage1_t vol_pg1;
+        Mpi2ConfigReply_t mpi_reply;
+        struct _raid_device *raid_device;
+        u16 handle;
+        u16 ioc_status;
+
+        handle = 0xFFFF;
+        while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
+            &vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
+                ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
+                    MPI2_IOCSTATUS_MASK;
+                if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
+                        break;
+                handle = le16_to_cpu(vol_pg1.DevHandle);
+                raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
+                if (raid_device)
+                        raid_device->direct_io_enabled = 0;
+        }
+        return;
+}
+
+
+/**
+ * _scsih_get_num_volumes - Get number of volumes in the ioc
+ * @ioc: per adapter object
+ */
+static u8
+_scsih_get_num_volumes(struct MPT2SAS_ADAPTER *ioc)
+{
+        Mpi2RaidVolPage1_t vol_pg1;
+        Mpi2ConfigReply_t mpi_reply;
+        u16 handle;
+        u8 vol_cnt = 0;
+        u16 ioc_status;
+
+        handle = 0xFFFF;
+        while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
+            &vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
+                ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
+                    MPI2_IOCSTATUS_MASK;
+                if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
+                        break;
+                vol_cnt++;
+                handle = le16_to_cpu(vol_pg1.DevHandle);
+        }
+        return vol_cnt;
+}
+
+
+/**
+ * _scsih_init_warpdrive_properties - Set properties for warpdrive direct I/O.
+ * @ioc: per adapter object
+ * @raid_device: the raid_device object
+ */
+static void
+_scsih_init_warpdrive_properties(struct MPT2SAS_ADAPTER *ioc,
+        struct _raid_device *raid_device)
+{
+        Mpi2RaidVolPage0_t *vol_pg0;
+        Mpi2RaidPhysDiskPage0_t pd_pg0;
+        Mpi2ConfigReply_t mpi_reply;
+        u16 sz;
+        u8 num_pds, count;
+        u64 mb = 1024 * 1024;
+        u64 tb_2 = 2 * mb * mb;
+        u64 capacity;
+        u32 stripe_sz;
+        u8 i, stripe_exp;
+
+        if (!ioc->is_warpdrive)
+                return;
+
+        if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_EXPOSE_ALL_DISKS) {
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                    "globally as drives are exposed\n", ioc->name);
+                return;
+        }
+        if (_scsih_get_num_volumes(ioc) > 1) {
+                _scsih_disable_ddio(ioc);
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                    "globally as number of drives > 1\n", ioc->name);
+                return;
+        }
+        if ((mpt2sas_config_get_number_pds(ioc, raid_device->handle,
+            &num_pds)) || !num_pds) {
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                    "Failure in computing number of drives\n", ioc->name);
+                return;
+        }
+
+        sz = offsetof(Mpi2RaidVolPage0_t, PhysDisk) + (num_pds *
+            sizeof(Mpi2RaidVol0PhysDisk_t));
+        vol_pg0 = kzalloc(sz, GFP_KERNEL);
+        if (!vol_pg0) {
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                    "Memory allocation failure for RVPG0\n", ioc->name);
+                return;
+        }
+
+        if ((mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
+             MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) {
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                    "Failure in retrieving RVPG0\n", ioc->name);
+                kfree(vol_pg0);
+                return;
+        }
+
+        /*
+         * WARPDRIVE:If number of physical disks in a volume exceeds the max pds
+         * assumed for WARPDRIVE, disable direct I/O
+         */
+        if (num_pds > MPT_MAX_WARPDRIVE_PDS) {
+                printk(MPT2SAS_WARN_FMT "WarpDrive : Direct IO is disabled "
+                    "for the drive with handle(0x%04x): num_mem=%d, "
+                    "max_mem_allowed=%d\n", ioc->name, raid_device->handle,
+                    num_pds, MPT_MAX_WARPDRIVE_PDS);
+                kfree(vol_pg0);
+                return;
+        }
+        for (count = 0; count < num_pds; count++) {
+                if (mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
+                    &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM,
+                    vol_pg0->PhysDisk[count].PhysDiskNum) ||
+                    pd_pg0.DevHandle == MPT2SAS_INVALID_DEVICE_HANDLE) {
+                        printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is "
+                            "disabled for the drive with handle(0x%04x) member"
+                            "handle retrieval failed for member number=%d\n",
+                            ioc->name, raid_device->handle,
+                            vol_pg0->PhysDisk[count].PhysDiskNum);
+                        goto out_error;
+                }
+                raid_device->pd_handle[count] = le16_to_cpu(pd_pg0.DevHandle);
+        }
+
+        /*
+         * Assumption for WD: Direct I/O is not supported if the volume is
+         * not RAID0, if the stripe size is not 64KB, if the block size is
+         * not 512 and if the volume size is >2TB
+         */
+        if (raid_device->volume_type != MPI2_RAID_VOL_TYPE_RAID0 ||
+            le16_to_cpu(vol_pg0->BlockSize) != 512) {
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                    "for the drive with handle(0x%04x): type=%d, "
+                    "s_sz=%uK, blk_size=%u\n", ioc->name,
+                    raid_device->handle, raid_device->volume_type,
+                    le32_to_cpu(vol_pg0->StripeSize)/2,
+                    le16_to_cpu(vol_pg0->BlockSize));
+                goto out_error;
+        }
+
+        capacity = (u64) le16_to_cpu(vol_pg0->BlockSize) *
+            (le64_to_cpu(vol_pg0->MaxLBA) + 1);
+
+        if (capacity > tb_2) {
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                "for the drive with handle(0x%04x) since drive sz > 2TB\n",
+                ioc->name, raid_device->handle);
+                goto out_error;
+        }
+
+        stripe_sz = le32_to_cpu(vol_pg0->StripeSize);
+        stripe_exp = 0;
+        for (i = 0; i < 32; i++) {
+                if (stripe_sz & 1)
+                        break;
+                stripe_exp++;
+                stripe_sz >>= 1;
+        }
+        if (i == 32) {
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                    "for the drive with handle(0x%04x) invalid stripe sz %uK\n",
+                    ioc->name, raid_device->handle,
+                    le32_to_cpu(vol_pg0->StripeSize)/2);
+                goto out_error;
+        }
+        raid_device->stripe_exponent = stripe_exp;
+        raid_device->direct_io_enabled = 1;
+
+        printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is Enabled for the drive"
+            " with handle(0x%04x)\n", ioc->name, raid_device->handle);
+        /*
+         * WARPDRIVE: Though the following fields are not used for direct IO,
+         * stored for future purpose:
+         */
+        raid_device->max_lba = le64_to_cpu(vol_pg0->MaxLBA);
+        raid_device->stripe_sz = le32_to_cpu(vol_pg0->StripeSize);
+        raid_device->block_sz = le16_to_cpu(vol_pg0->BlockSize);
+
+
+        kfree(vol_pg0);
+        return;
+
+out_error:
+        raid_device->direct_io_enabled = 0;
+        for (count = 0; count < num_pds; count++)
+                raid_device->pd_handle[count] = 0;
+        kfree(vol_pg0);
+        return;
+}
 
 /**
  * _scsih_enable_tlr - setting TLR flags
@@ -1710,6 +1923,11 @@ _scsih_slave_configure(struct scsi_device *sdev)
 
                 _scsih_get_volume_capabilities(ioc, raid_device);
 
+                /*
+                 * WARPDRIVE: Initialize the required data for Direct IO
+                 */
+                _scsih_init_warpdrive_properties(ioc, raid_device);
+
                 /* RAID Queue Depth Support
                  * IS volume = underlying qdepth of drive type, either
                  *    MPT2SAS_SAS_QUEUE_DEPTH or MPT2SAS_SATA_QUEUE_DEPTH
@@ -1757,14 +1975,16 @@ _scsih_slave_configure(struct scsi_device *sdev)
                         break;
                 }
 
-                sdev_printk(KERN_INFO, sdev, "%s: "
-                    "handle(0x%04x), wwid(0x%016llx), pd_count(%d), type(%s)\n",
-                    r_level, raid_device->handle,
-                    (unsigned long long)raid_device->wwid,
-                    raid_device->num_pds, ds);
+                if (!ioc->hide_ir_msg)
+                        sdev_printk(KERN_INFO, sdev, "%s: handle(0x%04x), "
+                            "wwid(0x%016llx), pd_count(%d), type(%s)\n",
+                            r_level, raid_device->handle,
+                            (unsigned long long)raid_device->wwid,
+                            raid_device->num_pds, ds);
                 _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
                 /* raid transport support */
-                _scsih_set_level(sdev, raid_device);
+                if (!ioc->is_warpdrive)
+                        _scsih_set_level(sdev, raid_device);
                 return 0;
         }
 
@@ -2133,8 +2353,7 @@ mpt2sas_scsih_issue_tm(struct MPT2SAS_ADAPTER *ioc, u16 handle, uint channel,
         switch (type) {
         case MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
                 scmd_lookup = _scsih_scsi_lookup_get(ioc, smid_task);
-                if (scmd_lookup && (scmd_lookup->serial_number ==
-                    scmd->serial_number))
+                if (scmd_lookup)
                         rc = FAILED;
                 else
                         rc = SUCCESS;
@@ -2182,16 +2401,20 @@ _scsih_tm_display_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd)
         struct MPT2SAS_TARGET *priv_target = starget->hostdata;
         struct _sas_device *sas_device = NULL;
         unsigned long flags;
+        char *device_str = NULL;
 
         if (!priv_target)
                 return;
+        if (ioc->hide_ir_msg)
+                device_str = "WarpDrive";
+        else
+                device_str = "volume";
 
         scsi_print_command(scmd);
         if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
-                starget_printk(KERN_INFO, starget, "volume handle(0x%04x), "
-                    "volume wwid(0x%016llx)\n",
-                    priv_target->handle,
-                    (unsigned long long)priv_target->sas_address);
+                starget_printk(KERN_INFO, starget, "%s handle(0x%04x), "
+                    "%s wwid(0x%016llx)\n", device_str, priv_target->handle,
+                    device_str, (unsigned long long)priv_target->sas_address);
         } else {
                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
                 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
@@ -3130,6 +3353,9 @@ _scsih_check_ir_config_unhide_events(struct MPT2SAS_ADAPTER *ioc,
         a = 0;
         b = 0;
 
+        if (ioc->is_warpdrive)
+                return;
+
         /* Volume Resets for Deleted or Removed */
         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
         for (i = 0; i < event_data->NumElements; i++, element++) {
@@ -3347,6 +3573,105 @@ _scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
 }
 
 /**
+ * _scsih_scsi_direct_io_get - returns direct io flag
+ * @ioc: per adapter object
+ * @smid: system request message index
+ *
+ * Returns the smid stored scmd pointer.
+ */
+static inline u8
+_scsih_scsi_direct_io_get(struct MPT2SAS_ADAPTER *ioc, u16 smid)
+{
+        return ioc->scsi_lookup[smid - 1].direct_io;
+}
+
+/**
+ * _scsih_scsi_direct_io_set - sets direct io flag
+ * @ioc: per adapter object
+ * @smid: system request message index
+ * @direct_io: Zero or non-zero value to set in the direct_io flag
+ *
+ * Returns Nothing.
+ */
+static inline void
+_scsih_scsi_direct_io_set(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 direct_io)
+{
+        ioc->scsi_lookup[smid - 1].direct_io = direct_io;
+}
+
+
+/**
+ * _scsih_setup_direct_io - setup MPI request for WARPDRIVE Direct I/O
+ * @ioc: per adapter object
+ * @scmd: pointer to scsi command object
+ * @raid_device: pointer to raid device data structure
+ * @mpi_request: pointer to the SCSI_IO reqest message frame
+ * @smid: system request message index
+ *
+ * Returns nothing
+ */
+static void
+_scsih_setup_direct_io(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
+        struct _raid_device *raid_device, Mpi2SCSIIORequest_t *mpi_request,
+        u16 smid)
+{
+        u32 v_lba, p_lba, stripe_off, stripe_unit, column, io_size;
+        u32 stripe_sz, stripe_exp;
+        u8 num_pds, *cdb_ptr, *tmp_ptr, *lba_ptr1, *lba_ptr2;
+        u8 cdb0 = scmd->cmnd[0];
+
+        /*
+         * Try Direct I/O to RAID memeber disks
+         */
+        if (cdb0 == READ_16 || cdb0 == READ_10 ||
+            cdb0 == WRITE_16 || cdb0 == WRITE_10) {
+                cdb_ptr = mpi_request->CDB.CDB32;
+
+                if ((cdb0 < READ_16) || !(cdb_ptr[2] | cdb_ptr[3] | cdb_ptr[4]
+                        | cdb_ptr[5])) {
+                        io_size = scsi_bufflen(scmd) >> 9;
+                        /* get virtual lba */
+                        lba_ptr1 = lba_ptr2 = (cdb0 < READ_16) ? &cdb_ptr[2] :
+                            &cdb_ptr[6];
+                        tmp_ptr = (u8 *)&v_lba + 3;
+                        *tmp_ptr-- = *lba_ptr1++;
+                        *tmp_ptr-- = *lba_ptr1++;
+                        *tmp_ptr-- = *lba_ptr1++;
+                        *tmp_ptr = *lba_ptr1;
+
+                        if (((u64)v_lba + (u64)io_size - 1) <=
+                            (u32)raid_device->max_lba) {
+                                stripe_sz = raid_device->stripe_sz;
+                                stripe_exp = raid_device->stripe_exponent;
+                                stripe_off = v_lba & (stripe_sz - 1);
+
+                                /* Check whether IO falls within a stripe */
+                                if ((stripe_off + io_size) <= stripe_sz) {
+                                        num_pds = raid_device->num_pds;
+                                        p_lba = v_lba >> stripe_exp;
+                                        stripe_unit = p_lba / num_pds;
+                                        column = p_lba % num_pds;
+                                        p_lba = (stripe_unit << stripe_exp) +
+                                            stripe_off;
+                                        mpi_request->DevHandle =
+                                                cpu_to_le16(raid_device->
+                                                    pd_handle[column]);
+                                        tmp_ptr = (u8 *)&p_lba + 3;
+                                        *lba_ptr2++ = *tmp_ptr--;
+                                        *lba_ptr2++ = *tmp_ptr--;
+                                        *lba_ptr2++ = *tmp_ptr--;
+                                        *lba_ptr2 = *tmp_ptr;
+                                        /*
+                                        * WD: To indicate this I/O is directI/O
+                                        */
+                                        _scsih_scsi_direct_io_set(ioc, smid, 1);
+                                }
+                        }
+                }
+        }
+}
+
+/**
  * _scsih_qcmd - main scsi request entry point
  * @scmd: pointer to scsi command object
  * @done: function pointer to be invoked on completion
@@ -3363,6 +3688,7 @@ _scsih_qcmd_lck(struct scsi_cmnd *scmd, void (*done)(struct scsi_cmnd *))
         struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
         struct MPT2SAS_DEVICE *sas_device_priv_data;
         struct MPT2SAS_TARGET *sas_target_priv_data;
+        struct _raid_device *raid_device;
         Mpi2SCSIIORequest_t *mpi_request;
         u32 mpi_control;
         u16 smid;
@@ -3424,8 +3750,10 @@ _scsih_qcmd_lck(struct scsi_cmnd *scmd, void (*done)(struct scsi_cmnd *))
 
         } else
                 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
-        /* Make sure Device is not raid volume */
-        if (!_scsih_is_raid(&scmd->device->sdev_gendev) &&
+        /* Make sure Device is not raid volume.
+         * We do not expose raid functionality to upper layer for warpdrive.
+         */
+        if (!ioc->is_warpdrive && !_scsih_is_raid(&scmd->device->sdev_gendev) &&
             sas_is_tlr_enabled(scmd->device) && scmd->cmd_len != 32)
                 mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON;
 
@@ -3473,9 +3801,14 @@ _scsih_qcmd_lck(struct scsi_cmnd *scmd, void (*done)(struct scsi_cmnd *))
                 }
         }
 
+        raid_device = sas_target_priv_data->raid_device;
+        if (raid_device && raid_device->direct_io_enabled)
+                _scsih_setup_direct_io(ioc, scmd, raid_device, mpi_request,
+                    smid);
+
         if (likely(mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST))
                 mpt2sas_base_put_smid_scsi_io(ioc, smid,
-                    sas_device_priv_data->sas_target->handle);
+                    le16_to_cpu(mpi_request->DevHandle));
         else
                 mpt2sas_base_put_smid_default(ioc, smid);
         return 0;
@@ -3540,10 +3873,16 @@ _scsih_scsi_ioc_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
         unsigned long flags;
         struct scsi_target *starget = scmd->device->sdev_target;
         struct MPT2SAS_TARGET *priv_target = starget->hostdata;
+        char *device_str = NULL;
 
         if (!priv_target)
                 return;
 
+        if (ioc->hide_ir_msg)
+                device_str = "WarpDrive";
+        else
+                device_str = "volume";
+
         if (log_info == 0x31170000)
                 return;
 
@@ -3660,8 +3999,8 @@ _scsih_scsi_ioc_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
         scsi_print_command(scmd);
 
         if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
-                printk(MPT2SAS_WARN_FMT "\tvolume wwid(0x%016llx)\n", ioc->name,
-                    (unsigned long long)priv_target->sas_address);
+                printk(MPT2SAS_WARN_FMT "\t%s wwid(0x%016llx)\n", ioc->name,
+                    device_str, (unsigned long long)priv_target->sas_address);
         } else {
                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
                 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
@@ -3840,6 +4179,20 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
                 scmd->result = DID_NO_CONNECT << 16;
                 goto out;
         }
+        /*
+         * WARPDRIVE: If direct_io is set then it is directIO,
+         * the failed direct I/O should be redirected to volume
+         */
+        if (_scsih_scsi_direct_io_get(ioc, smid)) {
+                _scsih_scsi_direct_io_set(ioc, smid, 0);
+                memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
+                mpi_request->DevHandle =
+                    cpu_to_le16(sas_device_priv_data->sas_target->handle);
+                mpt2sas_base_put_smid_scsi_io(ioc, smid,
+                    sas_device_priv_data->sas_target->handle);
+                return 0;
+        }
+
 
         /* turning off TLR */
         scsi_state = mpi_reply->SCSIState;
@@ -3848,7 +4201,10 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
                     le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF;
         if (!sas_device_priv_data->tlr_snoop_check) {
                 sas_device_priv_data->tlr_snoop_check++;
-        if (!_scsih_is_raid(&scmd->device->sdev_gendev) &&
+        /* Make sure Device is not raid volume.
+         * We do not expose raid functionality to upper layer for warpdrive.
+         */
+        if (!ioc->is_warpdrive && !_scsih_is_raid(&scmd->device->sdev_gendev) &&
                 sas_is_tlr_enabled(scmd->device) &&
                     response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME) {
                         sas_disable_tlr(scmd->device);
@@ -4681,8 +5037,10 @@ _scsih_remove_device(struct MPT2SAS_ADAPTER *ioc,
 
         _scsih_ublock_io_device(ioc, sas_device_backup.handle);
 
-        mpt2sas_transport_port_remove(ioc, sas_device_backup.sas_address,
-            sas_device_backup.sas_address_parent);
+        if (!ioc->hide_drives)
+                mpt2sas_transport_port_remove(ioc,
+                    sas_device_backup.sas_address,
+                    sas_device_backup.sas_address_parent);
 
         printk(MPT2SAS_INFO_FMT "removing handle(0x%04x), sas_addr"
             "(0x%016llx)\n", ioc->name, sas_device_backup.handle,
@@ -5413,6 +5771,7 @@ _scsih_sas_pd_hide(struct MPT2SAS_ADAPTER *ioc,
             &sas_device->volume_wwid);
         set_bit(handle, ioc->pd_handles);
         _scsih_reprobe_target(sas_device->starget, 1);
+
 }
 
 /**
@@ -5591,7 +5950,8 @@ _scsih_sas_ir_config_change_event(struct MPT2SAS_ADAPTER *ioc,
         Mpi2EventDataIrConfigChangeList_t *event_data = fw_event->event_data;
 
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
-        if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
+        if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
+            && !ioc->hide_ir_msg)
                 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
 
 #endif
@@ -5614,16 +5974,20 @@ _scsih_sas_ir_config_change_event(struct MPT2SAS_ADAPTER *ioc,
                                     le16_to_cpu(element->VolDevHandle));
                         break;
                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
-                        _scsih_sas_pd_hide(ioc, element);
+                        if (!ioc->is_warpdrive)
+                                _scsih_sas_pd_hide(ioc, element);
                         break;
                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
-                        _scsih_sas_pd_expose(ioc, element);
+                        if (!ioc->is_warpdrive)
+                                _scsih_sas_pd_expose(ioc, element);
                         break;
                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
-                        _scsih_sas_pd_add(ioc, element);
+                        if (!ioc->is_warpdrive)
+                                _scsih_sas_pd_add(ioc, element);
                         break;
                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
-                        _scsih_sas_pd_delete(ioc, element);
+                        if (!ioc->is_warpdrive)
+                                _scsih_sas_pd_delete(ioc, element);
                         break;
                 }
         }
@@ -5654,9 +6018,10 @@ _scsih_sas_ir_volume_event(struct MPT2SAS_ADAPTER *ioc,
 
         handle = le16_to_cpu(event_data->VolDevHandle);
         state = le32_to_cpu(event_data->NewValue);
-        dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
-            "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
-            le32_to_cpu(event_data->PreviousValue), state));
+        if (!ioc->hide_ir_msg)
+                dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
+                    "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
+                    le32_to_cpu(event_data->PreviousValue), state));
 
         switch (state) {
         case MPI2_RAID_VOL_STATE_MISSING:
@@ -5736,9 +6101,10 @@ _scsih_sas_ir_physical_disk_event(struct MPT2SAS_ADAPTER *ioc,
         handle = le16_to_cpu(event_data->PhysDiskDevHandle);
         state = le32_to_cpu(event_data->NewValue);
 
-        dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
-            "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
-            le32_to_cpu(event_data->PreviousValue), state));
+        if (!ioc->hide_ir_msg)
+                dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
+                    "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
+                    le32_to_cpu(event_data->PreviousValue), state));
 
         switch (state) {
         case MPI2_RAID_PD_STATE_ONLINE:
@@ -5747,7 +6113,8 @@ _scsih_sas_ir_physical_disk_event(struct MPT2SAS_ADAPTER *ioc,
         case MPI2_RAID_PD_STATE_OPTIMAL:
         case MPI2_RAID_PD_STATE_HOT_SPARE:
 
-                set_bit(handle, ioc->pd_handles);
+                if (!ioc->is_warpdrive)
+                        set_bit(handle, ioc->pd_handles);
 
                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
                 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
@@ -5851,7 +6218,8 @@ _scsih_sas_ir_operation_status_event(struct MPT2SAS_ADAPTER *ioc,
         u16 handle;
 
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
-        if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
+        if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
+            && !ioc->hide_ir_msg)
                 _scsih_sas_ir_operation_status_event_debug(ioc,
                      event_data);
 #endif
@@ -5910,7 +6278,7 @@ static void
 _scsih_mark_responding_sas_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
     u16 slot, u16 handle)
 {
-        struct MPT2SAS_TARGET *sas_target_priv_data;
+        struct MPT2SAS_TARGET *sas_target_priv_data = NULL;
         struct scsi_target *starget;
         struct _sas_device *sas_device;
         unsigned long flags;
@@ -5918,7 +6286,7 @@ _scsih_mark_responding_sas_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
         spin_lock_irqsave(&ioc->sas_device_lock, flags);
         list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
                 if (sas_device->sas_address == sas_address &&
-                    sas_device->slot == slot && sas_device->starget) {
+                    sas_device->slot == slot) {
                         sas_device->responding = 1;
                         starget = sas_device->starget;
                         if (starget && starget->hostdata) {
@@ -5927,13 +6295,15 @@ _scsih_mark_responding_sas_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
                                 sas_target_priv_data->deleted = 0;
                         } else
                                 sas_target_priv_data = NULL;
-                        starget_printk(KERN_INFO, sas_device->starget,
-                            "handle(0x%04x), sas_addr(0x%016llx), enclosure "
-                            "logical id(0x%016llx), slot(%d)\n", handle,
-                            (unsigned long long)sas_device->sas_address,
-                            (unsigned long long)
-                            sas_device->enclosure_logical_id,
-                            sas_device->slot);
+                        if (starget)
+                                starget_printk(KERN_INFO, starget,
+                                    "handle(0x%04x), sas_addr(0x%016llx), "
+                                    "enclosure logical id(0x%016llx), "
+                                    "slot(%d)\n", handle,
+                                    (unsigned long long)sas_device->sas_address,
+                                    (unsigned long long)
+                                    sas_device->enclosure_logical_id,
+                                    sas_device->slot);
                         if (sas_device->handle == handle)
                                 goto out;
                         printk(KERN_INFO "\thandle changed from(0x%04x)!!!\n",
@@ -6025,6 +6395,12 @@ _scsih_mark_responding_raid_device(struct MPT2SAS_ADAPTER *ioc, u64 wwid,
                         starget_printk(KERN_INFO, raid_device->starget,
                             "handle(0x%04x), wwid(0x%016llx)\n", handle,
                             (unsigned long long)raid_device->wwid);
+                        /*
+                         * WARPDRIVE: The handles of the PDs might have changed
+                         * across the host reset so re-initialize the
+                         * required data for Direct IO
+                         */
+                        _scsih_init_warpdrive_properties(ioc, raid_device);
                         if (raid_device->handle == handle)
                                 goto out;
                         printk(KERN_INFO "\thandle changed from(0x%04x)!!!\n",
@@ -6086,18 +6462,20 @@ _scsih_search_responding_raid_devices(struct MPT2SAS_ADAPTER *ioc)
         }
 
         /* refresh the pd_handles */
-        phys_disk_num = 0xFF;
-        memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
-        while (!(mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
-            &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
-            phys_disk_num))) {
-                ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
-                    MPI2_IOCSTATUS_MASK;
-                if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
-                        break;
-                phys_disk_num = pd_pg0.PhysDiskNum;
-                handle = le16_to_cpu(pd_pg0.DevHandle);
-                set_bit(handle, ioc->pd_handles);
+        if (!ioc->is_warpdrive) {
+                phys_disk_num = 0xFF;
+                memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
+                while (!(mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
+                    &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
+                    phys_disk_num))) {
+                        ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
+                            MPI2_IOCSTATUS_MASK;
+                        if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
+                                break;
+                        phys_disk_num = pd_pg0.PhysDiskNum;
+                        handle = le16_to_cpu(pd_pg0.DevHandle);
+                        set_bit(handle, ioc->pd_handles);
+                }
         }
 }
 
@@ -6243,6 +6621,50 @@ _scsih_remove_unresponding_sas_devices(struct MPT2SAS_ADAPTER *ioc)
 }
 
 /**
+ * _scsih_hide_unhide_sas_devices - add/remove device to/from OS
+ * @ioc: per adapter object
+ *
+ * Return nothing.
+ */
+static void
+_scsih_hide_unhide_sas_devices(struct MPT2SAS_ADAPTER *ioc)
+{
+        struct _sas_device *sas_device, *sas_device_next;
+
+        if (!ioc->is_warpdrive || ioc->mfg_pg10_hide_flag !=
+            MFG_PAGE10_HIDE_IF_VOL_PRESENT)
+                return;
+
+        if (ioc->hide_drives) {
+                if (_scsih_get_num_volumes(ioc))
+                        return;
+                ioc->hide_drives = 0;
+                list_for_each_entry_safe(sas_device, sas_device_next,
+                    &ioc->sas_device_list, list) {
+                        if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
+                                sas_device->sas_address_parent)) {
+                                _scsih_sas_device_remove(ioc, sas_device);
+                        } else if (!sas_device->starget) {
+                                mpt2sas_transport_port_remove(ioc,
+                                    sas_device->sas_address,
+                                    sas_device->sas_address_parent);
+                                _scsih_sas_device_remove(ioc, sas_device);
+                        }
+                }
+        } else {
+                if (!_scsih_get_num_volumes(ioc))
+                        return;
+                ioc->hide_drives = 1;
+                list_for_each_entry_safe(sas_device, sas_device_next,
+                    &ioc->sas_device_list, list) {
+                        mpt2sas_transport_port_remove(ioc,
+                            sas_device->sas_address,
+                            sas_device->sas_address_parent);
+                }
+        }
+}
+
+/**
  * mpt2sas_scsih_reset_handler - reset callback handler (for scsih)
  * @ioc: per adapter object
  * @reset_phase: phase
@@ -6326,6 +6748,7 @@ _firmware_event_work(struct work_struct *work)
                         spin_unlock_irqrestore(&ioc->ioc_reset_in_progress_lock,
                             flags);
                 _scsih_remove_unresponding_sas_devices(ioc);
+                _scsih_hide_unhide_sas_devices(ioc);
                 return;
         }
 
@@ -6425,6 +6848,53 @@ mpt2sas_scsih_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index,
                     (Mpi2EventDataIrVolume_t *)
                     mpi_reply->EventData);
                 break;
+        case MPI2_EVENT_LOG_ENTRY_ADDED:
+        {
+                Mpi2EventDataLogEntryAdded_t *log_entry;
+                u32 *log_code;
+
+                if (!ioc->is_warpdrive)
+                        break;
+
+                log_entry = (Mpi2EventDataLogEntryAdded_t *)
+                    mpi_reply->EventData;
+                log_code = (u32 *)log_entry->LogData;
+
+                if (le16_to_cpu(log_entry->LogEntryQualifier)
+                    != MPT2_WARPDRIVE_LOGENTRY)
+                        break;
+
+                switch (le32_to_cpu(*log_code)) {
+                case MPT2_WARPDRIVE_LC_SSDT:
+                        printk(MPT2SAS_WARN_FMT "WarpDrive Warning: "
+                            "IO Throttling has occurred in the WarpDrive "
+                            "subsystem. Check WarpDrive documentation for "
+                            "additional details.\n", ioc->name);
+                        break;
+                case MPT2_WARPDRIVE_LC_SSDLW:
+                        printk(MPT2SAS_WARN_FMT "WarpDrive Warning: "
+                            "Program/Erase Cycles for the WarpDrive subsystem "
+                            "in degraded range. Check WarpDrive documentation "
+                            "for additional details.\n", ioc->name);
+                        break;
+                case MPT2_WARPDRIVE_LC_SSDLF:
+                        printk(MPT2SAS_ERR_FMT "WarpDrive Fatal Error: "
+                            "There are no Program/Erase Cycles for the "
+                            "WarpDrive subsystem. The storage device will be "
+                            "in read-only mode. Check WarpDrive documentation "
+                            "for additional details.\n", ioc->name);
+                        break;
+                case MPT2_WARPDRIVE_LC_BRMF:
+                        printk(MPT2SAS_ERR_FMT "WarpDrive Fatal Error: "
+                            "The Backup Rail Monitor has failed on the "
+                            "WarpDrive subsystem. Check WarpDrive "
+                            "documentation for additional details.\n",
+                            ioc->name);
+                        break;
+                }
+
+                break;
+        }
         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
         case MPI2_EVENT_IR_OPERATION_STATUS:
         case MPI2_EVENT_SAS_DISCOVERY:
@@ -6583,7 +7053,8 @@ _scsih_ir_shutdown(struct MPT2SAS_ADAPTER *ioc)
         mpi_request->Function = MPI2_FUNCTION_RAID_ACTION;
         mpi_request->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED;
 
-        printk(MPT2SAS_INFO_FMT "IR shutdown (sending)\n", ioc->name);
+        if (!ioc->hide_ir_msg)
+                printk(MPT2SAS_INFO_FMT "IR shutdown (sending)\n", ioc->name);
         init_completion(&ioc->scsih_cmds.done);
         mpt2sas_base_put_smid_default(ioc, smid);
         wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
@@ -6597,10 +7068,11 @@ _scsih_ir_shutdown(struct MPT2SAS_ADAPTER *ioc)
         if (ioc->scsih_cmds.status & MPT2_CMD_REPLY_VALID) {
                 mpi_reply = ioc->scsih_cmds.reply;
 
-                printk(MPT2SAS_INFO_FMT "IR shutdown (complete): "
-                    "ioc_status(0x%04x), loginfo(0x%08x)\n",
-                    ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
-                    le32_to_cpu(mpi_reply->IOCLogInfo));
+                if (!ioc->hide_ir_msg)
+                        printk(MPT2SAS_INFO_FMT "IR shutdown (complete): "
+                            "ioc_status(0x%04x), loginfo(0x%08x)\n",
+                            ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
+                            le32_to_cpu(mpi_reply->IOCLogInfo));
         }
 
  out:
@@ -6759,6 +7231,9 @@ _scsih_probe_boot_devices(struct MPT2SAS_ADAPTER *ioc)
                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
                 list_move_tail(&sas_device->list, &ioc->sas_device_list);
                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
+
+                if (ioc->hide_drives)
+                        return;
                 if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
                     sas_device->sas_address_parent)) {
                         _scsih_sas_device_remove(ioc, sas_device);
@@ -6812,6 +7287,9 @@ _scsih_probe_sas(struct MPT2SAS_ADAPTER *ioc)
                 list_move_tail(&sas_device->list, &ioc->sas_device_list);
                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 
+                if (ioc->hide_drives)
+                        continue;
+
                 if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
                     sas_device->sas_address_parent)) {
                         _scsih_sas_device_remove(ioc, sas_device);
@@ -6882,6 +7360,11 @@ _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         ioc->id = mpt_ids++;
         sprintf(ioc->name, "%s%d", MPT2SAS_DRIVER_NAME, ioc->id);
         ioc->pdev = pdev;
+        if (id->device == MPI2_MFGPAGE_DEVID_SSS6200) {
+                ioc->is_warpdrive = 1;
+                ioc->hide_ir_msg = 1;
+        } else
+                ioc->mfg_pg10_hide_flag = MFG_PAGE10_EXPOSE_ALL_DISKS;
         ioc->scsi_io_cb_idx = scsi_io_cb_idx;
         ioc->tm_cb_idx = tm_cb_idx;
         ioc->ctl_cb_idx = ctl_cb_idx;
@@ -6947,6 +7430,20 @@ _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         }
 
         ioc->wait_for_port_enable_to_complete = 0;
+        if (ioc->is_warpdrive) {
+                if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_EXPOSE_ALL_DISKS)
+                        ioc->hide_drives = 0;
+                else if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_HIDE_ALL_DISKS)
+                        ioc->hide_drives = 1;
+                else {
+                        if (_scsih_get_num_volumes(ioc))
+                                ioc->hide_drives = 1;
+                        else
+                                ioc->hide_drives = 0;
+                }
+        } else
+                ioc->hide_drives = 0;
+
         _scsih_probe_devices(ioc);
         return 0;
 
diff --git a/drivers/scsi/mvsas/Kconfig b/drivers/scsi/mvsas/Kconfig
index 6de7af27e507..c82b012aba37 100644
--- a/drivers/scsi/mvsas/Kconfig
+++ b/drivers/scsi/mvsas/Kconfig
@@ -3,6 +3,7 @@
 #
 # Copyright 2007 Red Hat, Inc.
 # Copyright 2008 Marvell. <kewei@marvell.com>
+# Copyright 2009-20011 Marvell. <yuxiangl@marvell.com>
 #
 # This file is licensed under GPLv2.
 #
diff --git a/drivers/scsi/mvsas/Makefile b/drivers/scsi/mvsas/Makefile
index ffbf759e46f1..87b231a5bd5e 100644
--- a/drivers/scsi/mvsas/Makefile
+++ b/drivers/scsi/mvsas/Makefile
@@ -3,6 +3,7 @@
 #
 # Copyright 2007 Red Hat, Inc.
 # Copyright 2008 Marvell. <kewei@marvell.com>
+# Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
 #
 # This file is licensed under GPLv2.
 #
diff --git a/drivers/scsi/mvsas/mv_64xx.c b/drivers/scsi/mvsas/mv_64xx.c
index afc7f6f3a13e..13c960481391 100644
--- a/drivers/scsi/mvsas/mv_64xx.c
+++ b/drivers/scsi/mvsas/mv_64xx.c
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
diff --git a/drivers/scsi/mvsas/mv_64xx.h b/drivers/scsi/mvsas/mv_64xx.h
index 42e947d9795e..545889bd9753 100644
--- a/drivers/scsi/mvsas/mv_64xx.h
+++ b/drivers/scsi/mvsas/mv_64xx.h
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
diff --git a/drivers/scsi/mvsas/mv_94xx.c b/drivers/scsi/mvsas/mv_94xx.c
index eed4c5c72013..78162c3c36e6 100644
--- a/drivers/scsi/mvsas/mv_94xx.c
+++ b/drivers/scsi/mvsas/mv_94xx.c
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
diff --git a/drivers/scsi/mvsas/mv_94xx.h b/drivers/scsi/mvsas/mv_94xx.h
index 23ed9b164669..8835befe2c0e 100644
--- a/drivers/scsi/mvsas/mv_94xx.h
+++ b/drivers/scsi/mvsas/mv_94xx.h
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
diff --git a/drivers/scsi/mvsas/mv_chips.h b/drivers/scsi/mvsas/mv_chips.h
index a67e1c4172f9..1753a6fc42d0 100644
--- a/drivers/scsi/mvsas/mv_chips.h
+++ b/drivers/scsi/mvsas/mv_chips.h
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
diff --git a/drivers/scsi/mvsas/mv_defs.h b/drivers/scsi/mvsas/mv_defs.h
index 1849da1f030d..bc00c940743c 100644
--- a/drivers/scsi/mvsas/mv_defs.h
+++ b/drivers/scsi/mvsas/mv_defs.h
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
@@ -34,6 +35,8 @@ enum chip_flavors {
         chip_6485,
         chip_9480,
         chip_9180,
+        chip_9445,
+        chip_9485,
         chip_1300,
         chip_1320
 };
diff --git a/drivers/scsi/mvsas/mv_init.c b/drivers/scsi/mvsas/mv_init.c
index 938d045e4180..90b636611cde 100644
--- a/drivers/scsi/mvsas/mv_init.c
+++ b/drivers/scsi/mvsas/mv_init.c
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
@@ -25,13 +26,24 @@
 
 #include "mv_sas.h"
 
+static int lldd_max_execute_num = 1;
+module_param_named(collector, lldd_max_execute_num, int, S_IRUGO);
+MODULE_PARM_DESC(collector, "\n"
+        "\tIf greater than one, tells the SAS Layer to run in Task Collector\n"
+        "\tMode.  If 1 or 0, tells the SAS Layer to run in Direct Mode.\n"
+        "\tThe mvsas SAS LLDD supports both modes.\n"
+        "\tDefault: 1 (Direct Mode).\n");
+
 static struct scsi_transport_template *mvs_stt;
+struct kmem_cache *mvs_task_list_cache;
 static const struct mvs_chip_info mvs_chips[] = {
         [chip_6320] =   { 1, 2, 0x400, 17, 16,  9, &mvs_64xx_dispatch, },
         [chip_6440] =   { 1, 4, 0x400, 17, 16,  9, &mvs_64xx_dispatch, },
         [chip_6485] =   { 1, 8, 0x800, 33, 32, 10, &mvs_64xx_dispatch, },
         [chip_9180] =   { 2, 4, 0x800, 17, 64,  9, &mvs_94xx_dispatch, },
         [chip_9480] =   { 2, 4, 0x800, 17, 64,  9, &mvs_94xx_dispatch, },
+        [chip_9445] =   { 1, 4, 0x800, 17, 64, 11, &mvs_94xx_dispatch, },
+        [chip_9485] =   { 2, 4, 0x800, 17, 64, 11, &mvs_94xx_dispatch, },
         [chip_1300] =   { 1, 4, 0x400, 17, 16,  9, &mvs_64xx_dispatch, },
         [chip_1320] =   { 2, 4, 0x800, 17, 64,  9, &mvs_94xx_dispatch, },
 };
@@ -107,7 +119,6 @@ static void __devinit mvs_phy_init(struct mvs_info *mvi, int phy_id)
 
 static void mvs_free(struct mvs_info *mvi)
 {
-        int i;
         struct mvs_wq *mwq;
         int slot_nr;
 
@@ -119,12 +130,8 @@ static void mvs_free(struct mvs_info *mvi)
         else
                 slot_nr = MVS_SLOTS;
 
-        for (i = 0; i < mvi->tags_num; i++) {
-                struct mvs_slot_info *slot = &mvi->slot_info[i];
-                if (slot->buf)
-                        dma_free_coherent(mvi->dev, MVS_SLOT_BUF_SZ,
-                                          slot->buf, slot->buf_dma);
-        }
+        if (mvi->dma_pool)
+                pci_pool_destroy(mvi->dma_pool);
 
         if (mvi->tx)
                 dma_free_coherent(mvi->dev,
@@ -213,6 +220,7 @@ static irqreturn_t mvs_interrupt(int irq, void *opaque)
 static int __devinit mvs_alloc(struct mvs_info *mvi, struct Scsi_Host *shost)
 {
         int i = 0, slot_nr;
+        char pool_name[32];
 
         if (mvi->flags & MVF_FLAG_SOC)
                 slot_nr = MVS_SOC_SLOTS;
@@ -272,18 +280,14 @@ static int __devinit mvs_alloc(struct mvs_info *mvi, struct Scsi_Host *shost)
         if (!mvi->bulk_buffer)
                 goto err_out;
 #endif
-        for (i = 0; i < slot_nr; i++) {
-                struct mvs_slot_info *slot = &mvi->slot_info[i];
-
-                slot->buf = dma_alloc_coherent(mvi->dev, MVS_SLOT_BUF_SZ,
-                                               &slot->buf_dma, GFP_KERNEL);
-                if (!slot->buf) {
-                        printk(KERN_DEBUG"failed to allocate slot->buf.\n");
+        sprintf(pool_name, "%s%d", "mvs_dma_pool", mvi->id);
+        mvi->dma_pool = pci_pool_create(pool_name, mvi->pdev, MVS_SLOT_BUF_SZ, 16, 0);
+        if (!mvi->dma_pool) {
+                        printk(KERN_DEBUG "failed to create dma pool %s.\n", pool_name);
                         goto err_out;
-                }
-                memset(slot->buf, 0, MVS_SLOT_BUF_SZ);
-                ++mvi->tags_num;
         }
+        mvi->tags_num = slot_nr;
+
         /* Initialize tags */
         mvs_tag_init(mvi);
         return 0;
@@ -484,7 +488,7 @@ static void  __devinit mvs_post_sas_ha_init(struct Scsi_Host *shost,
 
         sha->num_phys = nr_core * chip_info->n_phy;
 
-        sha->lldd_max_execute_num = 1;
+        sha->lldd_max_execute_num = lldd_max_execute_num;
 
         if (mvi->flags & MVF_FLAG_SOC)
                 can_queue = MVS_SOC_CAN_QUEUE;
@@ -670,6 +674,24 @@ static struct pci_device_id __devinitdata mvs_pci_table[] = {
         { PCI_VDEVICE(TTI, 0x2740), chip_9480 },
         { PCI_VDEVICE(TTI, 0x2744), chip_9480 },
         { PCI_VDEVICE(TTI, 0x2760), chip_9480 },
+        {
+                .vendor         = 0x1b4b,
+                .device         = 0x9445,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = 0x9480,
+                .class          = 0,
+                .class_mask     = 0,
+                .driver_data    = chip_9445,
+        },
+        {
+                .vendor         = 0x1b4b,
+                .device         = 0x9485,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = 0x9480,
+                .class          = 0,
+                .class_mask     = 0,
+                .driver_data    = chip_9485,
+        },
 
         { }     /* terminate list */
 };
@@ -690,6 +712,14 @@ static int __init mvs_init(void)
         if (!mvs_stt)
                 return -ENOMEM;
 
+        mvs_task_list_cache = kmem_cache_create("mvs_task_list", sizeof(struct mvs_task_list),
+                                                         0, SLAB_HWCACHE_ALIGN, NULL);
+        if (!mvs_task_list_cache) {
+                rc = -ENOMEM;
+                mv_printk("%s: mvs_task_list_cache alloc failed! \n", __func__);
+                goto err_out;
+        }
+
         rc = pci_register_driver(&mvs_pci_driver);
 
         if (rc)
@@ -706,6 +736,7 @@ static void __exit mvs_exit(void)
 {
         pci_unregister_driver(&mvs_pci_driver);
         sas_release_transport(mvs_stt);
+        kmem_cache_destroy(mvs_task_list_cache);
 }
 
 module_init(mvs_init);
diff --git a/drivers/scsi/mvsas/mv_sas.c b/drivers/scsi/mvsas/mv_sas.c
index adedaa916ecb..0ef27425c447 100644
--- a/drivers/scsi/mvsas/mv_sas.c
+++ b/drivers/scsi/mvsas/mv_sas.c
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
@@ -862,178 +863,286 @@ static int mvs_task_prep_ssp(struct mvs_info *mvi,
 }
 
 #define DEV_IS_GONE(mvi_dev)    ((!mvi_dev || (mvi_dev->dev_type == NO_DEVICE)))
-static int mvs_task_exec(struct sas_task *task, const int num, gfp_t gfp_flags,
-                                struct completion *completion,int is_tmf,
-                                struct mvs_tmf_task *tmf)
+static int mvs_task_prep(struct sas_task *task, struct mvs_info *mvi, int is_tmf,
+                                struct mvs_tmf_task *tmf, int *pass)
 {
         struct domain_device *dev = task->dev;
-        struct mvs_device *mvi_dev = (struct mvs_device *)dev->lldd_dev;
-        struct mvs_info *mvi = mvi_dev->mvi_info;
+        struct mvs_device *mvi_dev = dev->lldd_dev;
         struct mvs_task_exec_info tei;
-        struct sas_task *t = task;
         struct mvs_slot_info *slot;
-        u32 tag = 0xdeadbeef, rc, n_elem = 0;
-        u32 n = num, pass = 0;
-        unsigned long flags = 0,  flags_libsas = 0;
+        u32 tag = 0xdeadbeef, n_elem = 0;
+        int rc = 0;
 
         if (!dev->port) {
-                struct task_status_struct *tsm = &t->task_status;
+                struct task_status_struct *tsm = &task->task_status;
 
                 tsm->resp = SAS_TASK_UNDELIVERED;
                 tsm->stat = SAS_PHY_DOWN;
+                /*
+                 * libsas will use dev->port, should
+                 * not call task_done for sata
+                 */
                 if (dev->dev_type != SATA_DEV)
-                        t->task_done(t);
-                return 0;
+                        task->task_done(task);
+                return rc;
         }
 
-        spin_lock_irqsave(&mvi->lock, flags);
-        do {
-                dev = t->dev;
-                mvi_dev = dev->lldd_dev;
-                if (DEV_IS_GONE(mvi_dev)) {
-                        if (mvi_dev)
-                                mv_dprintk("device %d not ready.\n",
-                                        mvi_dev->device_id);
-                        else
-                                mv_dprintk("device %016llx not ready.\n",
-                                        SAS_ADDR(dev->sas_addr));
+        if (DEV_IS_GONE(mvi_dev)) {
+                if (mvi_dev)
+                        mv_dprintk("device %d not ready.\n",
+                                mvi_dev->device_id);
+                else
+                        mv_dprintk("device %016llx not ready.\n",
+                                SAS_ADDR(dev->sas_addr));
 
                         rc = SAS_PHY_DOWN;
-                        goto out_done;
-                }
+                        return rc;
+        }
+        tei.port = dev->port->lldd_port;
+        if (tei.port && !tei.port->port_attached && !tmf) {
+                if (sas_protocol_ata(task->task_proto)) {
+                        struct task_status_struct *ts = &task->task_status;
+                        mv_dprintk("SATA/STP port %d does not attach"
+                                        "device.\n", dev->port->id);
+                        ts->resp = SAS_TASK_COMPLETE;
+                        ts->stat = SAS_PHY_DOWN;
 
-                if (dev->port->id >= mvi->chip->n_phy)
-                        tei.port = &mvi->port[dev->port->id - mvi->chip->n_phy];
-                else
-                        tei.port = &mvi->port[dev->port->id];
-
-                if (tei.port && !tei.port->port_attached) {
-                        if (sas_protocol_ata(t->task_proto)) {
-                                struct task_status_struct *ts = &t->task_status;
-
-                                mv_dprintk("port %d does not"
-                                        "attached device.\n", dev->port->id);
-                                ts->stat = SAS_PROTO_RESPONSE;
-                                ts->stat = SAS_PHY_DOWN;
-                                spin_unlock_irqrestore(dev->sata_dev.ap->lock,
-                                                       flags_libsas);
-                                spin_unlock_irqrestore(&mvi->lock, flags);
-                                t->task_done(t);
-                                spin_lock_irqsave(&mvi->lock, flags);
-                                spin_lock_irqsave(dev->sata_dev.ap->lock,
-                                                  flags_libsas);
-                                if (n > 1)
-                                        t = list_entry(t->list.next,
-                                                       struct sas_task, list);
-                                continue;
-                        } else {
-                                struct task_status_struct *ts = &t->task_status;
-                                ts->resp = SAS_TASK_UNDELIVERED;
-                                ts->stat = SAS_PHY_DOWN;
-                                t->task_done(t);
-                                if (n > 1)
-                                        t = list_entry(t->list.next,
-                                                        struct sas_task, list);
-                                continue;
-                        }
-                }
+                        task->task_done(task);
 
-                if (!sas_protocol_ata(t->task_proto)) {
-                        if (t->num_scatter) {
-                                n_elem = dma_map_sg(mvi->dev,
-                                                    t->scatter,
-                                                    t->num_scatter,
-                                                    t->data_dir);
-                                if (!n_elem) {
-                                        rc = -ENOMEM;
-                                        goto err_out;
-                                }
-                        }
                 } else {
-                        n_elem = t->num_scatter;
+                        struct task_status_struct *ts = &task->task_status;
+                        mv_dprintk("SAS port %d does not attach"
+                                "device.\n", dev->port->id);
+                        ts->resp = SAS_TASK_UNDELIVERED;
+                        ts->stat = SAS_PHY_DOWN;
+                        task->task_done(task);
                 }
+                return rc;
+        }
 
-                rc = mvs_tag_alloc(mvi, &tag);
-                if (rc)
-                        goto err_out;
+        if (!sas_protocol_ata(task->task_proto)) {
+                if (task->num_scatter) {
+                        n_elem = dma_map_sg(mvi->dev,
+                                            task->scatter,
+                                            task->num_scatter,
+                                            task->data_dir);
+                        if (!n_elem) {
+                                rc = -ENOMEM;
+                                goto prep_out;
+                        }
+                }
+        } else {
+                n_elem = task->num_scatter;
+        }
 
-                slot = &mvi->slot_info[tag];
+        rc = mvs_tag_alloc(mvi, &tag);
+        if (rc)
+                goto err_out;
 
+        slot = &mvi->slot_info[tag];
 
-                t->lldd_task = NULL;
-                slot->n_elem = n_elem;
-                slot->slot_tag = tag;
-                memset(slot->buf, 0, MVS_SLOT_BUF_SZ);
+        task->lldd_task = NULL;
+        slot->n_elem = n_elem;
+        slot->slot_tag = tag;
+
+        slot->buf = pci_pool_alloc(mvi->dma_pool, GFP_ATOMIC, &slot->buf_dma);
+        if (!slot->buf)
+                goto err_out_tag;
+        memset(slot->buf, 0, MVS_SLOT_BUF_SZ);
+
+        tei.task = task;
+        tei.hdr = &mvi->slot[tag];
+        tei.tag = tag;
+        tei.n_elem = n_elem;
+        switch (task->task_proto) {
+        case SAS_PROTOCOL_SMP:
+                rc = mvs_task_prep_smp(mvi, &tei);
+                break;
+        case SAS_PROTOCOL_SSP:
+                rc = mvs_task_prep_ssp(mvi, &tei, is_tmf, tmf);
+                break;
+        case SAS_PROTOCOL_SATA:
+        case SAS_PROTOCOL_STP:
+        case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
+                rc = mvs_task_prep_ata(mvi, &tei);
+                break;
+        default:
+                dev_printk(KERN_ERR, mvi->dev,
+                        "unknown sas_task proto: 0x%x\n",
+                        task->task_proto);
+                rc = -EINVAL;
+                break;
+        }
 
-                tei.task = t;
-                tei.hdr = &mvi->slot[tag];
-                tei.tag = tag;
-                tei.n_elem = n_elem;
-                switch (t->task_proto) {
-                case SAS_PROTOCOL_SMP:
-                        rc = mvs_task_prep_smp(mvi, &tei);
-                        break;
-                case SAS_PROTOCOL_SSP:
-                        rc = mvs_task_prep_ssp(mvi, &tei, is_tmf, tmf);
-                        break;
-                case SAS_PROTOCOL_SATA:
-                case SAS_PROTOCOL_STP:
-                case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
-                        rc = mvs_task_prep_ata(mvi, &tei);
-                        break;
-                default:
-                        dev_printk(KERN_ERR, mvi->dev,
-                                   "unknown sas_task proto: 0x%x\n",
-                                   t->task_proto);
-                        rc = -EINVAL;
-                        break;
-                }
+        if (rc) {
+                mv_dprintk("rc is %x\n", rc);
+                goto err_out_slot_buf;
+        }
+        slot->task = task;
+        slot->port = tei.port;
+        task->lldd_task = slot;
+        list_add_tail(&slot->entry, &tei.port->list);
+        spin_lock(&task->task_state_lock);
+        task->task_state_flags |= SAS_TASK_AT_INITIATOR;
+        spin_unlock(&task->task_state_lock);
 
-                if (rc) {
-                        mv_dprintk("rc is %x\n", rc);
-                        goto err_out_tag;
-                }
-                slot->task = t;
-                slot->port = tei.port;
-                t->lldd_task = slot;
-                list_add_tail(&slot->entry, &tei.port->list);
-                /* TODO: select normal or high priority */
-                spin_lock(&t->task_state_lock);
-                t->task_state_flags |= SAS_TASK_AT_INITIATOR;
-                spin_unlock(&t->task_state_lock);
-
-                mvs_hba_memory_dump(mvi, tag, t->task_proto);
-                mvi_dev->running_req++;
-                ++pass;
-                mvi->tx_prod = (mvi->tx_prod + 1) & (MVS_CHIP_SLOT_SZ - 1);
-                if (n > 1)
-                        t = list_entry(t->list.next, struct sas_task, list);
-                if (likely(pass))
-                        MVS_CHIP_DISP->start_delivery(mvi, (mvi->tx_prod - 1) &
-                                                      (MVS_CHIP_SLOT_SZ - 1));
+        mvs_hba_memory_dump(mvi, tag, task->task_proto);
+        mvi_dev->running_req++;
+        ++(*pass);
+        mvi->tx_prod = (mvi->tx_prod + 1) & (MVS_CHIP_SLOT_SZ - 1);
 
-        } while (--n);
-        rc = 0;
-        goto out_done;
+        return rc;
 
+err_out_slot_buf:
+        pci_pool_free(mvi->dma_pool, slot->buf, slot->buf_dma);
 err_out_tag:
         mvs_tag_free(mvi, tag);
 err_out:
 
-        dev_printk(KERN_ERR, mvi->dev, "mvsas exec failed[%d]!\n", rc);
-        if (!sas_protocol_ata(t->task_proto))
+        dev_printk(KERN_ERR, mvi->dev, "mvsas prep failed[%d]!\n", rc);
+        if (!sas_protocol_ata(task->task_proto))
                 if (n_elem)
-                        dma_unmap_sg(mvi->dev, t->scatter, n_elem,
-                                     t->data_dir);
-out_done:
+                        dma_unmap_sg(mvi->dev, task->scatter, n_elem,
+                                     task->data_dir);
+prep_out:
+        return rc;
+}
+
+static struct mvs_task_list *mvs_task_alloc_list(int *num, gfp_t gfp_flags)
+{
+        struct mvs_task_list *first = NULL;
+
+        for (; *num > 0; --*num) {
+                struct mvs_task_list *mvs_list = kmem_cache_zalloc(mvs_task_list_cache, gfp_flags);
+
+                if (!mvs_list)
+                        break;
+
+                INIT_LIST_HEAD(&mvs_list->list);
+                if (!first)
+                        first = mvs_list;
+                else
+                        list_add_tail(&mvs_list->list, &first->list);
+
+        }
+
+        return first;
+}
+
+static inline void mvs_task_free_list(struct mvs_task_list *mvs_list)
+{
+        LIST_HEAD(list);
+        struct list_head *pos, *a;
+        struct mvs_task_list *mlist = NULL;
+
+        __list_add(&list, mvs_list->list.prev, &mvs_list->list);
+
+        list_for_each_safe(pos, a, &list) {
+                list_del_init(pos);
+                mlist = list_entry(pos, struct mvs_task_list, list);
+                kmem_cache_free(mvs_task_list_cache, mlist);
+        }
+}
+
+static int mvs_task_exec(struct sas_task *task, const int num, gfp_t gfp_flags,
+                                struct completion *completion, int is_tmf,
+                                struct mvs_tmf_task *tmf)
+{
+        struct domain_device *dev = task->dev;
+        struct mvs_info *mvi = NULL;
+        u32 rc = 0;
+        u32 pass = 0;
+        unsigned long flags = 0;
+
+        mvi = ((struct mvs_device *)task->dev->lldd_dev)->mvi_info;
+
+        if ((dev->dev_type == SATA_DEV) && (dev->sata_dev.ap != NULL))
+                spin_unlock_irq(dev->sata_dev.ap->lock);
+
+        spin_lock_irqsave(&mvi->lock, flags);
+        rc = mvs_task_prep(task, mvi, is_tmf, tmf, &pass);
+        if (rc)
+                dev_printk(KERN_ERR, mvi->dev, "mvsas exec failed[%d]!\n", rc);
+
+        if (likely(pass))
+                        MVS_CHIP_DISP->start_delivery(mvi, (mvi->tx_prod - 1) &
+                                (MVS_CHIP_SLOT_SZ - 1));
         spin_unlock_irqrestore(&mvi->lock, flags);
+
+        if ((dev->dev_type == SATA_DEV) && (dev->sata_dev.ap != NULL))
+                spin_lock_irq(dev->sata_dev.ap->lock);
+
+        return rc;
+}
+
+static int mvs_collector_task_exec(struct sas_task *task, const int num, gfp_t gfp_flags,
+                                struct completion *completion, int is_tmf,
+                                struct mvs_tmf_task *tmf)
+{
+        struct domain_device *dev = task->dev;
+        struct mvs_prv_info *mpi = dev->port->ha->lldd_ha;
+        struct mvs_info *mvi = NULL;
+        struct sas_task *t = task;
+        struct mvs_task_list *mvs_list = NULL, *a;
+        LIST_HEAD(q);
+        int pass[2] = {0};
+        u32 rc = 0;
+        u32 n = num;
+        unsigned long flags = 0;
+
+        mvs_list = mvs_task_alloc_list(&n, gfp_flags);
+        if (n) {
+                printk(KERN_ERR "%s: mvs alloc list failed.\n", __func__);
+                rc = -ENOMEM;
+                goto free_list;
+        }
+
+        __list_add(&q, mvs_list->list.prev, &mvs_list->list);
+
+        list_for_each_entry(a, &q, list) {
+                a->task = t;
+                t = list_entry(t->list.next, struct sas_task, list);
+        }
+
+        list_for_each_entry(a, &q , list) {
+
+                t = a->task;
+                mvi = ((struct mvs_device *)t->dev->lldd_dev)->mvi_info;
+
+                spin_lock_irqsave(&mvi->lock, flags);
+                rc = mvs_task_prep(t, mvi, is_tmf, tmf, &pass[mvi->id]);
+                if (rc)
+                        dev_printk(KERN_ERR, mvi->dev, "mvsas exec failed[%d]!\n", rc);
+                spin_unlock_irqrestore(&mvi->lock, flags);
+        }
+
+        if (likely(pass[0]))
+                        MVS_CHIP_DISP->start_delivery(mpi->mvi[0],
+                                (mpi->mvi[0]->tx_prod - 1) & (MVS_CHIP_SLOT_SZ - 1));
+
+        if (likely(pass[1]))
+                        MVS_CHIP_DISP->start_delivery(mpi->mvi[1],
+                                (mpi->mvi[1]->tx_prod - 1) & (MVS_CHIP_SLOT_SZ - 1));
+
+        list_del_init(&q);
+
+free_list:
+        if (mvs_list)
+                mvs_task_free_list(mvs_list);
+
         return rc;
 }
 
 int mvs_queue_command(struct sas_task *task, const int num,
                         gfp_t gfp_flags)
 {
-        return mvs_task_exec(task, num, gfp_flags, NULL, 0, NULL);
+        struct mvs_device *mvi_dev = task->dev->lldd_dev;
+        struct sas_ha_struct *sas = mvi_dev->mvi_info->sas;
+
+        if (sas->lldd_max_execute_num < 2)
+                return mvs_task_exec(task, num, gfp_flags, NULL, 0, NULL);
+        else
+                return mvs_collector_task_exec(task, num, gfp_flags, NULL, 0, NULL);
 }
 
 static void mvs_slot_free(struct mvs_info *mvi, u32 rx_desc)
@@ -1067,6 +1176,11 @@ static void mvs_slot_task_free(struct mvs_info *mvi, struct sas_task *task,
                 /* do nothing */
                 break;
         }
+
+        if (slot->buf) {
+                pci_pool_free(mvi->dma_pool, slot->buf, slot->buf_dma);
+                slot->buf = NULL;
+        }
         list_del_init(&slot->entry);
         task->lldd_task = NULL;
         slot->task = NULL;
@@ -1255,6 +1369,7 @@ static void mvs_port_notify_formed(struct asd_sas_phy *sas_phy, int lock)
                 spin_lock_irqsave(&mvi->lock, flags);
         port->port_attached = 1;
         phy->port = port;
+        sas_port->lldd_port = port;
         if (phy->phy_type & PORT_TYPE_SAS) {
                 port->wide_port_phymap = sas_port->phy_mask;
                 mv_printk("set wide port phy map %x\n", sas_port->phy_mask);
diff --git a/drivers/scsi/mvsas/mv_sas.h b/drivers/scsi/mvsas/mv_sas.h
index 77ddc7c1e5f2..1367d8b9350d 100644
--- a/drivers/scsi/mvsas/mv_sas.h
+++ b/drivers/scsi/mvsas/mv_sas.h
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
@@ -67,6 +68,7 @@ extern struct mvs_tgt_initiator mvs_tgt;
 extern struct mvs_info *tgt_mvi;
 extern const struct mvs_dispatch mvs_64xx_dispatch;
 extern const struct mvs_dispatch mvs_94xx_dispatch;
+extern struct kmem_cache *mvs_task_list_cache;
 
 #define DEV_IS_EXPANDER(type)   \
         ((type == EDGE_DEV) || (type == FANOUT_DEV))
@@ -341,6 +343,7 @@ struct mvs_info {
         dma_addr_t bulk_buffer_dma;
 #define TRASH_BUCKET_SIZE       0x20000
 #endif
+        void *dma_pool;
         struct mvs_slot_info slot_info[0];
 };
 
@@ -367,6 +370,11 @@ struct mvs_task_exec_info {
         int n_elem;
 };
 
+struct mvs_task_list {
+        struct sas_task *task;
+        struct list_head list;
+};
+
 
 /******************** function prototype *********************/
 void mvs_get_sas_addr(void *buf, u32 buflen);
diff --git a/drivers/scsi/ncr53c8xx.c b/drivers/scsi/ncr53c8xx.c
index 835d8d66e696..4b3b4755945c 100644
--- a/drivers/scsi/ncr53c8xx.c
+++ b/drivers/scsi/ncr53c8xx.c
@@ -8147,7 +8147,7 @@ static int ncr53c8xx_abort(struct scsi_cmnd *cmd)
         unsigned long flags;
         struct scsi_cmnd *done_list;
 
-        printk("ncr53c8xx_abort: command pid %lu\n", cmd->serial_number);
+        printk("ncr53c8xx_abort\n");
 
         NCR_LOCK_NCB(np, flags);
 
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index 8ba5744c267e..d838205ab169 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -4066,7 +4066,7 @@ __qla1280_print_scsi_cmd(struct scsi_cmnd *cmd)
            } */
         printk("  tag=%d, transfersize=0x%x \n",
                cmd->tag, cmd->transfersize);
-        printk("  Pid=%li, SP=0x%p\n", cmd->serial_number, CMD_SP(cmd));
+        printk("  SP=0x%p\n", CMD_SP(cmd));
         printk(" underflow size = 0x%x, direction=0x%x\n",
                cmd->underflow, cmd->sc_data_direction);
 }
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index d3e58d763b43..532313e0725e 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -496,8 +496,8 @@ do_read:
                         offset = 0;
                 }
 
-                rval = qla2x00_read_sfp(vha, ha->sfp_data_dma, addr, offset,
-                    SFP_BLOCK_SIZE);
+                rval = qla2x00_read_sfp(vha, ha->sfp_data_dma, ha->sfp_data,
+                    addr, offset, SFP_BLOCK_SIZE, 0);
                 if (rval != QLA_SUCCESS) {
                         qla_printk(KERN_WARNING, ha,
                             "Unable to read SFP data (%x/%x/%x).\n", rval,
@@ -628,12 +628,12 @@ qla2x00_sysfs_write_edc(struct file *filp, struct kobject *kobj,
 
         memcpy(ha->edc_data, &buf[8], len);
 
-        rval = qla2x00_write_edc(vha, dev, adr, ha->edc_data_dma,
-            ha->edc_data, len, opt);
+        rval = qla2x00_write_sfp(vha, ha->edc_data_dma, ha->edc_data,
+            dev, adr, len, opt);
         if (rval != QLA_SUCCESS) {
                 DEBUG2(qla_printk(KERN_INFO, ha,
                     "Unable to write EDC (%x) %02x:%02x:%04x:%02x:%02x.\n",
-                    rval, dev, adr, opt, len, *buf));
+                    rval, dev, adr, opt, len, buf[8]));
                 return 0;
         }
 
@@ -685,8 +685,8 @@ qla2x00_sysfs_write_edc_status(struct file *filp, struct kobject *kobj,
                         return -EINVAL;
 
         memset(ha->edc_data, 0, len);
-        rval = qla2x00_read_edc(vha, dev, adr, ha->edc_data_dma,
-            ha->edc_data, len, opt);
+        rval = qla2x00_read_sfp(vha, ha->edc_data_dma, ha->edc_data,
+                        dev, adr, len, opt);
         if (rval != QLA_SUCCESS) {
                 DEBUG2(qla_printk(KERN_INFO, ha,
                     "Unable to write EDC status (%x) %02x:%02x:%04x:%02x.\n",
@@ -1568,7 +1568,7 @@ qla2x00_dev_loss_tmo_callbk(struct fc_rport *rport)
 
         /* Now that the rport has been deleted, set the fcport state to
            FCS_DEVICE_DEAD */
-        atomic_set(&fcport->state, FCS_DEVICE_DEAD);
+        qla2x00_set_fcport_state(fcport, FCS_DEVICE_DEAD);
 
         /*
          * Transport has effectively 'deleted' the rport, clear
@@ -1877,14 +1877,15 @@ qla24xx_vport_delete(struct fc_vport *fc_vport)
 
         scsi_remove_host(vha->host);
 
+        /* Allow timer to run to drain queued items, when removing vp */
+        qla24xx_deallocate_vp_id(vha);
+
         if (vha->timer_active) {
                 qla2x00_vp_stop_timer(vha);
                 DEBUG15(printk(KERN_INFO "scsi(%ld): timer for the vport[%d]"
                 " = %p has stopped\n", vha->host_no, vha->vp_idx, vha));
         }
 
-        qla24xx_deallocate_vp_id(vha);
-
         /* No pending activities shall be there on the vha now */
         DEBUG(msleep(random32()%10));  /* Just to see if something falls on
                                         * the net we have placed below */
diff --git a/drivers/scsi/qla2xxx/qla_bsg.c b/drivers/scsi/qla2xxx/qla_bsg.c
index 903b0586ded3..8c10e2c4928e 100644
--- a/drivers/scsi/qla2xxx/qla_bsg.c
+++ b/drivers/scsi/qla2xxx/qla_bsg.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_bsg.h b/drivers/scsi/qla2xxx/qla_bsg.h
index 074a999c7017..0f0f54e35f06 100644
--- a/drivers/scsi/qla2xxx/qla_bsg.h
+++ b/drivers/scsi/qla2xxx/qla_bsg.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_dbg.c b/drivers/scsi/qla2xxx/qla_dbg.c
index 096141148257..c53719a9a747 100644
--- a/drivers/scsi/qla2xxx/qla_dbg.c
+++ b/drivers/scsi/qla2xxx/qla_dbg.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_dbg.h b/drivers/scsi/qla2xxx/qla_dbg.h
index b74e6b5743dc..930414541ec6 100644
--- a/drivers/scsi/qla2xxx/qla_dbg.h
+++ b/drivers/scsi/qla2xxx/qla_dbg.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index ee20353c8550..cc5a79259d33 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -1717,6 +1717,14 @@ typedef struct fc_port {
 #define FCS_DEVICE_LOST         3
 #define FCS_ONLINE              4
 
+static const char * const port_state_str[] = {
+        "Unknown",
+        "UNCONFIGURED",
+        "DEAD",
+        "LOST",
+        "ONLINE"
+};
+
 /*
  * FC port flags.
  */
diff --git a/drivers/scsi/qla2xxx/qla_dfs.c b/drivers/scsi/qla2xxx/qla_dfs.c
index 6271353e8c51..a5a4e1275bf2 100644
--- a/drivers/scsi/qla2xxx/qla_dfs.c
+++ b/drivers/scsi/qla2xxx/qla_dfs.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_fw.h b/drivers/scsi/qla2xxx/qla_fw.h
index f5ba09c8a663..691783abfb69 100644
--- a/drivers/scsi/qla2xxx/qla_fw.h
+++ b/drivers/scsi/qla2xxx/qla_fw.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -416,8 +416,7 @@ struct cmd_type_6 {
         uint8_t vp_index;
 
         uint32_t fcp_data_dseg_address[2];      /* Data segment address. */
-        uint16_t fcp_data_dseg_len;             /* Data segment length. */
-        uint16_t reserved_1;                    /* MUST be set to 0. */
+        uint32_t fcp_data_dseg_len;             /* Data segment length. */
 };
 
 #define COMMAND_TYPE_7  0x18            /* Command Type 7 entry */
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index d48326ee3f61..0b381224ae4b 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -39,6 +39,8 @@ extern int qla81xx_load_risc(scsi_qla_host_t *, uint32_t *);
 extern int qla2x00_perform_loop_resync(scsi_qla_host_t *);
 extern int qla2x00_loop_resync(scsi_qla_host_t *);
 
+extern int qla2x00_find_new_loop_id(scsi_qla_host_t *, fc_port_t *);
+
 extern int qla2x00_fabric_login(scsi_qla_host_t *, fc_port_t *, uint16_t *);
 extern int qla2x00_local_device_login(scsi_qla_host_t *, fc_port_t *);
 
@@ -100,6 +102,8 @@ extern int ql2xgffidenable;
 extern int ql2xenabledif;
 extern int ql2xenablehba_err_chk;
 extern int ql2xtargetreset;
+extern int ql2xdontresethba;
+extern unsigned int ql2xmaxlun;
 
 extern int qla2x00_loop_reset(scsi_qla_host_t *);
 extern void qla2x00_abort_all_cmds(scsi_qla_host_t *, int);
@@ -319,15 +323,12 @@ extern int
 qla2x00_disable_fce_trace(scsi_qla_host_t *, uint64_t *, uint64_t *);
 
 extern int
-qla2x00_read_sfp(scsi_qla_host_t *, dma_addr_t, uint16_t, uint16_t, uint16_t);
-
-extern int
-qla2x00_read_edc(scsi_qla_host_t *, uint16_t, uint16_t, dma_addr_t,
-    uint8_t *, uint16_t, uint16_t);
+qla2x00_read_sfp(scsi_qla_host_t *, dma_addr_t, uint8_t *,
+        uint16_t, uint16_t, uint16_t, uint16_t);
 
 extern int
-qla2x00_write_edc(scsi_qla_host_t *, uint16_t, uint16_t, dma_addr_t,
-    uint8_t *, uint16_t, uint16_t);
+qla2x00_write_sfp(scsi_qla_host_t *, dma_addr_t, uint8_t *,
+        uint16_t, uint16_t, uint16_t, uint16_t);
 
 extern int
 qla2x00_set_idma_speed(scsi_qla_host_t *, uint16_t, uint16_t, uint16_t *);
@@ -549,7 +550,6 @@ extern int qla82xx_wr_32(struct qla_hw_data *, ulong, u32);
 extern int qla82xx_rd_32(struct qla_hw_data *, ulong);
 extern int qla82xx_rdmem(struct qla_hw_data *, u64, void *, int);
 extern int qla82xx_wrmem(struct qla_hw_data *, u64, void *, int);
-extern void qla82xx_rom_unlock(struct qla_hw_data *);
 
 /* ISP 8021 IDC */
 extern void qla82xx_clear_drv_active(struct qla_hw_data *);
diff --git a/drivers/scsi/qla2xxx/qla_gs.c b/drivers/scsi/qla2xxx/qla_gs.c
index 74a91b6dfc68..8cd9066ad906 100644
--- a/drivers/scsi/qla2xxx/qla_gs.c
+++ b/drivers/scsi/qla2xxx/qla_gs.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 8575808dbae0..920b76bfbb93 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -35,8 +35,6 @@ static int qla2x00_fabric_dev_login(scsi_qla_host_t *, fc_port_t *,
 
 static int qla2x00_restart_isp(scsi_qla_host_t *);
 
-static int qla2x00_find_new_loop_id(scsi_qla_host_t *, fc_port_t *);
-
 static struct qla_chip_state_84xx *qla84xx_get_chip(struct scsi_qla_host *);
 static int qla84xx_init_chip(scsi_qla_host_t *);
 static int qla25xx_init_queues(struct qla_hw_data *);
@@ -385,8 +383,18 @@ qla2x00_async_login_done(struct scsi_qla_host *vha, fc_port_t *fcport,
 
         switch (data[0]) {
         case MBS_COMMAND_COMPLETE:
+                /*
+                 * Driver must validate login state - If PRLI not complete,
+                 * force a relogin attempt via implicit LOGO, PLOGI, and PRLI
+                 * requests.
+                 */
+                rval = qla2x00_get_port_database(vha, fcport, 0);
+                if (rval != QLA_SUCCESS) {
+                        qla2x00_post_async_logout_work(vha, fcport, NULL);
+                        qla2x00_post_async_login_work(vha, fcport, NULL);
+                        break;
+                }
                 if (fcport->flags & FCF_FCP2_DEVICE) {
-                        fcport->flags |= FCF_ASYNC_SENT;
                         qla2x00_post_async_adisc_work(vha, fcport, data);
                         break;
                 }
@@ -397,7 +405,7 @@ qla2x00_async_login_done(struct scsi_qla_host *vha, fc_port_t *fcport,
                 if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
                         set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
                 else
-                        qla2x00_mark_device_lost(vha, fcport, 1, 1);
+                        qla2x00_mark_device_lost(vha, fcport, 1, 0);
                 break;
         case MBS_PORT_ID_USED:
                 fcport->loop_id = data[1];
@@ -409,7 +417,7 @@ qla2x00_async_login_done(struct scsi_qla_host *vha, fc_port_t *fcport,
                 rval = qla2x00_find_new_loop_id(vha, fcport);
                 if (rval != QLA_SUCCESS) {
                         fcport->flags &= ~FCF_ASYNC_SENT;
-                        qla2x00_mark_device_lost(vha, fcport, 1, 1);
+                        qla2x00_mark_device_lost(vha, fcport, 1, 0);
                         break;
                 }
                 qla2x00_post_async_login_work(vha, fcport, NULL);
@@ -441,7 +449,7 @@ qla2x00_async_adisc_done(struct scsi_qla_host *vha, fc_port_t *fcport,
         if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
                 set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
         else
-                qla2x00_mark_device_lost(vha, fcport, 1, 1);
+                qla2x00_mark_device_lost(vha, fcport, 1, 0);
 
         return;
 }
@@ -2536,7 +2544,7 @@ qla2x00_alloc_fcport(scsi_qla_host_t *vha, gfp_t flags)
         fcport->vp_idx = vha->vp_idx;
         fcport->port_type = FCT_UNKNOWN;
         fcport->loop_id = FC_NO_LOOP_ID;
-        atomic_set(&fcport->state, FCS_UNCONFIGURED);
+        qla2x00_set_fcport_state(fcport, FCS_UNCONFIGURED);
         fcport->supported_classes = FC_COS_UNSPECIFIED;
 
         return fcport;
@@ -2722,7 +2730,7 @@ qla2x00_configure_local_loop(scsi_qla_host_t *vha)
                             "loop_id=0x%04x\n",
                             vha->host_no, fcport->loop_id));
 
-                        atomic_set(&fcport->state, FCS_DEVICE_LOST);
+                        qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
                 }
         }
 
@@ -2934,7 +2942,7 @@ qla2x00_update_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
         qla2x00_iidma_fcport(vha, fcport);
         qla24xx_update_fcport_fcp_prio(vha, fcport);
         qla2x00_reg_remote_port(vha, fcport);
-        atomic_set(&fcport->state, FCS_ONLINE);
+        qla2x00_set_fcport_state(fcport, FCS_ONLINE);
 }
 
 /*
@@ -3391,7 +3399,7 @@ qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
  * Context:
  *      Kernel context.
  */
-static int
+int
 qla2x00_find_new_loop_id(scsi_qla_host_t *vha, fc_port_t *dev)
 {
         int     rval;
@@ -5202,7 +5210,7 @@ qla81xx_nvram_config(scsi_qla_host_t *vha)
         }
 
         /* Reset Initialization control block */
-        memset(icb, 0, sizeof(struct init_cb_81xx));
+        memset(icb, 0, ha->init_cb_size);
 
         /* Copy 1st segment. */
         dptr1 = (uint8_t *)icb;
@@ -5427,6 +5435,13 @@ qla82xx_restart_isp(scsi_qla_host_t *vha)
                 ha->isp_abort_cnt = 0;
                 clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
 
+                /* Update the firmware version */
+                qla2x00_get_fw_version(vha, &ha->fw_major_version,
+                    &ha->fw_minor_version, &ha->fw_subminor_version,
+                    &ha->fw_attributes, &ha->fw_memory_size,
+                    ha->mpi_version, &ha->mpi_capabilities,
+                    ha->phy_version);
+
                 if (ha->fce) {
                         ha->flags.fce_enabled = 1;
                         memset(ha->fce, 0,
@@ -5508,26 +5523,26 @@ qla81xx_update_fw_options(scsi_qla_host_t *vha)
  *
  * Return:
  *      non-zero (if found)
- *      0 (if not found)
+ *      -1 (if not found)
  *
  * Context:
  *      Kernel context
  */
-uint8_t
+static int
 qla24xx_get_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
 {
         int i, entries;
         uint8_t pid_match, wwn_match;
-        uint8_t priority;
+        int priority;
         uint32_t pid1, pid2;
         uint64_t wwn1, wwn2;
         struct qla_fcp_prio_entry *pri_entry;
         struct qla_hw_data *ha = vha->hw;
 
         if (!ha->fcp_prio_cfg || !ha->flags.fcp_prio_enabled)
-                return 0;
+                return -1;
 
-        priority = 0;
+        priority = -1;
         entries = ha->fcp_prio_cfg->num_entries;
         pri_entry = &ha->fcp_prio_cfg->entry[0];
 
@@ -5610,7 +5625,7 @@ int
 qla24xx_update_fcport_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
 {
         int ret;
-        uint8_t priority;
+        int priority;
         uint16_t mb[5];
 
         if (fcport->port_type != FCT_TARGET ||
@@ -5618,6 +5633,9 @@ qla24xx_update_fcport_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
                 return QLA_FUNCTION_FAILED;
 
         priority = qla24xx_get_fcp_prio(vha, fcport);
+        if (priority < 0)
+                return QLA_FUNCTION_FAILED;
+
         ret = qla24xx_set_fcp_prio(vha, fcport->loop_id, priority, mb);
         if (ret == QLA_SUCCESS)
                 fcport->fcp_prio = priority;
diff --git a/drivers/scsi/qla2xxx/qla_inline.h b/drivers/scsi/qla2xxx/qla_inline.h
index 48f97a92e33d..4c8167e11f69 100644
--- a/drivers/scsi/qla2xxx/qla_inline.h
+++ b/drivers/scsi/qla2xxx/qla_inline.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -83,3 +83,22 @@ qla2x00_clean_dsd_pool(struct qla_hw_data *ha, srb_t *sp)
         }
         INIT_LIST_HEAD(&((struct crc_context *)sp->ctx)->dsd_list);
 }
+
+static inline void
+qla2x00_set_fcport_state(fc_port_t *fcport, int state)
+{
+        int old_state;
+
+        old_state = atomic_read(&fcport->state);
+        atomic_set(&fcport->state, state);
+
+        /* Don't print state transitions during initial allocation of fcport */
+        if (old_state && old_state != state) {
+                DEBUG(qla_printk(KERN_WARNING, fcport->vha->hw,
+                    "scsi(%ld): FCPort state transitioned from %s to %s - "
+                    "portid=%02x%02x%02x.\n", fcport->vha->host_no,
+                    port_state_str[old_state], port_state_str[state],
+                    fcport->d_id.b.domain, fcport->d_id.b.area,
+                    fcport->d_id.b.al_pa));
+        }
+}
diff --git a/drivers/scsi/qla2xxx/qla_iocb.c b/drivers/scsi/qla2xxx/qla_iocb.c
index d78d5896fc33..7bac3cd109d6 100644
--- a/drivers/scsi/qla2xxx/qla_iocb.c
+++ b/drivers/scsi/qla2xxx/qla_iocb.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index 712518d05128..9c0f0e3389eb 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -843,7 +843,10 @@ qla2x00_process_completed_request(struct scsi_qla_host *vha,
                 qla_printk(KERN_WARNING, ha,
                     "Invalid SCSI completion handle %d.\n", index);
 
-                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                if (IS_QLA82XX(ha))
+                        set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
+                else
+                        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                 return;
         }
 
@@ -861,7 +864,10 @@ qla2x00_process_completed_request(struct scsi_qla_host *vha,
                 qla_printk(KERN_WARNING, ha,
                     "Invalid ISP SCSI completion handle\n");
 
-                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                if (IS_QLA82XX(ha))
+                        set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
+                else
+                        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
         }
 }
 
@@ -878,7 +884,10 @@ qla2x00_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
         if (index >= MAX_OUTSTANDING_COMMANDS) {
                 qla_printk(KERN_WARNING, ha,
                     "%s: Invalid completion handle (%x).\n", func, index);
-                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                if (IS_QLA82XX(ha))
+                        set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
+                else
+                        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                 goto done;
         }
         sp = req->outstanding_cmds[index];
@@ -1564,7 +1573,10 @@ qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
                     "scsi(%ld): Invalid status handle (0x%x).\n", vha->host_no,
                     sts->handle);
 
-                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                if (IS_QLA82XX(ha))
+                        set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
+                else
+                        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                 qla2xxx_wake_dpc(vha);
                 return;
         }
@@ -1794,12 +1806,13 @@ out:
         if (logit)
                 DEBUG2(qla_printk(KERN_INFO, ha,
                     "scsi(%ld:%d:%d) FCP command status: 0x%x-0x%x (0x%x) "
-                    "oxid=0x%x cdb=%02x%02x%02x len=0x%x "
+                    "portid=%02x%02x%02x oxid=0x%x cdb=%02x%02x%02x len=0x%x "
                     "rsp_info=0x%x resid=0x%x fw_resid=0x%x\n", vha->host_no,
                     cp->device->id, cp->device->lun, comp_status, scsi_status,
-                    cp->result, ox_id, cp->cmnd[0],
-                    cp->cmnd[1], cp->cmnd[2], scsi_bufflen(cp), rsp_info_len,
-                    resid_len, fw_resid_len));
+                    cp->result, fcport->d_id.b.domain, fcport->d_id.b.area,
+                    fcport->d_id.b.al_pa, ox_id, cp->cmnd[0], cp->cmnd[1],
+                    cp->cmnd[2], scsi_bufflen(cp), rsp_info_len, resid_len,
+                    fw_resid_len));
 
         if (rsp->status_srb == NULL)
                 qla2x00_sp_compl(ha, sp);
@@ -1908,13 +1921,17 @@ qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
                 qla2x00_sp_compl(ha, sp);
 
         } else if (pkt->entry_type == COMMAND_A64_TYPE || pkt->entry_type ==
-            COMMAND_TYPE || pkt->entry_type == COMMAND_TYPE_7) {
+                COMMAND_TYPE || pkt->entry_type == COMMAND_TYPE_7
+                || pkt->entry_type == COMMAND_TYPE_6) {
                 DEBUG2(printk("scsi(%ld): Error entry - invalid handle\n",
-                    vha->host_no));
+                        vha->host_no));
                 qla_printk(KERN_WARNING, ha,
-                    "Error entry - invalid handle\n");
+                        "Error entry - invalid handle\n");
 
-                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                if (IS_QLA82XX(ha))
+                        set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
+                else
+                        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                 qla2xxx_wake_dpc(vha);
         }
 }
diff --git a/drivers/scsi/qla2xxx/qla_mbx.c b/drivers/scsi/qla2xxx/qla_mbx.c
index 34893397ac84..c26f0acdfecc 100644
--- a/drivers/scsi/qla2xxx/qla_mbx.c
+++ b/drivers/scsi/qla2xxx/qla_mbx.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -1261,11 +1261,12 @@ qla2x00_get_port_database(scsi_qla_host_t *vha, 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__, vha->host_no,
-                            pd24->current_login_state,
-                            pd24->last_login_state, fcport->loop_id));
+                        DEBUG2(qla_printk(KERN_WARNING, ha,
+                           "scsi(%ld): Unable to verify login-state (%x/%x) "
+                           " - portid=%02x%02x%02x.\n", vha->host_no,
+                           pd24->current_login_state, pd24->last_login_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;
                 }
@@ -1289,6 +1290,12 @@ qla2x00_get_port_database(scsi_qla_host_t *vha, 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) {
+                        DEBUG2(qla_printk(KERN_WARNING, ha,
+                           "scsi(%ld): Unable to verify login-state (%x/%x) "
+                           " - portid=%02x%02x%02x.\n", vha->host_no,
+                           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;
                 }
@@ -1883,7 +1890,8 @@ qla24xx_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
         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;
@@ -2362,7 +2370,7 @@ qla24xx_abort_command(srb_t *sp)
         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;
@@ -2779,44 +2787,6 @@ qla2x00_disable_fce_trace(scsi_qla_host_t *vha, uint64_t *wr, uint64_t *rd)
 }
 
 int
-qla2x00_read_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint16_t addr,
-    uint16_t off, uint16_t count)
-{
-        int rval;
-        mbx_cmd_t mc;
-        mbx_cmd_t *mcp = &mc;
-
-        if (!IS_FWI2_CAPABLE(vha->hw))
-                return QLA_FUNCTION_FAILED;
-
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
-
-        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->tov = MBX_TOV_SECONDS;
-        mcp->flags = 0;
-        rval = qla2x00_mailbox_command(vha, mcp);
-
-        if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
-        } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
-        }
-
-        return rval;
-}
-
-int
 qla2x00_get_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
         uint16_t *port_speed, uint16_t *mb)
 {
@@ -3581,15 +3551,22 @@ qla81xx_restart_mpi_firmware(scsi_qla_host_t *vha)
 }
 
 int
-qla2x00_read_edc(scsi_qla_host_t *vha, uint16_t dev, uint16_t adr,
-    dma_addr_t sfp_dma, uint8_t *sfp, uint16_t len, uint16_t opt)
+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;
+
+        if (!IS_FWI2_CAPABLE(ha))
+                return QLA_FUNCTION_FAILED;
 
         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
 
+        if (len == 1)
+                opt |= BIT_0;
+
         mcp->mb[0] = MBC_READ_SFP;
         mcp->mb[1] = dev;
         mcp->mb[2] = MSW(sfp_dma);
@@ -3597,17 +3574,16 @@ qla2x00_read_edc(scsi_qla_host_t *vha, uint16_t dev, uint16_t adr,
         mcp->mb[6] = MSW(MSD(sfp_dma));
         mcp->mb[7] = LSW(MSD(sfp_dma));
         mcp->mb[8] = len;
-        mcp->mb[9] = adr;
+        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_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)
-                if (sfp)
-                        *sfp = mcp->mb[8];
+                *sfp = mcp->mb[1];
 
         if (rval != QLA_SUCCESS) {
                 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
@@ -3620,18 +3596,24 @@ qla2x00_read_edc(scsi_qla_host_t *vha, uint16_t dev, uint16_t adr,
 }
 
 int
-qla2x00_write_edc(scsi_qla_host_t *vha, uint16_t dev, uint16_t adr,
-    dma_addr_t sfp_dma, uint8_t *sfp, uint16_t len, uint16_t opt)
+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;
+
+        if (!IS_FWI2_CAPABLE(ha))
+                return QLA_FUNCTION_FAILED;
 
         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
 
+        if (len == 1)
+                opt |= BIT_0;
+
         if (opt & BIT_0)
-                if (sfp)
-                        len = *sfp;
+                len = *sfp;
 
         mcp->mb[0] = MBC_WRITE_SFP;
         mcp->mb[1] = dev;
@@ -3640,10 +3622,10 @@ qla2x00_write_edc(scsi_qla_host_t *vha, uint16_t dev, uint16_t adr,
         mcp->mb[6] = MSW(MSD(sfp_dma));
         mcp->mb[7] = LSW(MSD(sfp_dma));
         mcp->mb[8] = len;
-        mcp->mb[9] = adr;
+        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_0;
+        mcp->in_mb = MBX_1|MBX_0;
         mcp->tov = MBX_TOV_SECONDS;
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
@@ -4160,63 +4142,32 @@ int
 qla2x00_get_thermal_temp(scsi_qla_host_t *vha, uint16_t *temp, uint16_t *frac)
 {
         int rval;
-        mbx_cmd_t mc;
-        mbx_cmd_t *mcp = &mc;
+        uint8_t byte;
         struct qla_hw_data *ha = vha->hw;
 
-        DEBUG11(printk(KERN_INFO "%s(%ld): entered.\n", __func__, ha->host_no));
+        DEBUG11(printk(KERN_INFO "%s(%ld): entered.\n", __func__, vha->host_no));
 
-        /* High bits. */
-        mcp->mb[0] = MBC_READ_SFP;
-        mcp->mb[1] = 0x98;
-        mcp->mb[2] = 0;
-        mcp->mb[3] = 0;
-        mcp->mb[6] = 0;
-        mcp->mb[7] = 0;
-        mcp->mb[8] = 1;
-        mcp->mb[9] = 0x01;
-        mcp->mb[10] = BIT_13|BIT_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_1|MBX_0;
-        mcp->tov = MBX_TOV_SECONDS;
-        mcp->flags = 0;
-        rval = qla2x00_mailbox_command(vha, mcp);
+        /* Integer part */
+        rval = qla2x00_read_sfp(vha, 0, &byte, 0x98, 0x01, 1, BIT_13|BIT_0);
         if (rval != QLA_SUCCESS) {
                 DEBUG2_3_11(printk(KERN_WARNING
-                    "%s(%ld): failed=%x (%x).\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
+                    "%s(%ld): failed=%x.\n", __func__, vha->host_no, rval));
                 ha->flags.thermal_supported = 0;
                 goto fail;
         }
-        *temp = mcp->mb[1] & 0xFF;
+        *temp = byte;
 
-        /* Low bits. */
-        mcp->mb[0] = MBC_READ_SFP;
-        mcp->mb[1] = 0x98;
-        mcp->mb[2] = 0;
-        mcp->mb[3] = 0;
-        mcp->mb[6] = 0;
-        mcp->mb[7] = 0;
-        mcp->mb[8] = 1;
-        mcp->mb[9] = 0x10;
-        mcp->mb[10] = BIT_13|BIT_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_1|MBX_0;
-        mcp->tov = MBX_TOV_SECONDS;
-        mcp->flags = 0;
-        rval = qla2x00_mailbox_command(vha, mcp);
+        /* Fraction part */
+        rval = qla2x00_read_sfp(vha, 0, &byte, 0x98, 0x10, 1, BIT_13|BIT_0);
         if (rval != QLA_SUCCESS) {
                 DEBUG2_3_11(printk(KERN_WARNING
-                    "%s(%ld): failed=%x (%x).\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
+                    "%s(%ld): failed=%x.\n", __func__, vha->host_no, rval));
                 ha->flags.thermal_supported = 0;
                 goto fail;
         }
-        *frac = ((mcp->mb[1] & 0xFF) >> 6) * 25;
+        *frac = (byte >> 6) * 25;
 
-        if (rval == QLA_SUCCESS)
-                DEBUG11(printk(KERN_INFO
-                    "%s(%ld): done.\n", __func__, ha->host_no));
+        DEBUG11(printk(KERN_INFO "%s(%ld): done.\n", __func__, vha->host_no));
 fail:
         return rval;
 }
diff --git a/drivers/scsi/qla2xxx/qla_mid.c b/drivers/scsi/qla2xxx/qla_mid.c
index 2b69392a71a1..5e343919acad 100644
--- a/drivers/scsi/qla2xxx/qla_mid.c
+++ b/drivers/scsi/qla2xxx/qla_mid.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -136,7 +136,7 @@ qla2x00_mark_vp_devices_dead(scsi_qla_host_t *vha)
                     vha->host_no, fcport->loop_id, fcport->vp_idx));
 
                 qla2x00_mark_device_lost(vha, fcport, 0, 0);
-                atomic_set(&fcport->state, FCS_UNCONFIGURED);
+                qla2x00_set_fcport_state(fcport, FCS_UNCONFIGURED);
         }
 }
 
@@ -456,7 +456,7 @@ qla24xx_create_vhost(struct fc_vport *fc_vport)
         else
                 host->max_cmd_len = MAX_CMDSZ;
         host->max_channel = MAX_BUSES - 1;
-        host->max_lun = MAX_LUNS;
+        host->max_lun = ql2xmaxlun;
         host->unique_id = host->host_no;
         host->max_id = MAX_TARGETS_2200;
         host->transportt = qla2xxx_transport_vport_template;
diff --git a/drivers/scsi/qla2xxx/qla_nx.c b/drivers/scsi/qla2xxx/qla_nx.c
index 455fe134d31d..e1138bcc834c 100644
--- a/drivers/scsi/qla2xxx/qla_nx.c
+++ b/drivers/scsi/qla2xxx/qla_nx.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -844,6 +844,12 @@ qla82xx_rom_lock(struct qla_hw_data *ha)
         return 0;
 }
 
+static void
+qla82xx_rom_unlock(struct qla_hw_data *ha)
+{
+        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+}
+
 static int
 qla82xx_wait_rom_busy(struct qla_hw_data *ha)
 {
@@ -924,7 +930,7 @@ qla82xx_rom_fast_read(struct qla_hw_data *ha, int addr, int *valp)
                 return -1;
         }
         ret = qla82xx_do_rom_fast_read(ha, addr, valp);
-        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+        qla82xx_rom_unlock(ha);
         return ret;
 }
 
@@ -1056,7 +1062,7 @@ qla82xx_write_flash_dword(struct qla_hw_data *ha, uint32_t flashaddr,
         ret = qla82xx_flash_wait_write_finish(ha);
 
 done_write:
-        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+        qla82xx_rom_unlock(ha);
         return ret;
 }
 
@@ -1081,12 +1087,26 @@ qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
         /* Halt all the indiviual PEGs and other blocks of the ISP */
         qla82xx_rom_lock(ha);
 
-        /* mask all niu interrupts */
+        /* disable all I2Q */
+        qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x10, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x14, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x18, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x1c, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x20, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x24, 0x0);
+
+        /* disable all niu interrupts */
         qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x40, 0xff);
         /* disable xge rx/tx */
         qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x70000, 0x00);
         /* disable xg1 rx/tx */
         qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x80000, 0x00);
+        /* disable sideband mac */
+        qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x90000, 0x00);
+        /* disable ap0 mac */
+        qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0xa0000, 0x00);
+        /* disable ap1 mac */
+        qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0xb0000, 0x00);
 
         /* halt sre */
         val = qla82xx_rd_32(ha, QLA82XX_CRB_SRE + 0x1000);
@@ -1101,6 +1121,7 @@ qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
         qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x10, 0x0);
         qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x18, 0x0);
         qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x100, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x200, 0x0);
 
         /* halt pegs */
         qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_0 + 0x3c, 1);
@@ -1108,9 +1129,9 @@ qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
         qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_2 + 0x3c, 1);
         qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_3 + 0x3c, 1);
         qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_4 + 0x3c, 1);
+        msleep(20);
 
         /* big hammer */
-        msleep(1000);
         if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))
                 /* don't reset CAM block on reset */
                 qla82xx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, 0xfeffffff);
@@ -1129,7 +1150,7 @@ qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
         qla82xx_wr_32(ha, QLA82XX_CRB_QDR_NET + 0xe4, val);
         msleep(20);
 
-        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+        qla82xx_rom_unlock(ha);
 
         /* Read the signature value from the flash.
          * Offset 0: Contain signature (0xcafecafe)
@@ -2395,9 +2416,13 @@ qla82xx_load_fw(scsi_qla_host_t *vha)
 
         if (qla82xx_fw_load_from_flash(ha) == QLA_SUCCESS) {
                 qla_printk(KERN_ERR, ha,
-                        "Firmware loaded successfully from flash\n");
+                    "Firmware loaded successfully from flash\n");
                 return QLA_SUCCESS;
+        } else {
+                qla_printk(KERN_ERR, ha,
+                    "Firmware load from flash failed\n");
         }
+
 try_blob_fw:
         qla_printk(KERN_INFO, ha,
             "Attempting to load firmware from blob\n");
@@ -2548,11 +2573,11 @@ qla2xx_build_scsi_type_6_iocbs(srb_t *sp, struct cmd_type_6 *cmd_pkt,
                         dsd_seg = (uint32_t *)&cmd_pkt->fcp_data_dseg_address;
                         *dsd_seg++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma));
                         *dsd_seg++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma));
-                        cmd_pkt->fcp_data_dseg_len = dsd_list_len;
+                        *dsd_seg++ = cpu_to_le32(dsd_list_len);
                 } else {
                         *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma));
                         *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma));
-                        *cur_dsd++ = dsd_list_len;
+                        *cur_dsd++ = cpu_to_le32(dsd_list_len);
                 }
                 cur_dsd = (uint32_t *)next_dsd;
                 while (avail_dsds) {
@@ -2991,7 +3016,7 @@ qla82xx_unprotect_flash(struct qla_hw_data *ha)
                 qla_printk(KERN_WARNING, ha, "Write disable failed\n");
 
 done_unprotect:
-        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+        qla82xx_rom_unlock(ha);
         return ret;
 }
 
@@ -3020,7 +3045,7 @@ qla82xx_protect_flash(struct qla_hw_data *ha)
         if (qla82xx_write_disable_flash(ha) != 0)
                 qla_printk(KERN_WARNING, ha, "Write disable failed\n");
 done_protect:
-        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+        qla82xx_rom_unlock(ha);
         return ret;
 }
 
@@ -3048,7 +3073,7 @@ qla82xx_erase_sector(struct qla_hw_data *ha, int addr)
         }
         ret = qla82xx_flash_wait_write_finish(ha);
 done:
-        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+        qla82xx_rom_unlock(ha);
         return ret;
 }
 
@@ -3228,7 +3253,7 @@ void qla82xx_rom_lock_recovery(struct qla_hw_data *ha)
          * else died while holding it.
          * In either case, unlock.
          */
-        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+        qla82xx_rom_unlock(ha);
 }
 
 /*
@@ -3528,15 +3553,18 @@ int
 qla82xx_device_state_handler(scsi_qla_host_t *vha)
 {
         uint32_t dev_state;
+        uint32_t old_dev_state;
         int rval = QLA_SUCCESS;
         unsigned long dev_init_timeout;
         struct qla_hw_data *ha = vha->hw;
+        int loopcount = 0;
 
         qla82xx_idc_lock(ha);
         if (!vha->flags.init_done)
                 qla82xx_set_drv_active(vha);
 
         dev_state = qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE);
+        old_dev_state = dev_state;
         qla_printk(KERN_INFO, ha, "1:Device state is 0x%x = %s\n", dev_state,
                 dev_state < MAX_STATES ? qdev_state[dev_state] : "Unknown");
 
@@ -3553,10 +3581,16 @@ qla82xx_device_state_handler(scsi_qla_host_t *vha)
                         break;
                 }
                 dev_state = qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE);
-                qla_printk(KERN_INFO, ha,
-                        "2:Device state is 0x%x = %s\n", dev_state,
-                        dev_state < MAX_STATES ?
-                        qdev_state[dev_state] : "Unknown");
+                if (old_dev_state != dev_state) {
+                        loopcount = 0;
+                        old_dev_state = dev_state;
+                }
+                if (loopcount < 5) {
+                        qla_printk(KERN_INFO, ha,
+                            "2:Device state is 0x%x = %s\n", dev_state,
+                            dev_state < MAX_STATES ?
+                            qdev_state[dev_state] : "Unknown");
+                }
 
                 switch (dev_state) {
                 case QLA82XX_DEV_READY:
@@ -3570,6 +3604,7 @@ qla82xx_device_state_handler(scsi_qla_host_t *vha)
                         qla82xx_idc_lock(ha);
                         break;
                 case QLA82XX_DEV_NEED_RESET:
+                    if (!ql2xdontresethba)
                         qla82xx_need_reset_handler(vha);
                         dev_init_timeout = jiffies +
                                 (ha->nx_dev_init_timeout * HZ);
@@ -3604,6 +3639,7 @@ qla82xx_device_state_handler(scsi_qla_host_t *vha)
                         msleep(1000);
                         qla82xx_idc_lock(ha);
                 }
+                loopcount++;
         }
 exit:
         qla82xx_idc_unlock(ha);
@@ -3621,7 +3657,8 @@ void qla82xx_watchdog(scsi_qla_host_t *vha)
                 if (dev_state == QLA82XX_DEV_NEED_RESET &&
                     !test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags)) {
                         qla_printk(KERN_WARNING, ha,
-                            "%s(): Adapter reset needed!\n", __func__);
+                            "scsi(%ld) %s: Adapter reset needed!\n",
+                                vha->host_no, __func__);
                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                         qla2xxx_wake_dpc(vha);
                 } else if (dev_state == QLA82XX_DEV_NEED_QUIESCENT &&
@@ -3632,10 +3669,27 @@ void qla82xx_watchdog(scsi_qla_host_t *vha)
                         set_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags);
                         qla2xxx_wake_dpc(vha);
                 } else {
-                        qla82xx_check_fw_alive(vha);
                         if (qla82xx_check_fw_alive(vha)) {
                                 halt_status = qla82xx_rd_32(ha,
                                     QLA82XX_PEG_HALT_STATUS1);
+                                qla_printk(KERN_INFO, ha,
+                                    "scsi(%ld): %s, Dumping hw/fw registers:\n "
+                                    " PEG_HALT_STATUS1: 0x%x, PEG_HALT_STATUS2: 0x%x,\n "
+                                    " PEG_NET_0_PC: 0x%x, PEG_NET_1_PC: 0x%x,\n "
+                                    " PEG_NET_2_PC: 0x%x, PEG_NET_3_PC: 0x%x,\n "
+                                    " PEG_NET_4_PC: 0x%x\n",
+                                    vha->host_no, __func__, halt_status,
+                                    qla82xx_rd_32(ha, QLA82XX_PEG_HALT_STATUS2),
+                                    qla82xx_rd_32(ha,
+                                            QLA82XX_CRB_PEG_NET_0 + 0x3c),
+                                    qla82xx_rd_32(ha,
+                                            QLA82XX_CRB_PEG_NET_1 + 0x3c),
+                                    qla82xx_rd_32(ha,
+                                            QLA82XX_CRB_PEG_NET_2 + 0x3c),
+                                    qla82xx_rd_32(ha,
+                                            QLA82XX_CRB_PEG_NET_3 + 0x3c),
+                                    qla82xx_rd_32(ha,
+                                            QLA82XX_CRB_PEG_NET_4 + 0x3c));
                                 if (halt_status & HALT_STATUS_UNRECOVERABLE) {
                                         set_bit(ISP_UNRECOVERABLE,
                                             &vha->dpc_flags);
@@ -3651,8 +3705,9 @@ void qla82xx_watchdog(scsi_qla_host_t *vha)
                                 if (ha->flags.mbox_busy) {
                                         ha->flags.mbox_int = 1;
                                         DEBUG2(qla_printk(KERN_ERR, ha,
-                                            "Due to fw hung, doing premature "
-                                            "completion of mbx command\n"));
+                                            "scsi(%ld) Due to fw hung, doing "
+                                            "premature completion of mbx "
+                                            "command\n", vha->host_no));
                                         if (test_bit(MBX_INTR_WAIT,
                                             &ha->mbx_cmd_flags))
                                                 complete(&ha->mbx_intr_comp);
diff --git a/drivers/scsi/qla2xxx/qla_nx.h b/drivers/scsi/qla2xxx/qla_nx.h
index ed5883f1778a..8a21832c6693 100644
--- a/drivers/scsi/qla2xxx/qla_nx.h
+++ b/drivers/scsi/qla2xxx/qla_nx.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index aa7747529165..f461925a9dfc 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -164,6 +164,20 @@ module_param(ql2xasynctmfenable, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xasynctmfenable,
                 "Enables issue of TM IOCBs asynchronously via IOCB mechanism"
                 "Default is 0 - Issue TM IOCBs via mailbox mechanism.");
+
+int ql2xdontresethba;
+module_param(ql2xdontresethba, int, S_IRUGO);
+MODULE_PARM_DESC(ql2xdontresethba,
+        "Option to specify reset behaviour\n"
+        " 0 (Default) -- Reset on failure.\n"
+        " 1 -- Do not reset on failure.\n");
+
+uint ql2xmaxlun = MAX_LUNS;
+module_param(ql2xmaxlun, uint, S_IRUGO);
+MODULE_PARM_DESC(ql2xmaxlun,
+                "Defines the maximum LU number to register with the SCSI "
+                "midlayer. Default is 65535.");
+
 /*
  * SCSI host template entry points
  */
@@ -528,7 +542,7 @@ qla2x00_get_new_sp(scsi_qla_host_t *vha, fc_port_t *fcport,
 static int
 qla2xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 {
-        scsi_qla_host_t *vha = shost_priv(cmd->device->host);
+        scsi_qla_host_t *vha = shost_priv(host);
         fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
         struct fc_rport *rport = starget_to_rport(scsi_target(cmd->device));
         struct qla_hw_data *ha = vha->hw;
@@ -2128,7 +2142,7 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         else
                 host->max_cmd_len = MAX_CMDSZ;
         host->max_channel = MAX_BUSES - 1;
-        host->max_lun = MAX_LUNS;
+        host->max_lun = ql2xmaxlun;
         host->transportt = qla2xxx_transport_template;
         sht->vendor_id = (SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_QLOGIC);
 
@@ -2360,21 +2374,26 @@ qla2x00_remove_one(struct pci_dev *pdev)
         base_vha = pci_get_drvdata(pdev);
         ha = base_vha->hw;
 
-        spin_lock_irqsave(&ha->vport_slock, flags);
-        list_for_each_entry(vha, &ha->vp_list, list) {
-                atomic_inc(&vha->vref_count);
+        mutex_lock(&ha->vport_lock);
+        while (ha->cur_vport_count) {
+                struct Scsi_Host *scsi_host;
 
-                if (vha->fc_vport) {
-                        spin_unlock_irqrestore(&ha->vport_slock, flags);
+                spin_lock_irqsave(&ha->vport_slock, flags);
 
-                        fc_vport_terminate(vha->fc_vport);
+                BUG_ON(base_vha->list.next == &ha->vp_list);
+                /* This assumes first entry in ha->vp_list is always base vha */
+                vha = list_first_entry(&base_vha->list, scsi_qla_host_t, list);
+                scsi_host = scsi_host_get(vha->host);
 
-                        spin_lock_irqsave(&ha->vport_slock, flags);
-                }
+                spin_unlock_irqrestore(&ha->vport_slock, flags);
+                mutex_unlock(&ha->vport_lock);
+
+                fc_vport_terminate(vha->fc_vport);
+                scsi_host_put(vha->host);
 
-                atomic_dec(&vha->vref_count);
+                mutex_lock(&ha->vport_lock);
         }
-        spin_unlock_irqrestore(&ha->vport_slock, flags);
+        mutex_unlock(&ha->vport_lock);
 
         set_bit(UNLOADING, &base_vha->dpc_flags);
 
@@ -2544,7 +2563,7 @@ void qla2x00_mark_device_lost(scsi_qla_host_t *vha, fc_port_t *fcport,
 {
         if (atomic_read(&fcport->state) == FCS_ONLINE &&
             vha->vp_idx == fcport->vp_idx) {
-                atomic_set(&fcport->state, FCS_DEVICE_LOST);
+                qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
                 qla2x00_schedule_rport_del(vha, fcport, defer);
         }
         /*
@@ -2552,7 +2571,7 @@ void qla2x00_mark_device_lost(scsi_qla_host_t *vha, fc_port_t *fcport,
          * port but do the retries.
          */
         if (atomic_read(&fcport->state) != FCS_DEVICE_DEAD)
-                atomic_set(&fcport->state, FCS_DEVICE_LOST);
+                qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
 
         if (!do_login)
                 return;
@@ -2607,7 +2626,7 @@ qla2x00_mark_all_devices_lost(scsi_qla_host_t *vha, int defer)
                 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD)
                         continue;
                 if (atomic_read(&fcport->state) == FCS_ONLINE) {
-                        atomic_set(&fcport->state, FCS_DEVICE_LOST);
+                        qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
                         if (defer)
                                 qla2x00_schedule_rport_del(vha, fcport, defer);
                         else if (vha->vp_idx == fcport->vp_idx)
@@ -3214,6 +3233,17 @@ void qla2x00_relogin(struct scsi_qla_host *vha)
                                                         fcport->d_id.b.area,
                                                         fcport->d_id.b.al_pa);
 
+                                if (fcport->loop_id == FC_NO_LOOP_ID) {
+                                        fcport->loop_id = next_loopid =
+                                            ha->min_external_loopid;
+                                        status = qla2x00_find_new_loop_id(
+                                            vha, fcport);
+                                        if (status != QLA_SUCCESS) {
+                                                /* Ran out of IDs to use */
+                                                break;
+                                        }
+                                }
+
                                 if (IS_ALOGIO_CAPABLE(ha)) {
                                         fcport->flags |= FCF_ASYNC_SENT;
                                         data[0] = 0;
@@ -3604,7 +3634,8 @@ qla2x00_timer(scsi_qla_host_t *vha)
         if (!pci_channel_offline(ha->pdev))
                 pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w);
 
-        if (IS_QLA82XX(ha)) {
+        /* Make sure qla82xx_watchdog is run only for physical port */
+        if (!vha->vp_idx && IS_QLA82XX(ha)) {
                 if (test_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags))
                         start_dpc++;
                 qla82xx_watchdog(vha);
@@ -3612,7 +3643,8 @@ qla2x00_timer(scsi_qla_host_t *vha)
 
         /* Loop down handler. */
         if (atomic_read(&vha->loop_down_timer) > 0 &&
-            !(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))
+            !(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) &&
+            !(test_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags))
                 && vha->flags.online) {
 
                 if (atomic_read(&vha->loop_down_timer) ==
@@ -3648,7 +3680,11 @@ qla2x00_timer(scsi_qla_host_t *vha)
                                         if (!(sfcp->flags & FCF_FCP2_DEVICE))
                                                 continue;
 
-                                        set_bit(ISP_ABORT_NEEDED,
+                                        if (IS_QLA82XX(ha))
+                                                set_bit(FCOE_CTX_RESET_NEEDED,
+                                                        &vha->dpc_flags);
+                                        else
+                                                set_bit(ISP_ABORT_NEEDED,
                                                         &vha->dpc_flags);
                                         break;
                                 }
@@ -3667,7 +3703,12 @@ qla2x00_timer(scsi_qla_host_t *vha)
                                 qla_printk(KERN_WARNING, ha,
                                     "Loop down - aborting ISP.\n");
 
-                                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                                if (IS_QLA82XX(ha))
+                                        set_bit(FCOE_CTX_RESET_NEEDED,
+                                                &vha->dpc_flags);
+                                else
+                                        set_bit(ISP_ABORT_NEEDED,
+                                                &vha->dpc_flags);
                         }
                 }
                 DEBUG3(printk("scsi(%ld): Loop Down - seconds remaining %d\n",
@@ -3675,8 +3716,8 @@ qla2x00_timer(scsi_qla_host_t *vha)
                     atomic_read(&vha->loop_down_timer)));
         }
 
-        /* Check if beacon LED needs to be blinked */
-        if (ha->beacon_blink_led == 1) {
+        /* Check if beacon LED needs to be blinked for physical host only */
+        if (!vha->vp_idx && (ha->beacon_blink_led == 1)) {
                 set_bit(BEACON_BLINK_NEEDED, &vha->dpc_flags);
                 start_dpc++;
         }
diff --git a/drivers/scsi/qla2xxx/qla_settings.h b/drivers/scsi/qla2xxx/qla_settings.h
index f0b2b9986a55..d70f03008981 100644
--- a/drivers/scsi/qla2xxx/qla_settings.h
+++ b/drivers/scsi/qla2xxx/qla_settings.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_sup.c b/drivers/scsi/qla2xxx/qla_sup.c
index 22070621206c..693647661ed1 100644
--- a/drivers/scsi/qla2xxx/qla_sup.c
+++ b/drivers/scsi/qla2xxx/qla_sup.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_version.h b/drivers/scsi/qla2xxx/qla_version.h
index 3a260c3f055a..062c97bf62f5 100644
--- a/drivers/scsi/qla2xxx/qla_version.h
+++ b/drivers/scsi/qla2xxx/qla_version.h
@@ -1,15 +1,15 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
 /*
  * Driver version
  */
-#define QLA2XXX_VERSION      "8.03.07.00"
+#define QLA2XXX_VERSION      "8.03.07.03-k"
 
 #define QLA_DRIVER_MAJOR_VER    8
 #define QLA_DRIVER_MINOR_VER    3
 #define QLA_DRIVER_PATCH_VER    7
-#define QLA_DRIVER_BETA_VER     0
+#define QLA_DRIVER_BETA_VER     3
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index 230ba097d28c..c22f2a764d9d 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -2068,15 +2068,14 @@ static int qla4xxx_eh_abort(struct scsi_cmnd *cmd)
         struct scsi_qla_host *ha = to_qla_host(cmd->device->host);
         unsigned int id = cmd->device->id;
         unsigned int lun = cmd->device->lun;
-        unsigned long serial = cmd->serial_number;
         unsigned long flags;
         struct srb *srb = NULL;
         int ret = SUCCESS;
         int wait = 0;
 
         ql4_printk(KERN_INFO, ha,
-            "scsi%ld:%d:%d: Abort command issued cmd=%p, pid=%ld\n",
-            ha->host_no, id, lun, cmd, serial);
+            "scsi%ld:%d:%d: Abort command issued cmd=%p\n",
+            ha->host_no, id, lun, cmd);
 
         spin_lock_irqsave(&ha->hardware_lock, flags);
         srb = (struct srb *) CMD_SP(cmd);
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 633c2395a92a..abea2cf05c2e 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -321,6 +321,12 @@ static int scsi_check_sense(struct scsi_cmnd *scmd)
                                     "changed. The Linux SCSI layer does not "
                                     "automatically adjust these parameters.\n");
 
+                if (sshdr.asc == 0x38 && sshdr.ascq == 0x07)
+                        scmd_printk(KERN_WARNING, scmd,
+                                    "Warning! Received an indication that the "
+                                    "LUN reached a thin provisioning soft "
+                                    "threshold.\n");
+
                 /*
                  * Pass the UA upwards for a determination in the completion
                  * functions.
diff --git a/drivers/scsi/scsi_proc.c b/drivers/scsi/scsi_proc.c
index c99da926fdac..f46855cd853d 100644
--- a/drivers/scsi/scsi_proc.c
+++ b/drivers/scsi/scsi_proc.c
@@ -386,13 +386,59 @@ static ssize_t proc_scsi_write(struct file *file, const char __user *buf,
  * @s: output goes here
  * @p: not used
  */
-static int proc_scsi_show(struct seq_file *s, void *p)
+static int always_match(struct device *dev, void *data)
 {
-        seq_printf(s, "Attached devices:\n");
-        bus_for_each_dev(&scsi_bus_type, NULL, s, proc_print_scsidevice);
-        return 0;
+        return 1;
+}
+
+static inline struct device *next_scsi_device(struct device *start)
+{
+        struct device *next = bus_find_device(&scsi_bus_type, start, NULL,
+                                              always_match);
+        put_device(start);
+        return next;
 }
 
+static void *scsi_seq_start(struct seq_file *sfile, loff_t *pos)
+{
+        struct device *dev = NULL;
+        loff_t n = *pos;
+
+        while ((dev = next_scsi_device(dev))) {
+                if (!n--)
+                        break;
+                sfile->private++;
+        }
+        return dev;
+}
+
+static void *scsi_seq_next(struct seq_file *sfile, void *v, loff_t *pos)
+{
+        (*pos)++;
+        sfile->private++;
+        return next_scsi_device(v);
+}
+
+static void scsi_seq_stop(struct seq_file *sfile, void *v)
+{
+        put_device(v);
+}
+
+static int scsi_seq_show(struct seq_file *sfile, void *dev)
+{
+        if (!sfile->private)
+                seq_puts(sfile, "Attached devices:\n");
+
+        return proc_print_scsidevice(dev, sfile);
+}
+
+static const struct seq_operations scsi_seq_ops = {
+        .start  = scsi_seq_start,
+        .next   = scsi_seq_next,
+        .stop   = scsi_seq_stop,
+        .show   = scsi_seq_show
+};
+
 /**
  * proc_scsi_open - glue function
  * @inode: not used
@@ -406,7 +452,7 @@ static int proc_scsi_open(struct inode *inode, struct file *file)
          * We don't really need this for the write case but it doesn't
          * harm either.
          */
-        return single_open(file, proc_scsi_show, NULL);
+        return seq_open(file, &scsi_seq_ops);
 }
 
 static const struct file_operations proc_scsi_operations = {
@@ -415,7 +461,7 @@ static const struct file_operations proc_scsi_operations = {
         .read           = seq_read,
         .write          = proc_scsi_write,
         .llseek         = seq_lseek,
-        .release        = single_release,
+        .release        = seq_release,
 };
 
 /**
diff --git a/drivers/scsi/scsi_tgt_lib.c b/drivers/scsi/scsi_tgt_lib.c
index 8bca8c25ba69..84a1fdf67864 100644
--- a/drivers/scsi/scsi_tgt_lib.c
+++ b/drivers/scsi/scsi_tgt_lib.c
@@ -275,10 +275,8 @@ void scsi_tgt_free_queue(struct Scsi_Host *shost)
 
         for (i = 0; i < ARRAY_SIZE(qdata->cmd_hash); i++) {
                 list_for_each_entry_safe(tcmd, n, &qdata->cmd_hash[i],
-                                         hash_list) {
-                        list_del(&tcmd->hash_list);
-                        list_add(&tcmd->hash_list, &cmds);
-                }
+                                         hash_list)
+                        list_move(&tcmd->hash_list, &cmds);
         }
 
         spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index 815069d13f9b..1b214910b714 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -422,8 +422,7 @@ static int fc_host_setup(struct transport_container *tc, struct device *dev,
 
         snprintf(fc_host->work_q_name, sizeof(fc_host->work_q_name),
                  "fc_wq_%d", shost->host_no);
-        fc_host->work_q = create_singlethread_workqueue(
-                                        fc_host->work_q_name);
+        fc_host->work_q = alloc_workqueue(fc_host->work_q_name, 0, 0);
         if (!fc_host->work_q)
                 return -ENOMEM;
 
@@ -431,8 +430,8 @@ static int fc_host_setup(struct transport_container *tc, struct device *dev,
         snprintf(fc_host->devloss_work_q_name,
                  sizeof(fc_host->devloss_work_q_name),
                  "fc_dl_%d", shost->host_no);
-        fc_host->devloss_work_q = create_singlethread_workqueue(
-                                        fc_host->devloss_work_q_name);
+        fc_host->devloss_work_q =
+                        alloc_workqueue(fc_host->devloss_work_q_name, 0, 0);
         if (!fc_host->devloss_work_q) {
                 destroy_workqueue(fc_host->work_q);
                 fc_host->work_q = NULL;
@@ -2489,6 +2488,8 @@ fc_rport_final_delete(struct work_struct *work)
         unsigned long flags;
         int do_callback = 0;
 
+        fc_terminate_rport_io(rport);
+
         /*
          * if a scan is pending, flush the SCSI Host work_q so that
          * that we can reclaim the rport scan work element.
@@ -2496,8 +2497,6 @@ fc_rport_final_delete(struct work_struct *work)
         if (rport->flags & FC_RPORT_SCAN_PENDING)
                 scsi_flush_work(shost);
 
-        fc_terminate_rport_io(rport);
-
         /*
          * Cancel any outstanding timers. These should really exist
          * only when rmmod'ing the LLDD and we're asking for
diff --git a/drivers/scsi/tmscsim.c b/drivers/scsi/tmscsim.c
index a124a28f2ccb..a1baccce05f0 100644
--- a/drivers/scsi/tmscsim.c
+++ b/drivers/scsi/tmscsim.c
@@ -565,12 +565,12 @@ dc390_StartSCSI( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_sr
         pDCB->TagMask |= 1 << tag[1];
         pSRB->TagNumber = tag[1];
         DC390_write8(ScsiFifo, tag[1]);
-        DEBUG1(printk(KERN_INFO "DC390: Select w/DisCn for Cmd %li (SRB %p), block tag %02x\n", scmd->serial_number, pSRB, tag[1]));
+        DEBUG1(printk(KERN_INFO "DC390: Select w/DisCn for SRB %p, block tag %02x\n", pSRB, tag[1]));
         cmd = SEL_W_ATN3;
     } else {
         /* No TagQ */
 //no_tag:
-        DEBUG1(printk(KERN_INFO "DC390: Select w%s/DisCn for Cmd %li (SRB %p), No TagQ\n", disc_allowed ? "" : "o", scmd->serial_number, pSRB));
+        DEBUG1(printk(KERN_INFO "DC390: Select w%s/DisCn for SRB %p, No TagQ\n", disc_allowed ? "" : "o", pSRB));
     }
 
     pSRB->SRBState = SRB_START_;
@@ -620,8 +620,8 @@ dc390_StartSCSI( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_sr
     if (DC390_read8 (Scsi_Status) & INTERRUPT)
     {
         dc390_freetag (pDCB, pSRB);
-        DEBUG0(printk ("DC390: Interrupt during Start SCSI (pid %li, target %02i-%02i)\n",
-                scmd->serial_number, scmd->device->id, scmd->device->lun));
+        DEBUG0(printk ("DC390: Interrupt during Start SCSI (target %02i-%02i)\n",
+                scmd->device->id, scmd->device->lun));
         pSRB->SRBState = SRB_READY;
         //DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
         pACB->SelLost++;
@@ -1705,8 +1705,7 @@ dc390_SRBdone( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb*
 
     status = pSRB->TargetStatus;
 
-    DEBUG0(printk (" SRBdone (%02x,%08x), SRB %p, pid %li\n", status, pcmd->result,\
-                pSRB, pcmd->serial_number));
+    DEBUG0(printk (" SRBdone (%02x,%08x), SRB %p\n", status, pcmd->result, pSRB));
     if(pSRB->SRBFlag & AUTO_REQSENSE)
     {   /* Last command was a Request Sense */
         pSRB->SRBFlag &= ~AUTO_REQSENSE;
@@ -1727,7 +1726,7 @@ dc390_SRBdone( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb*
             } else {
                 SET_RES_DRV(pcmd->result, DRIVER_SENSE);
                 //pSRB->ScsiCmdLen       = (u8) (pSRB->Segment1[0] >> 8);
-                DEBUG0 (printk ("DC390: RETRY pid %li (%02x), target %02i-%02i\n", pcmd->serial_number, pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun));
+                DEBUG0 (printk ("DC390: RETRY (%02x), target %02i-%02i\n", pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun));
                 pSRB->TotalXferredLen = 0;
                 SET_RES_DID(pcmd->result, DID_SOFT_ERROR);
             }
@@ -1747,7 +1746,7 @@ dc390_SRBdone( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb*
         else if (status == SAM_STAT_TASK_SET_FULL)
         {
             scsi_track_queue_full(pcmd->device, pDCB->GoingSRBCnt - 1);
-            DEBUG0 (printk ("DC390: RETRY pid %li (%02x), target %02i-%02i\n", pcmd->serial_number, pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun));
+            DEBUG0 (printk ("DC390: RETRY (%02x), target %02i-%02i\n", pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun));
             pSRB->TotalXferredLen = 0;
             SET_RES_DID(pcmd->result, DID_SOFT_ERROR);
         }
@@ -1801,7 +1800,7 @@ cmd_done:
     /* Add to free list */
     dc390_Free_insert (pACB, pSRB);
 
-    DEBUG0(printk (KERN_DEBUG "DC390: SRBdone: done pid %li\n", pcmd->serial_number));
+    DEBUG0(printk (KERN_DEBUG "DC390: SRBdone: done\n"));
     pcmd->scsi_done (pcmd);
 
     return;
@@ -1997,8 +1996,7 @@ static int DC390_abort(struct scsi_cmnd *cmd)
         struct dc390_acb *pACB = (struct dc390_acb*) cmd->device->host->hostdata;
         struct dc390_dcb *pDCB = (struct dc390_dcb*) cmd->device->hostdata;
 
-        scmd_printk(KERN_WARNING, cmd,
-                "DC390: Abort command (pid %li)\n", cmd->serial_number);
+        scmd_printk(KERN_WARNING, cmd, "DC390: Abort command\n");
 
         /* abort() is too stupid for already sent commands at the moment. 
          * If it's called we are in trouble anyway, so let's dump some info 
@@ -2006,7 +2004,7 @@ static int DC390_abort(struct scsi_cmnd *cmd)
         dc390_dumpinfo(pACB, pDCB, NULL);
 
         pDCB->DCBFlag |= ABORT_DEV_;
-        printk(KERN_INFO "DC390: Aborted pid %li\n", cmd->serial_number);
+        printk(KERN_INFO "DC390: Aborted.\n");
 
         return FAILED;
 }
diff --git a/drivers/scsi/u14-34f.c b/drivers/scsi/u14-34f.c
index edfc5da8be4c..90e104d6b558 100644
--- a/drivers/scsi/u14-34f.c
+++ b/drivers/scsi/u14-34f.c
@@ -1256,8 +1256,8 @@ static int u14_34f_queuecommand_lck(struct scsi_cmnd *SCpnt, void (*done)(struct
    j = ((struct hostdata *) SCpnt->device->host->hostdata)->board_number;
 
    if (SCpnt->host_scribble)
-      panic("%s: qcomm, pid %ld, SCpnt %p already active.\n",
-            BN(j), SCpnt->serial_number, SCpnt);
+      panic("%s: qcomm, SCpnt %p already active.\n",
+            BN(j), SCpnt);
 
    /* i is the mailbox number, look for the first free mailbox
       starting from last_cp_used */
@@ -1286,9 +1286,9 @@ static int u14_34f_queuecommand_lck(struct scsi_cmnd *SCpnt, void (*done)(struct
    cpp->cpp_index = i;
    SCpnt->host_scribble = (unsigned char *) &cpp->cpp_index;
 
-   if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d, pid %ld.\n",
+   if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d.\n",
                         BN(j), i, SCpnt->device->channel, SCpnt->device->id,
-                        SCpnt->device->lun, SCpnt->serial_number);
+                        SCpnt->device->lun);
 
    cpp->opcode = OP_SCSI;
    cpp->channel = SCpnt->device->channel;
@@ -1315,7 +1315,7 @@ static int u14_34f_queuecommand_lck(struct scsi_cmnd *SCpnt, void (*done)(struct
       unmap_dma(i, j);
       SCpnt->host_scribble = NULL;
       scmd_printk(KERN_INFO, SCpnt,
-                "qcomm, pid %ld, adapter busy.\n", SCpnt->serial_number);
+                "qcomm, adapter busy.\n");
       return 1;
       }
 
@@ -1337,14 +1337,12 @@ static int u14_34f_eh_abort(struct scsi_cmnd *SCarg) {
    j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
 
    if (SCarg->host_scribble == NULL) {
-      scmd_printk(KERN_INFO, SCarg, "abort, pid %ld inactive.\n",
-             SCarg->serial_number);
+      scmd_printk(KERN_INFO, SCarg, "abort, command inactive.\n");
       return SUCCESS;
       }
 
    i = *(unsigned int *)SCarg->host_scribble;
-   scmd_printk(KERN_INFO, SCarg, "abort, mbox %d, pid %ld.\n",
-               i, SCarg->serial_number);
+   scmd_printk(KERN_INFO, SCarg, "abort, mbox %d.\n", i);
 
    if (i >= sh[j]->can_queue)
       panic("%s: abort, invalid SCarg->host_scribble.\n", BN(j));
@@ -1387,8 +1385,7 @@ static int u14_34f_eh_abort(struct scsi_cmnd *SCarg) {
       SCarg->result = DID_ABORT << 16;
       SCarg->host_scribble = NULL;
       HD(j)->cp_stat[i] = FREE;
-      printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n",
-             BN(j), i, SCarg->serial_number);
+      printk("%s, abort, mbox %d ready, DID_ABORT, done.\n", BN(j), i);
       SCarg->scsi_done(SCarg);
       return SUCCESS;
       }
@@ -1403,12 +1400,12 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
    struct scsi_cmnd *SCpnt;
 
    j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
-   scmd_printk(KERN_INFO, SCarg, "reset, enter, pid %ld.\n", SCarg->serial_number);
+   scmd_printk(KERN_INFO, SCarg, "reset, enter.\n");
 
    spin_lock_irq(sh[j]->host_lock);
 
    if (SCarg->host_scribble == NULL)
-      printk("%s: reset, pid %ld inactive.\n", BN(j), SCarg->serial_number);
+      printk("%s: reset, inactive.\n", BN(j));
 
    if (HD(j)->in_reset) {
       printk("%s: reset, exit, already in reset.\n", BN(j));
@@ -1445,14 +1442,12 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
 
       if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) {
          HD(j)->cp_stat[i] = ABORTING;
-         printk("%s: reset, mbox %d aborting, pid %ld.\n",
-                BN(j), i, SCpnt->serial_number);
+         printk("%s: reset, mbox %d aborting.\n", BN(j), i);
          }
 
       else {
          HD(j)->cp_stat[i] = IN_RESET;
-         printk("%s: reset, mbox %d in reset, pid %ld.\n",
-                BN(j), i, SCpnt->serial_number);
+         printk("%s: reset, mbox %d in reset.\n", BN(j), i);
          }
 
       if (SCpnt->host_scribble == NULL)
@@ -1500,8 +1495,7 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
          /* This mailbox is still waiting for its interrupt */
          HD(j)->cp_stat[i] = LOCKED;
 
-         printk("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n",
-                BN(j), i, SCpnt->serial_number);
+         printk("%s, reset, mbox %d locked, DID_RESET, done.\n", BN(j), i);
          }
 
       else if (HD(j)->cp_stat[i] == ABORTING) {
@@ -1513,8 +1507,7 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
          /* This mailbox was never queued to the adapter */
          HD(j)->cp_stat[i] = FREE;
 
-         printk("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n",
-                BN(j), i, SCpnt->serial_number);
+         printk("%s, reset, mbox %d aborting, DID_RESET, done.\n", BN(j), i);
          }
 
       else
@@ -1528,7 +1521,7 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
    HD(j)->in_reset = FALSE;
    do_trace = FALSE;
 
-   if (arg_done) printk("%s: reset, exit, pid %ld done.\n", BN(j), SCarg->serial_number);
+   if (arg_done) printk("%s: reset, exit, done.\n", BN(j));
    else          printk("%s: reset, exit.\n", BN(j));
 
    spin_unlock_irq(sh[j]->host_lock);
@@ -1671,10 +1664,10 @@ static int reorder(unsigned int j, unsigned long cursec,
    if (link_statistics && (overlap || !(flushcount % link_statistics)))
       for (n = 0; n < n_ready; n++) {
          k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
-         printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %u"\
+         printk("%s %d.%d:%d mb %d fc %d nr %d sec %ld ns %u"\
                 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
                 (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target,
-                SCpnt->lun, SCpnt->serial_number, k, flushcount, n_ready,
+                SCpnt->lun, k, flushcount, n_ready,
                 blk_rq_pos(SCpnt->request), blk_rq_sectors(SCpnt->request),
                 cursec, YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
                 YESNO(overlap), cpp->xdir);
@@ -1709,9 +1702,9 @@ static void flush_dev(struct scsi_device *dev, unsigned long cursec, unsigned in
 
       if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
          scmd_printk(KERN_INFO, SCpnt,
-                "%s, pid %ld, mbox %d, adapter"
+                "%s, mbox %d, adapter"
                 " busy, will abort.\n", (ihdlr ? "ihdlr" : "qcomm"),
-                SCpnt->serial_number, k);
+                k);
          HD(j)->cp_stat[k] = ABORTING;
          continue;
          }
@@ -1793,12 +1786,12 @@ static irqreturn_t ihdlr(unsigned int j)
    if (SCpnt == NULL) panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", BN(j), i);
 
    if (SCpnt->host_scribble == NULL)
-      panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", BN(j), i,
-            SCpnt->serial_number, SCpnt);
+      panic("%s: ihdlr, mbox %d, SCpnt %p garbled.\n", BN(j), i,
+            SCpnt);
 
    if (*(unsigned int *)SCpnt->host_scribble != i)
-      panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n",
-            BN(j), i, SCpnt->serial_number, *(unsigned int *)SCpnt->host_scribble);
+      panic("%s: ihdlr, mbox %d, index mismatch %d.\n",
+            BN(j), i, *(unsigned int *)SCpnt->host_scribble);
 
    sync_dma(i, j);
 
@@ -1841,8 +1834,8 @@ static irqreturn_t ihdlr(unsigned int j)
              (!(tstatus == CHECK_CONDITION && HD(j)->iocount <= 1000 &&
                (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
             scmd_printk(KERN_INFO, SCpnt,
-                "ihdlr, pid %ld, target_status 0x%x, sense key 0x%x.\n",
-                   SCpnt->serial_number, spp->target_status,
+                "ihdlr, target_status 0x%x, sense key 0x%x.\n",
+                   spp->target_status,
                    SCpnt->sense_buffer[2]);
 
          HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] = 0;
@@ -1913,8 +1906,8 @@ static irqreturn_t ihdlr(unsigned int j)
         do_trace || msg_byte(spp->target_status))
 #endif
       scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"\
-             " pid %ld, reg 0x%x, count %d.\n",
-             i, spp->adapter_status, spp->target_status, SCpnt->serial_number,
+             " reg 0x%x, count %d.\n",
+             i, spp->adapter_status, spp->target_status,
              reg, HD(j)->iocount);
 
    unmap_dma(i, j);
diff --git a/drivers/scsi/wd33c93.c b/drivers/scsi/wd33c93.c
index 4468ae3610f7..97ae716134d0 100644
--- a/drivers/scsi/wd33c93.c
+++ b/drivers/scsi/wd33c93.c
@@ -381,7 +381,7 @@ wd33c93_queuecommand_lck(struct scsi_cmnd *cmd,
         hostdata = (struct WD33C93_hostdata *) cmd->device->host->hostdata;
 
         DB(DB_QUEUE_COMMAND,
-           printk("Q-%d-%02x-%ld( ", cmd->device->id, cmd->cmnd[0], cmd->serial_number))
+           printk("Q-%d-%02x( ", cmd->device->id, cmd->cmnd[0]))
 
 /* Set up a few fields in the scsi_cmnd structure for our own use:
  *  - host_scribble is the pointer to the next cmd in the input queue
@@ -462,7 +462,7 @@ wd33c93_queuecommand_lck(struct scsi_cmnd *cmd,
 
         wd33c93_execute(cmd->device->host);
 
-        DB(DB_QUEUE_COMMAND, printk(")Q-%ld ", cmd->serial_number))
+        DB(DB_QUEUE_COMMAND, printk(")Q "))
 
         spin_unlock_irq(&hostdata->lock);
         return 0;
@@ -687,7 +687,7 @@ wd33c93_execute(struct Scsi_Host *instance)
          */
 
         DB(DB_EXECUTE,
-           printk("%s%ld)EX-2 ", (cmd->SCp.phase) ? "d:" : "", cmd->serial_number))
+           printk("%s)EX-2 ", (cmd->SCp.phase) ? "d:" : ""))
 }
 
 static void
@@ -963,7 +963,7 @@ wd33c93_intr(struct Scsi_Host *instance)
         case CSR_XFER_DONE | PHS_COMMAND:
         case CSR_UNEXP | PHS_COMMAND:
         case CSR_SRV_REQ | PHS_COMMAND:
-                DB(DB_INTR, printk("CMND-%02x,%ld", cmd->cmnd[0], cmd->serial_number))
+                DB(DB_INTR, printk("CMND-%02x", cmd->cmnd[0]))
                     transfer_pio(regs, cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR,
                                  hostdata);
                 hostdata->state = S_CONNECTED;
@@ -1007,7 +1007,7 @@ wd33c93_intr(struct Scsi_Host *instance)
                 switch (msg) {
 
                 case COMMAND_COMPLETE:
-                        DB(DB_INTR, printk("CCMP-%ld", cmd->serial_number))
+                        DB(DB_INTR, printk("CCMP"))
                             write_wd33c93_cmd(regs, WD_CMD_NEGATE_ACK);
                         hostdata->state = S_PRE_CMP_DISC;
                         break;
@@ -1174,7 +1174,7 @@ wd33c93_intr(struct Scsi_Host *instance)
 
                 write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER);
                 if (phs == 0x60) {
-                        DB(DB_INTR, printk("SX-DONE-%ld", cmd->serial_number))
+                        DB(DB_INTR, printk("SX-DONE"))
                             cmd->SCp.Message = COMMAND_COMPLETE;
                         lun = read_wd33c93(regs, WD_TARGET_LUN);
                         DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun))
@@ -1200,8 +1200,8 @@ wd33c93_intr(struct Scsi_Host *instance)
                         wd33c93_execute(instance);
                 } else {
                         printk
-                            ("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE phase!!---",
-                             asr, sr, phs, cmd->serial_number);
+                            ("%02x:%02x:%02x: Unknown SEL_XFER_DONE phase!!---",
+                             asr, sr, phs);
                         spin_unlock_irqrestore(&hostdata->lock, flags);
                 }
                 break;
@@ -1266,7 +1266,7 @@ wd33c93_intr(struct Scsi_Host *instance)
                         spin_unlock_irqrestore(&hostdata->lock, flags);
                         return;
                 }
-                DB(DB_INTR, printk("UNEXP_DISC-%ld", cmd->serial_number))
+                DB(DB_INTR, printk("UNEXP_DISC"))
                     hostdata->connected = NULL;
                 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
                 hostdata->state = S_UNCONNECTED;
@@ -1292,7 +1292,7 @@ wd33c93_intr(struct Scsi_Host *instance)
  */
 
                 write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER);
-                DB(DB_INTR, printk("DISC-%ld", cmd->serial_number))
+                DB(DB_INTR, printk("DISC"))
                     if (cmd == NULL) {
                         printk(" - Already disconnected! ");
                         hostdata->state = S_UNCONNECTED;
@@ -1491,7 +1491,6 @@ wd33c93_intr(struct Scsi_Host *instance)
                 } else
                         hostdata->state = S_CONNECTED;
 
-                DB(DB_INTR, printk("-%ld", cmd->serial_number))
                     spin_unlock_irqrestore(&hostdata->lock, flags);
                 break;
 
@@ -1637,8 +1636,8 @@ wd33c93_abort(struct scsi_cmnd * cmd)
                         cmd->host_scribble = NULL;
                         cmd->result = DID_ABORT << 16;
                         printk
-                            ("scsi%d: Abort - removing command %ld from input_Q. ",
-                             instance->host_no, cmd->serial_number);
+                            ("scsi%d: Abort - removing command from input_Q. ",
+                             instance->host_no);
                         enable_irq(cmd->device->host->irq);
                         cmd->scsi_done(cmd);
                         return SUCCESS;
@@ -1662,8 +1661,8 @@ wd33c93_abort(struct scsi_cmnd * cmd)
                 uchar sr, asr;
                 unsigned long timeout;
 
-                printk("scsi%d: Aborting connected command %ld - ",
-                       instance->host_no, cmd->serial_number);
+                printk("scsi%d: Aborting connected command - ",
+                       instance->host_no);
 
                 printk("stopping DMA - ");
                 if (hostdata->dma == D_DMA_RUNNING) {
@@ -1729,8 +1728,8 @@ wd33c93_abort(struct scsi_cmnd * cmd)
         while (tmp) {
                 if (tmp == cmd) {
                         printk
-                            ("scsi%d: Abort - command %ld found on disconnected_Q - ",
-                             instance->host_no, cmd->serial_number);
+                            ("scsi%d: Abort - command found on disconnected_Q - ",
+                             instance->host_no);
                         printk("Abort SNOOZE. ");
                         enable_irq(cmd->device->host->irq);
                         return FAILED;
@@ -2180,8 +2179,8 @@ wd33c93_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off
                 strcat(bp, "\nconnected:     ");
                 if (hd->connected) {
                         cmd = (struct scsi_cmnd *) hd->connected;
-                        sprintf(tbuf, " %ld-%d:%d(%02x)",
-                                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+                        sprintf(tbuf, " %d:%d(%02x)",
+                                cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
                         strcat(bp, tbuf);
                 }
         }
@@ -2189,8 +2188,8 @@ wd33c93_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off
                 strcat(bp, "\ninput_Q:       ");
                 cmd = (struct scsi_cmnd *) hd->input_Q;
                 while (cmd) {
-                        sprintf(tbuf, " %ld-%d:%d(%02x)",
-                                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+                        sprintf(tbuf, " %d:%d(%02x)",
+                                cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
                         strcat(bp, tbuf);
                         cmd = (struct scsi_cmnd *) cmd->host_scribble;
                 }
@@ -2199,8 +2198,8 @@ wd33c93_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off
                 strcat(bp, "\ndisconnected_Q:");
                 cmd = (struct scsi_cmnd *) hd->disconnected_Q;
                 while (cmd) {
-                        sprintf(tbuf, " %ld-%d:%d(%02x)",
-                                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+                        sprintf(tbuf, " %d:%d(%02x)",
+                                cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
                         strcat(bp, tbuf);
                         cmd = (struct scsi_cmnd *) cmd->host_scribble;
                 }
diff --git a/drivers/target/Kconfig b/drivers/target/Kconfig
index 9ef2dbbfa62b..5cb0f0ef6af0 100644
--- a/drivers/target/Kconfig
+++ b/drivers/target/Kconfig
@@ -30,5 +30,6 @@ config TCM_PSCSI
         passthrough access to Linux/SCSI device
 
 source "drivers/target/loopback/Kconfig"
+source "drivers/target/tcm_fc/Kconfig"
 
 endif
diff --git a/drivers/target/Makefile b/drivers/target/Makefile
index 1178bbfc68fe..21df808a992c 100644
--- a/drivers/target/Makefile
+++ b/drivers/target/Makefile
@@ -24,3 +24,5 @@ obj-$(CONFIG_TCM_PSCSI)		+= target_core_pscsi.o
 
 # Fabric modules
 obj-$(CONFIG_LOOPBACK_TARGET)   += loopback/
+
+obj-$(CONFIG_TCM_FC)            += tcm_fc/
diff --git a/drivers/target/tcm_fc/Kconfig b/drivers/target/tcm_fc/Kconfig
new file mode 100644
index 000000000000..40caf458e89e
--- /dev/null
+++ b/drivers/target/tcm_fc/Kconfig
@@ -0,0 +1,5 @@
+config TCM_FC
+        tristate "TCM_FC fabric Plugin"
+        depends on LIBFC
+        help
+        Say Y here to enable the TCM FC plugin for accessing FC fabrics in TCM
diff --git a/drivers/target/tcm_fc/Makefile b/drivers/target/tcm_fc/Makefile
new file mode 100644
index 000000000000..7a5c2b64cf65
--- /dev/null
+++ b/drivers/target/tcm_fc/Makefile
@@ -0,0 +1,15 @@
+EXTRA_CFLAGS += -I$(srctree)/drivers/target/ \
+                -I$(srctree)/drivers/scsi/ \
+                -I$(srctree)/include/scsi/ \
+                -I$(srctree)/drivers/target/tcm_fc/
+
+tcm_fc-y +=     tfc_cmd.o \
+                tfc_conf.o \
+                tfc_io.o \
+                tfc_sess.o
+
+obj-$(CONFIG_TCM_FC)    += tcm_fc.o
+
+ifdef CONFIGFS_TCM_FC_DEBUG
+EXTRA_CFLAGS    += -DTCM_FC_DEBUG
+endif
diff --git a/drivers/target/tcm_fc/tcm_fc.h b/drivers/target/tcm_fc/tcm_fc.h
new file mode 100644
index 000000000000..defff32b7880
--- /dev/null
+++ b/drivers/target/tcm_fc/tcm_fc.h
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2010 Cisco Systems, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef __TCM_FC_H__
+#define __TCM_FC_H__
+
+#define FT_VERSION "0.3"
+
+#define FT_NAMELEN 32           /* length of ASCII WWPNs including pad */
+#define FT_TPG_NAMELEN 32       /* max length of TPG name */
+#define FT_LUN_NAMELEN 32       /* max length of LUN name */
+
+/*
+ * Debug options.
+ */
+#define FT_DEBUG_CONF   0x01    /* configuration messages */
+#define FT_DEBUG_SESS   0x02    /* session messages */
+#define FT_DEBUG_TM     0x04    /* TM operations */
+#define FT_DEBUG_IO     0x08    /* I/O commands */
+#define FT_DEBUG_DATA   0x10    /* Data transfer */
+
+extern unsigned int ft_debug_logging;   /* debug options */
+
+#define FT_DEBUG(mask, fmt, args...)                                    \
+        do {                                                            \
+                if (ft_debug_logging & (mask))                          \
+                        printk(KERN_INFO "tcm_fc: %s: " fmt,            \
+                                __func__, ##args);                      \
+        } while (0)
+
+#define FT_CONF_DBG(fmt, args...)       FT_DEBUG(FT_DEBUG_CONF, fmt, ##args)
+#define FT_SESS_DBG(fmt, args...)       FT_DEBUG(FT_DEBUG_SESS, fmt, ##args)
+#define FT_TM_DBG(fmt, args...)         FT_DEBUG(FT_DEBUG_TM, fmt, ##args)
+#define FT_IO_DBG(fmt, args...)         FT_DEBUG(FT_DEBUG_IO, fmt, ##args)
+#define FT_DATA_DBG(fmt, args...)       FT_DEBUG(FT_DEBUG_DATA, fmt, ##args)
+
+struct ft_transport_id {
+        __u8    format;
+        __u8    __resvd1[7];
+        __u8    wwpn[8];
+        __u8    __resvd2[8];
+} __attribute__((__packed__));
+
+/*
+ * Session (remote port).
+ */
+struct ft_sess {
+        u32 port_id;                    /* for hash lookup use only */
+        u32 params;
+        u16 max_frame;                  /* maximum frame size */
+        u64 port_name;                  /* port name for transport ID */
+        struct ft_tport *tport;
+        struct se_session *se_sess;
+        struct hlist_node hash;         /* linkage in ft_sess_hash table */
+        struct rcu_head rcu;
+        struct kref kref;               /* ref for hash and outstanding I/Os */
+};
+
+/*
+ * Hash table of sessions per local port.
+ * Hash lookup by remote port FC_ID.
+ */
+#define FT_SESS_HASH_BITS       6
+#define FT_SESS_HASH_SIZE       (1 << FT_SESS_HASH_BITS)
+
+/*
+ * Per local port data.
+ * This is created only after a TPG exists that allows target function
+ * for the local port.  If the TPG exists, this is allocated when
+ * we're notified that the local port has been created, or when
+ * the first PRLI provider callback is received.
+ */
+struct ft_tport {
+        struct fc_lport *lport;
+        struct ft_tpg *tpg;             /* NULL if TPG deleted before tport */
+        u32     sess_count;             /* number of sessions in hash */
+        struct rcu_head rcu;
+        struct hlist_head hash[FT_SESS_HASH_SIZE];      /* list of sessions */
+};
+
+/*
+ * Node ID and authentication.
+ */
+struct ft_node_auth {
+        u64     port_name;
+        u64     node_name;
+};
+
+/*
+ * Node ACL for FC remote port session.
+ */
+struct ft_node_acl {
+        struct ft_node_auth node_auth;
+        struct se_node_acl se_node_acl;
+};
+
+struct ft_lun {
+        u32 index;
+        char name[FT_LUN_NAMELEN];
+};
+
+/*
+ * Target portal group (local port).
+ */
+struct ft_tpg {
+        u32 index;
+        struct ft_lport_acl *lport_acl;
+        struct ft_tport *tport;         /* active tport or NULL */
+        struct list_head list;          /* linkage in ft_lport_acl tpg_list */
+        struct list_head lun_list;      /* head of LUNs */
+        struct se_portal_group se_tpg;
+        struct task_struct *thread;     /* processing thread */
+        struct se_queue_obj qobj;       /* queue for processing thread */
+};
+
+struct ft_lport_acl {
+        u64 wwpn;
+        char name[FT_NAMELEN];
+        struct list_head list;
+        struct list_head tpg_list;
+        struct se_wwn fc_lport_wwn;
+};
+
+enum ft_cmd_state {
+        FC_CMD_ST_NEW = 0,
+        FC_CMD_ST_REJ
+};
+
+/*
+ * Commands
+ */
+struct ft_cmd {
+        enum ft_cmd_state state;
+        u16 lun;                        /* LUN from request */
+        struct ft_sess *sess;           /* session held for cmd */
+        struct fc_seq *seq;             /* sequence in exchange mgr */
+        struct se_cmd se_cmd;           /* Local TCM I/O descriptor */
+        struct fc_frame *req_frame;
+        unsigned char *cdb;             /* pointer to CDB inside frame */
+        u32 write_data_len;             /* data received on writes */
+        struct se_queue_req se_req;
+        /* Local sense buffer */
+        unsigned char ft_sense_buffer[TRANSPORT_SENSE_BUFFER];
+        u32 was_ddp_setup:1;            /* Set only if ddp is setup */
+        struct scatterlist *sg;         /* Set only if DDP is setup */
+        u32 sg_cnt;                     /* No. of item in scatterlist */
+};
+
+extern struct list_head ft_lport_list;
+extern struct mutex ft_lport_lock;
+extern struct fc4_prov ft_prov;
+extern struct target_fabric_configfs *ft_configfs;
+
+/*
+ * Fabric methods.
+ */
+
+/*
+ * Session ops.
+ */
+void ft_sess_put(struct ft_sess *);
+int ft_sess_shutdown(struct se_session *);
+void ft_sess_close(struct se_session *);
+void ft_sess_stop(struct se_session *, int, int);
+int ft_sess_logged_in(struct se_session *);
+u32 ft_sess_get_index(struct se_session *);
+u32 ft_sess_get_port_name(struct se_session *, unsigned char *, u32);
+void ft_sess_set_erl0(struct se_session *);
+
+void ft_lport_add(struct fc_lport *, void *);
+void ft_lport_del(struct fc_lport *, void *);
+int ft_lport_notify(struct notifier_block *, unsigned long, void *);
+
+/*
+ * IO methods.
+ */
+void ft_check_stop_free(struct se_cmd *);
+void ft_release_cmd(struct se_cmd *);
+int ft_queue_status(struct se_cmd *);
+int ft_queue_data_in(struct se_cmd *);
+int ft_write_pending(struct se_cmd *);
+int ft_write_pending_status(struct se_cmd *);
+u32 ft_get_task_tag(struct se_cmd *);
+int ft_get_cmd_state(struct se_cmd *);
+void ft_new_cmd_failure(struct se_cmd *);
+int ft_queue_tm_resp(struct se_cmd *);
+int ft_is_state_remove(struct se_cmd *);
+
+/*
+ * other internal functions.
+ */
+int ft_thread(void *);
+void ft_recv_req(struct ft_sess *, struct fc_frame *);
+struct ft_tpg *ft_lport_find_tpg(struct fc_lport *);
+struct ft_node_acl *ft_acl_get(struct ft_tpg *, struct fc_rport_priv *);
+
+void ft_recv_write_data(struct ft_cmd *, struct fc_frame *);
+void ft_dump_cmd(struct ft_cmd *, const char *caller);
+
+ssize_t ft_format_wwn(char *, size_t, u64);
+
+#endif /* __TCM_FC_H__ */
diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
new file mode 100644
index 000000000000..49e51778f733
--- /dev/null
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -0,0 +1,696 @@
+/*
+ * Copyright (c) 2010 Cisco Systems, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/* XXX TBD some includes may be extraneous */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/version.h>
+#include <generated/utsrelease.h>
+#include <linux/utsname.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/kthread.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/configfs.h>
+#include <linux/ctype.h>
+#include <linux/hash.h>
+#include <asm/unaligned.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/libfc.h>
+#include <scsi/fc_encode.h>
+
+#include <target/target_core_base.h>
+#include <target/target_core_transport.h>
+#include <target/target_core_fabric_ops.h>
+#include <target/target_core_device.h>
+#include <target/target_core_tpg.h>
+#include <target/target_core_configfs.h>
+#include <target/target_core_base.h>
+#include <target/target_core_tmr.h>
+#include <target/configfs_macros.h>
+
+#include "tcm_fc.h"
+
+/*
+ * Dump cmd state for debugging.
+ */
+void ft_dump_cmd(struct ft_cmd *cmd, const char *caller)
+{
+        struct fc_exch *ep;
+        struct fc_seq *sp;
+        struct se_cmd *se_cmd;
+        struct se_mem *mem;
+        struct se_transport_task *task;
+
+        if (!(ft_debug_logging & FT_DEBUG_IO))
+                return;
+
+        se_cmd = &cmd->se_cmd;
+        printk(KERN_INFO "%s: cmd %p state %d sess %p seq %p se_cmd %p\n",
+                caller, cmd, cmd->state, cmd->sess, cmd->seq, se_cmd);
+        printk(KERN_INFO "%s: cmd %p cdb %p\n",
+                caller, cmd, cmd->cdb);
+        printk(KERN_INFO "%s: cmd %p lun %d\n", caller, cmd, cmd->lun);
+
+        task = T_TASK(se_cmd);
+        printk(KERN_INFO "%s: cmd %p task %p se_num %u buf %p len %u se_cmd_flags <0x%x>\n",
+               caller, cmd, task, task->t_tasks_se_num,
+               task->t_task_buf, se_cmd->data_length, se_cmd->se_cmd_flags);
+        if (task->t_mem_list)
+                list_for_each_entry(mem, task->t_mem_list, se_list)
+                        printk(KERN_INFO "%s: cmd %p mem %p page %p "
+                               "len 0x%x off 0x%x\n",
+                               caller, cmd, mem,
+                               mem->se_page, mem->se_len, mem->se_off);
+        sp = cmd->seq;
+        if (sp) {
+                ep = fc_seq_exch(sp);
+                printk(KERN_INFO "%s: cmd %p sid %x did %x "
+                        "ox_id %x rx_id %x seq_id %x e_stat %x\n",
+                        caller, cmd, ep->sid, ep->did, ep->oxid, ep->rxid,
+                        sp->id, ep->esb_stat);
+        }
+        print_hex_dump(KERN_INFO, "ft_dump_cmd ", DUMP_PREFIX_NONE,
+                16, 4, cmd->cdb, MAX_COMMAND_SIZE, 0);
+}
+
+/*
+ * Get LUN from CDB.
+ */
+static int ft_get_lun_for_cmd(struct ft_cmd *cmd, u8 *lunp)
+{
+        u64 lun;
+
+        lun = lunp[1];
+        switch (lunp[0] >> 6) {
+        case 0:
+                break;
+        case 1:
+                lun |= (lunp[0] & 0x3f) << 8;
+                break;
+        default:
+                return -1;
+        }
+        if (lun >= TRANSPORT_MAX_LUNS_PER_TPG)
+                return -1;
+        cmd->lun = lun;
+        return transport_get_lun_for_cmd(&cmd->se_cmd, NULL, lun);
+}
+
+static void ft_queue_cmd(struct ft_sess *sess, struct ft_cmd *cmd)
+{
+        struct se_queue_obj *qobj;
+        unsigned long flags;
+
+        qobj = &sess->tport->tpg->qobj;
+        spin_lock_irqsave(&qobj->cmd_queue_lock, flags);
+        list_add_tail(&cmd->se_req.qr_list, &qobj->qobj_list);
+        spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
+        atomic_inc(&qobj->queue_cnt);
+        wake_up_interruptible(&qobj->thread_wq);
+}
+
+static struct ft_cmd *ft_dequeue_cmd(struct se_queue_obj *qobj)
+{
+        unsigned long flags;
+        struct se_queue_req *qr;
+
+        spin_lock_irqsave(&qobj->cmd_queue_lock, flags);
+        if (list_empty(&qobj->qobj_list)) {
+                spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
+                return NULL;
+        }
+        qr = list_first_entry(&qobj->qobj_list, struct se_queue_req, qr_list);
+        list_del(&qr->qr_list);
+        atomic_dec(&qobj->queue_cnt);
+        spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
+        return container_of(qr, struct ft_cmd, se_req);
+}
+
+static void ft_free_cmd(struct ft_cmd *cmd)
+{
+        struct fc_frame *fp;
+        struct fc_lport *lport;
+
+        if (!cmd)
+                return;
+        fp = cmd->req_frame;
+        lport = fr_dev(fp);
+        if (fr_seq(fp))
+                lport->tt.seq_release(fr_seq(fp));
+        fc_frame_free(fp);
+        ft_sess_put(cmd->sess); /* undo get from lookup at recv */
+        kfree(cmd);
+}
+
+void ft_release_cmd(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+
+        ft_free_cmd(cmd);
+}
+
+void ft_check_stop_free(struct se_cmd *se_cmd)
+{
+        transport_generic_free_cmd(se_cmd, 0, 1, 0);
+}
+
+/*
+ * Send response.
+ */
+int ft_queue_status(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+        struct fc_frame *fp;
+        struct fcp_resp_with_ext *fcp;
+        struct fc_lport *lport;
+        struct fc_exch *ep;
+        size_t len;
+
+        ft_dump_cmd(cmd, __func__);
+        ep = fc_seq_exch(cmd->seq);
+        lport = ep->lp;
+        len = sizeof(*fcp) + se_cmd->scsi_sense_length;
+        fp = fc_frame_alloc(lport, len);
+        if (!fp) {
+                /* XXX shouldn't just drop it - requeue and retry? */
+                return 0;
+        }
+        fcp = fc_frame_payload_get(fp, len);
+        memset(fcp, 0, len);
+        fcp->resp.fr_status = se_cmd->scsi_status;
+
+        len = se_cmd->scsi_sense_length;
+        if (len) {
+                fcp->resp.fr_flags |= FCP_SNS_LEN_VAL;
+                fcp->ext.fr_sns_len = htonl(len);
+                memcpy((fcp + 1), se_cmd->sense_buffer, len);
+        }
+
+        /*
+         * Test underflow and overflow with one mask.  Usually both are off.
+         * Bidirectional commands are not handled yet.
+         */
+        if (se_cmd->se_cmd_flags & (SCF_OVERFLOW_BIT | SCF_UNDERFLOW_BIT)) {
+                if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT)
+                        fcp->resp.fr_flags |= FCP_RESID_OVER;
+                else
+                        fcp->resp.fr_flags |= FCP_RESID_UNDER;
+                fcp->ext.fr_resid = cpu_to_be32(se_cmd->residual_count);
+        }
+
+        /*
+         * Send response.
+         */
+        cmd->seq = lport->tt.seq_start_next(cmd->seq);
+        fc_fill_fc_hdr(fp, FC_RCTL_DD_CMD_STATUS, ep->did, ep->sid, FC_TYPE_FCP,
+                       FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ, 0);
+
+        lport->tt.seq_send(lport, cmd->seq, fp);
+        lport->tt.exch_done(cmd->seq);
+        return 0;
+}
+
+int ft_write_pending_status(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+
+        return cmd->write_data_len != se_cmd->data_length;
+}
+
+/*
+ * Send TX_RDY (transfer ready).
+ */
+int ft_write_pending(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+        struct fc_frame *fp;
+        struct fcp_txrdy *txrdy;
+        struct fc_lport *lport;
+        struct fc_exch *ep;
+        struct fc_frame_header *fh;
+        u32 f_ctl;
+
+        ft_dump_cmd(cmd, __func__);
+
+        ep = fc_seq_exch(cmd->seq);
+        lport = ep->lp;
+        fp = fc_frame_alloc(lport, sizeof(*txrdy));
+        if (!fp)
+                return PYX_TRANSPORT_OUT_OF_MEMORY_RESOURCES;
+
+        txrdy = fc_frame_payload_get(fp, sizeof(*txrdy));
+        memset(txrdy, 0, sizeof(*txrdy));
+        txrdy->ft_burst_len = htonl(se_cmd->data_length);
+
+        cmd->seq = lport->tt.seq_start_next(cmd->seq);
+        fc_fill_fc_hdr(fp, FC_RCTL_DD_DATA_DESC, ep->did, ep->sid, FC_TYPE_FCP,
+                       FC_FC_EX_CTX | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
+
+        fh = fc_frame_header_get(fp);
+        f_ctl = ntoh24(fh->fh_f_ctl);
+
+        /* Only if it is 'Exchange Responder' */
+        if (f_ctl & FC_FC_EX_CTX) {
+                /* Target is 'exchange responder' and sending XFER_READY
+                 * to 'exchange initiator (initiator)'
+                 */
+                if ((ep->xid <= lport->lro_xid) &&
+                    (fh->fh_r_ctl == FC_RCTL_DD_DATA_DESC)) {
+                        if (se_cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) {
+                                /*
+                                 * Map se_mem list to scatterlist, so that
+                                 * DDP can be setup. DDP setup function require
+                                 * scatterlist. se_mem_list is internal to
+                                 * TCM/LIO target
+                                 */
+                                transport_do_task_sg_chain(se_cmd);
+                                cmd->sg = T_TASK(se_cmd)->t_tasks_sg_chained;
+                                cmd->sg_cnt =
+                                        T_TASK(se_cmd)->t_tasks_sg_chained_no;
+                        }
+                        if (cmd->sg && lport->tt.ddp_setup(lport, ep->xid,
+                                                    cmd->sg, cmd->sg_cnt))
+                                cmd->was_ddp_setup = 1;
+                }
+        }
+        lport->tt.seq_send(lport, cmd->seq, fp);
+        return 0;
+}
+
+u32 ft_get_task_tag(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+
+        return fc_seq_exch(cmd->seq)->rxid;
+}
+
+int ft_get_cmd_state(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+
+        return cmd->state;
+}
+
+int ft_is_state_remove(struct se_cmd *se_cmd)
+{
+        return 0;       /* XXX TBD */
+}
+
+void ft_new_cmd_failure(struct se_cmd *se_cmd)
+{
+        /* XXX TBD */
+        printk(KERN_INFO "%s: se_cmd %p\n", __func__, se_cmd);
+}
+
+/*
+ * FC sequence response handler for follow-on sequences (data) and aborts.
+ */
+static void ft_recv_seq(struct fc_seq *sp, struct fc_frame *fp, void *arg)
+{
+        struct ft_cmd *cmd = arg;
+        struct fc_frame_header *fh;
+
+        if (IS_ERR(fp)) {
+                /* XXX need to find cmd if queued */
+                cmd->se_cmd.t_state = TRANSPORT_REMOVE;
+                cmd->seq = NULL;
+                transport_generic_free_cmd(&cmd->se_cmd, 0, 1, 0);
+                return;
+        }
+
+        fh = fc_frame_header_get(fp);
+
+        switch (fh->fh_r_ctl) {
+        case FC_RCTL_DD_SOL_DATA:       /* write data */
+                ft_recv_write_data(cmd, fp);
+                break;
+        case FC_RCTL_DD_UNSOL_CTL:      /* command */
+        case FC_RCTL_DD_SOL_CTL:        /* transfer ready */
+        case FC_RCTL_DD_DATA_DESC:      /* transfer ready */
+        default:
+                printk(KERN_INFO "%s: unhandled frame r_ctl %x\n",
+                       __func__, fh->fh_r_ctl);
+                fc_frame_free(fp);
+                transport_generic_free_cmd(&cmd->se_cmd, 0, 1, 0);
+                break;
+        }
+}
+
+/*
+ * Send a FCP response including SCSI status and optional FCP rsp_code.
+ * status is SAM_STAT_GOOD (zero) iff code is valid.
+ * This is used in error cases, such as allocation failures.
+ */
+static void ft_send_resp_status(struct fc_lport *lport,
+                                const struct fc_frame *rx_fp,
+                                u32 status, enum fcp_resp_rsp_codes code)
+{
+        struct fc_frame *fp;
+        struct fc_seq *sp;
+        const struct fc_frame_header *fh;
+        size_t len;
+        struct fcp_resp_with_ext *fcp;
+        struct fcp_resp_rsp_info *info;
+
+        fh = fc_frame_header_get(rx_fp);
+        FT_IO_DBG("FCP error response: did %x oxid %x status %x code %x\n",
+                  ntoh24(fh->fh_s_id), ntohs(fh->fh_ox_id), status, code);
+        len = sizeof(*fcp);
+        if (status == SAM_STAT_GOOD)
+                len += sizeof(*info);
+        fp = fc_frame_alloc(lport, len);
+        if (!fp)
+                return;
+        fcp = fc_frame_payload_get(fp, len);
+        memset(fcp, 0, len);
+        fcp->resp.fr_status = status;
+        if (status == SAM_STAT_GOOD) {
+                fcp->ext.fr_rsp_len = htonl(sizeof(*info));
+                fcp->resp.fr_flags |= FCP_RSP_LEN_VAL;
+                info = (struct fcp_resp_rsp_info *)(fcp + 1);
+                info->rsp_code = code;
+        }
+
+        fc_fill_reply_hdr(fp, rx_fp, FC_RCTL_DD_CMD_STATUS, 0);
+        sp = fr_seq(fp);
+        if (sp)
+                lport->tt.seq_send(lport, sp, fp);
+        else
+                lport->tt.frame_send(lport, fp);
+}
+
+/*
+ * Send error or task management response.
+ * Always frees the cmd and associated state.
+ */
+static void ft_send_resp_code(struct ft_cmd *cmd, enum fcp_resp_rsp_codes code)
+{
+        ft_send_resp_status(cmd->sess->tport->lport,
+                            cmd->req_frame, SAM_STAT_GOOD, code);
+        ft_free_cmd(cmd);
+}
+
+/*
+ * Handle Task Management Request.
+ */
+static void ft_send_tm(struct ft_cmd *cmd)
+{
+        struct se_tmr_req *tmr;
+        struct fcp_cmnd *fcp;
+        u8 tm_func;
+
+        fcp = fc_frame_payload_get(cmd->req_frame, sizeof(*fcp));
+
+        switch (fcp->fc_tm_flags) {
+        case FCP_TMF_LUN_RESET:
+                tm_func = TMR_LUN_RESET;
+                if (ft_get_lun_for_cmd(cmd, fcp->fc_lun) < 0) {
+                        ft_dump_cmd(cmd, __func__);
+                        transport_send_check_condition_and_sense(&cmd->se_cmd,
+                                cmd->se_cmd.scsi_sense_reason, 0);
+                        ft_sess_put(cmd->sess);
+                        return;
+                }
+                break;
+        case FCP_TMF_TGT_RESET:
+                tm_func = TMR_TARGET_WARM_RESET;
+                break;
+        case FCP_TMF_CLR_TASK_SET:
+                tm_func = TMR_CLEAR_TASK_SET;
+                break;
+        case FCP_TMF_ABT_TASK_SET:
+                tm_func = TMR_ABORT_TASK_SET;
+                break;
+        case FCP_TMF_CLR_ACA:
+                tm_func = TMR_CLEAR_ACA;
+                break;
+        default:
+                /*
+                 * FCP4r01 indicates having a combination of
+                 * tm_flags set is invalid.
+                 */
+                FT_TM_DBG("invalid FCP tm_flags %x\n", fcp->fc_tm_flags);
+                ft_send_resp_code(cmd, FCP_CMND_FIELDS_INVALID);
+                return;
+        }
+
+        FT_TM_DBG("alloc tm cmd fn %d\n", tm_func);
+        tmr = core_tmr_alloc_req(&cmd->se_cmd, cmd, tm_func);
+        if (!tmr) {
+                FT_TM_DBG("alloc failed\n");
+                ft_send_resp_code(cmd, FCP_TMF_FAILED);
+                return;
+        }
+        cmd->se_cmd.se_tmr_req = tmr;
+        transport_generic_handle_tmr(&cmd->se_cmd);
+}
+
+/*
+ * Send status from completed task management request.
+ */
+int ft_queue_tm_resp(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+        struct se_tmr_req *tmr = se_cmd->se_tmr_req;
+        enum fcp_resp_rsp_codes code;
+
+        switch (tmr->response) {
+        case TMR_FUNCTION_COMPLETE:
+                code = FCP_TMF_CMPL;
+                break;
+        case TMR_LUN_DOES_NOT_EXIST:
+                code = FCP_TMF_INVALID_LUN;
+                break;
+        case TMR_FUNCTION_REJECTED:
+                code = FCP_TMF_REJECTED;
+                break;
+        case TMR_TASK_DOES_NOT_EXIST:
+        case TMR_TASK_STILL_ALLEGIANT:
+        case TMR_TASK_FAILOVER_NOT_SUPPORTED:
+        case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED:
+        case TMR_FUNCTION_AUTHORIZATION_FAILED:
+        default:
+                code = FCP_TMF_FAILED;
+                break;
+        }
+        FT_TM_DBG("tmr fn %d resp %d fcp code %d\n",
+                  tmr->function, tmr->response, code);
+        ft_send_resp_code(cmd, code);
+        return 0;
+}
+
+/*
+ * Handle incoming FCP command.
+ */
+static void ft_recv_cmd(struct ft_sess *sess, struct fc_frame *fp)
+{
+        struct ft_cmd *cmd;
+        struct fc_lport *lport = sess->tport->lport;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC);
+        if (!cmd)
+                goto busy;
+        cmd->sess = sess;
+        cmd->seq = lport->tt.seq_assign(lport, fp);
+        if (!cmd->seq) {
+                kfree(cmd);
+                goto busy;
+        }
+        cmd->req_frame = fp;            /* hold frame during cmd */
+        ft_queue_cmd(sess, cmd);
+        return;
+
+busy:
+        FT_IO_DBG("cmd or seq allocation failure - sending BUSY\n");
+        ft_send_resp_status(lport, fp, SAM_STAT_BUSY, 0);
+        fc_frame_free(fp);
+        ft_sess_put(sess);              /* undo get from lookup */
+}
+
+
+/*
+ * Handle incoming FCP frame.
+ * Caller has verified that the frame is type FCP.
+ */
+void ft_recv_req(struct ft_sess *sess, struct fc_frame *fp)
+{
+        struct fc_frame_header *fh = fc_frame_header_get(fp);
+
+        switch (fh->fh_r_ctl) {
+        case FC_RCTL_DD_UNSOL_CMD:      /* command */
+                ft_recv_cmd(sess, fp);
+                break;
+        case FC_RCTL_DD_SOL_DATA:       /* write data */
+        case FC_RCTL_DD_UNSOL_CTL:
+        case FC_RCTL_DD_SOL_CTL:
+        case FC_RCTL_DD_DATA_DESC:      /* transfer ready */
+        case FC_RCTL_ELS4_REQ:          /* SRR, perhaps */
+        default:
+                printk(KERN_INFO "%s: unhandled frame r_ctl %x\n",
+                       __func__, fh->fh_r_ctl);
+                fc_frame_free(fp);
+                ft_sess_put(sess);      /* undo get from lookup */
+                break;
+        }
+}
+
+/*
+ * Send new command to target.
+ */
+static void ft_send_cmd(struct ft_cmd *cmd)
+{
+        struct fc_frame_header *fh = fc_frame_header_get(cmd->req_frame);
+        struct se_cmd *se_cmd;
+        struct fcp_cmnd *fcp;
+        int data_dir;
+        u32 data_len;
+        int task_attr;
+        int ret;
+
+        fcp = fc_frame_payload_get(cmd->req_frame, sizeof(*fcp));
+        if (!fcp)
+                goto err;
+
+        if (fcp->fc_flags & FCP_CFL_LEN_MASK)
+                goto err;               /* not handling longer CDBs yet */
+
+        if (fcp->fc_tm_flags) {
+                task_attr = FCP_PTA_SIMPLE;
+                data_dir = DMA_NONE;
+                data_len = 0;
+        } else {
+                switch (fcp->fc_flags & (FCP_CFL_RDDATA | FCP_CFL_WRDATA)) {
+                case 0:
+                        data_dir = DMA_NONE;
+                        break;
+                case FCP_CFL_RDDATA:
+                        data_dir = DMA_FROM_DEVICE;
+                        break;
+                case FCP_CFL_WRDATA:
+                        data_dir = DMA_TO_DEVICE;
+                        break;
+                case FCP_CFL_WRDATA | FCP_CFL_RDDATA:
+                        goto err;       /* TBD not supported by tcm_fc yet */
+                }
+
+                /* FCP_PTA_ maps 1:1 to TASK_ATTR_ */
+                task_attr = fcp->fc_pri_ta & FCP_PTA_MASK;
+                data_len = ntohl(fcp->fc_dl);
+                cmd->cdb = fcp->fc_cdb;
+        }
+
+        se_cmd = &cmd->se_cmd;
+        /*
+         * Initialize struct se_cmd descriptor from target_core_mod
+         * infrastructure
+         */
+        transport_init_se_cmd(se_cmd, &ft_configfs->tf_ops, cmd->sess->se_sess,
+                              data_len, data_dir, task_attr,
+                              &cmd->ft_sense_buffer[0]);
+        /*
+         * Check for FCP task management flags
+         */
+        if (fcp->fc_tm_flags) {
+                ft_send_tm(cmd);
+                return;
+        }
+
+        fc_seq_exch(cmd->seq)->lp->tt.seq_set_resp(cmd->seq, ft_recv_seq, cmd);
+
+        ret = ft_get_lun_for_cmd(cmd, fcp->fc_lun);
+        if (ret < 0) {
+                ft_dump_cmd(cmd, __func__);
+                transport_send_check_condition_and_sense(&cmd->se_cmd,
+                        cmd->se_cmd.scsi_sense_reason, 0);
+                return;
+        }
+
+        ret = transport_generic_allocate_tasks(se_cmd, cmd->cdb);
+
+        FT_IO_DBG("r_ctl %x alloc task ret %d\n", fh->fh_r_ctl, ret);
+        ft_dump_cmd(cmd, __func__);
+
+        if (ret == -1) {
+                transport_send_check_condition_and_sense(se_cmd,
+                                TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE, 0);
+                transport_generic_free_cmd(se_cmd, 0, 1, 0);
+                return;
+        }
+        if (ret == -2) {
+                if (se_cmd->se_cmd_flags & SCF_SCSI_RESERVATION_CONFLICT)
+                        ft_queue_status(se_cmd);
+                else
+                        transport_send_check_condition_and_sense(se_cmd,
+                                        se_cmd->scsi_sense_reason, 0);
+                transport_generic_free_cmd(se_cmd, 0, 1, 0);
+                return;
+        }
+        transport_generic_handle_cdb(se_cmd);
+        return;
+
+err:
+        ft_send_resp_code(cmd, FCP_CMND_FIELDS_INVALID);
+        return;
+}
+
+/*
+ * Handle request in the command thread.
+ */
+static void ft_exec_req(struct ft_cmd *cmd)
+{
+        FT_IO_DBG("cmd state %x\n", cmd->state);
+        switch (cmd->state) {
+        case FC_CMD_ST_NEW:
+                ft_send_cmd(cmd);
+                break;
+        default:
+                break;
+        }
+}
+
+/*
+ * Processing thread.
+ * Currently one thread per tpg.
+ */
+int ft_thread(void *arg)
+{
+        struct ft_tpg *tpg = arg;
+        struct se_queue_obj *qobj = &tpg->qobj;
+        struct ft_cmd *cmd;
+        int ret;
+
+        set_user_nice(current, -20);
+
+        while (!kthread_should_stop()) {
+                ret = wait_event_interruptible(qobj->thread_wq,
+                        atomic_read(&qobj->queue_cnt) || kthread_should_stop());
+                if (ret < 0 || kthread_should_stop())
+                        goto out;
+                cmd = ft_dequeue_cmd(qobj);
+                if (cmd)
+                        ft_exec_req(cmd);
+        }
+
+out:
+        return 0;
+}
diff --git a/drivers/target/tcm_fc/tfc_conf.c b/drivers/target/tcm_fc/tfc_conf.c
new file mode 100644
index 000000000000..fcdbbffe88cc
--- /dev/null
+++ b/drivers/target/tcm_fc/tfc_conf.c
@@ -0,0 +1,677 @@
+/*******************************************************************************
+ * Filename:  tcm_fc.c
+ *
+ * This file contains the configfs implementation for TCM_fc fabric node.
+ * Based on tcm_loop_configfs.c
+ *
+ * Copyright (c) 2010 Cisco Systems, Inc.
+ * Copyright (c) 2009,2010 Rising Tide, Inc.
+ * Copyright (c) 2009,2010 Linux-iSCSI.org
+ *
+ * Copyright (c) 2009,2010 Nicholas A. Bellinger <nab@linux-iscsi.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ ****************************************************************************/
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/version.h>
+#include <generated/utsrelease.h>
+#include <linux/utsname.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/kthread.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/configfs.h>
+#include <linux/ctype.h>
+#include <asm/unaligned.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/libfc.h>
+
+#include <target/target_core_base.h>
+#include <target/target_core_transport.h>
+#include <target/target_core_fabric_ops.h>
+#include <target/target_core_fabric_configfs.h>
+#include <target/target_core_fabric_lib.h>
+#include <target/target_core_device.h>
+#include <target/target_core_tpg.h>
+#include <target/target_core_configfs.h>
+#include <target/target_core_base.h>
+#include <target/configfs_macros.h>
+
+#include "tcm_fc.h"
+
+struct target_fabric_configfs *ft_configfs;
+
+LIST_HEAD(ft_lport_list);
+DEFINE_MUTEX(ft_lport_lock);
+
+unsigned int ft_debug_logging;
+module_param_named(debug_logging, ft_debug_logging, int, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
+
+/*
+ * Parse WWN.
+ * If strict, we require lower-case hex and colon separators to be sure
+ * the name is the same as what would be generated by ft_format_wwn()
+ * so the name and wwn are mapped one-to-one.
+ */
+static ssize_t ft_parse_wwn(const char *name, u64 *wwn, int strict)
+{
+        const char *cp;
+        char c;
+        u32 nibble;
+        u32 byte = 0;
+        u32 pos = 0;
+        u32 err;
+
+        *wwn = 0;
+        for (cp = name; cp < &name[FT_NAMELEN - 1]; cp++) {
+                c = *cp;
+                if (c == '\n' && cp[1] == '\0')
+                        continue;
+                if (strict && pos++ == 2 && byte++ < 7) {
+                        pos = 0;
+                        if (c == ':')
+                                continue;
+                        err = 1;
+                        goto fail;
+                }
+                if (c == '\0') {
+                        err = 2;
+                        if (strict && byte != 8)
+                                goto fail;
+                        return cp - name;
+                }
+                err = 3;
+                if (isdigit(c))
+                        nibble = c - '0';
+                else if (isxdigit(c) && (islower(c) || !strict))
+                        nibble = tolower(c) - 'a' + 10;
+                else
+                        goto fail;
+                *wwn = (*wwn << 4) | nibble;
+        }
+        err = 4;
+fail:
+        FT_CONF_DBG("err %u len %zu pos %u byte %u\n",
+                    err, cp - name, pos, byte);
+        return -1;
+}
+
+ssize_t ft_format_wwn(char *buf, size_t len, u64 wwn)
+{
+        u8 b[8];
+
+        put_unaligned_be64(wwn, b);
+        return snprintf(buf, len,
+                 "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x",
+                 b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]);
+}
+
+static ssize_t ft_wwn_show(void *arg, char *buf)
+{
+        u64 *wwn = arg;
+        ssize_t len;
+
+        len = ft_format_wwn(buf, PAGE_SIZE - 2, *wwn);
+        buf[len++] = '\n';
+        return len;
+}
+
+static ssize_t ft_wwn_store(void *arg, const char *buf, size_t len)
+{
+        ssize_t ret;
+        u64 wwn;
+
+        ret = ft_parse_wwn(buf, &wwn, 0);
+        if (ret > 0)
+                *(u64 *)arg = wwn;
+        return ret;
+}
+
+/*
+ * ACL auth ops.
+ */
+
+static ssize_t ft_nacl_show_port_name(
+        struct se_node_acl *se_nacl,
+        char *page)
+{
+        struct ft_node_acl *acl = container_of(se_nacl,
+                        struct ft_node_acl, se_node_acl);
+
+        return ft_wwn_show(&acl->node_auth.port_name, page);
+}
+
+static ssize_t ft_nacl_store_port_name(
+        struct se_node_acl *se_nacl,
+        const char *page,
+        size_t count)
+{
+        struct ft_node_acl *acl = container_of(se_nacl,
+                        struct ft_node_acl, se_node_acl);
+
+        return ft_wwn_store(&acl->node_auth.port_name, page, count);
+}
+
+TF_NACL_BASE_ATTR(ft, port_name, S_IRUGO | S_IWUSR);
+
+static ssize_t ft_nacl_show_node_name(
+        struct se_node_acl *se_nacl,
+        char *page)
+{
+        struct ft_node_acl *acl = container_of(se_nacl,
+                        struct ft_node_acl, se_node_acl);
+
+        return ft_wwn_show(&acl->node_auth.node_name, page);
+}
+
+static ssize_t ft_nacl_store_node_name(
+        struct se_node_acl *se_nacl,
+        const char *page,
+        size_t count)
+{
+        struct ft_node_acl *acl = container_of(se_nacl,
+                        struct ft_node_acl, se_node_acl);
+
+        return ft_wwn_store(&acl->node_auth.node_name, page, count);
+}
+
+TF_NACL_BASE_ATTR(ft, node_name, S_IRUGO | S_IWUSR);
+
+static struct configfs_attribute *ft_nacl_base_attrs[] = {
+        &ft_nacl_port_name.attr,
+        &ft_nacl_node_name.attr,
+        NULL,
+};
+
+/*
+ * ACL ops.
+ */
+
+/*
+ * Add ACL for an initiator.  The ACL is named arbitrarily.
+ * The port_name and/or node_name are attributes.
+ */
+static struct se_node_acl *ft_add_acl(
+        struct se_portal_group *se_tpg,
+        struct config_group *group,
+        const char *name)
+{
+        struct ft_node_acl *acl;
+        struct ft_tpg *tpg;
+        u64 wwpn;
+        u32 q_depth;
+
+        FT_CONF_DBG("add acl %s\n", name);
+        tpg = container_of(se_tpg, struct ft_tpg, se_tpg);
+
+        if (ft_parse_wwn(name, &wwpn, 1) < 0)
+                return ERR_PTR(-EINVAL);
+
+        acl = kzalloc(sizeof(struct ft_node_acl), GFP_KERNEL);
+        if (!(acl))
+                return ERR_PTR(-ENOMEM);
+        acl->node_auth.port_name = wwpn;
+
+        q_depth = 32;           /* XXX bogus default - get from tpg? */
+        return core_tpg_add_initiator_node_acl(&tpg->se_tpg,
+                                &acl->se_node_acl, name, q_depth);
+}
+
+static void ft_del_acl(struct se_node_acl *se_acl)
+{
+        struct se_portal_group *se_tpg = se_acl->se_tpg;
+        struct ft_tpg *tpg;
+        struct ft_node_acl *acl = container_of(se_acl,
+                                struct ft_node_acl, se_node_acl);
+
+        FT_CONF_DBG("del acl %s\n",
+                config_item_name(&se_acl->acl_group.cg_item));
+
+        tpg = container_of(se_tpg, struct ft_tpg, se_tpg);
+        FT_CONF_DBG("del acl %p se_acl %p tpg %p se_tpg %p\n",
+                    acl, se_acl, tpg, &tpg->se_tpg);
+
+        core_tpg_del_initiator_node_acl(&tpg->se_tpg, se_acl, 1);
+        kfree(acl);
+}
+
+struct ft_node_acl *ft_acl_get(struct ft_tpg *tpg, struct fc_rport_priv *rdata)
+{
+        struct ft_node_acl *found = NULL;
+        struct ft_node_acl *acl;
+        struct se_portal_group *se_tpg = &tpg->se_tpg;
+        struct se_node_acl *se_acl;
+
+        spin_lock_bh(&se_tpg->acl_node_lock);
+        list_for_each_entry(se_acl, &se_tpg->acl_node_list, acl_list) {
+                acl = container_of(se_acl, struct ft_node_acl, se_node_acl);
+                FT_CONF_DBG("acl %p port_name %llx\n",
+                        acl, (unsigned long long)acl->node_auth.port_name);
+                if (acl->node_auth.port_name == rdata->ids.port_name ||
+                    acl->node_auth.node_name == rdata->ids.node_name) {
+                        FT_CONF_DBG("acl %p port_name %llx matched\n", acl,
+                                    (unsigned long long)rdata->ids.port_name);
+                        found = acl;
+                        /* XXX need to hold onto ACL */
+                        break;
+                }
+        }
+        spin_unlock_bh(&se_tpg->acl_node_lock);
+        return found;
+}
+
+struct se_node_acl *ft_tpg_alloc_fabric_acl(struct se_portal_group *se_tpg)
+{
+        struct ft_node_acl *acl;
+
+        acl = kzalloc(sizeof(*acl), GFP_KERNEL);
+        if (!(acl)) {
+                printk(KERN_ERR "Unable to allocate struct ft_node_acl\n");
+                return NULL;
+        }
+        FT_CONF_DBG("acl %p\n", acl);
+        return &acl->se_node_acl;
+}
+
+static void ft_tpg_release_fabric_acl(struct se_portal_group *se_tpg,
+                                      struct se_node_acl *se_acl)
+{
+        struct ft_node_acl *acl = container_of(se_acl,
+                                struct ft_node_acl, se_node_acl);
+
+        FT_CONF_DBG(KERN_INFO "acl %p\n", acl);
+        kfree(acl);
+}
+
+/*
+ * local_port port_group (tpg) ops.
+ */
+static struct se_portal_group *ft_add_tpg(
+        struct se_wwn *wwn,
+        struct config_group *group,
+        const char *name)
+{
+        struct ft_lport_acl *lacl;
+        struct ft_tpg *tpg;
+        unsigned long index;
+        int ret;
+
+        FT_CONF_DBG("tcm_fc: add tpg %s\n", name);
+
+        /*
+         * Name must be "tpgt_" followed by the index.
+         */
+        if (strstr(name, "tpgt_") != name)
+                return NULL;
+        if (strict_strtoul(name + 5, 10, &index) || index > UINT_MAX)
+                return NULL;
+
+        lacl = container_of(wwn, struct ft_lport_acl, fc_lport_wwn);
+        tpg = kzalloc(sizeof(*tpg), GFP_KERNEL);
+        if (!tpg)
+                return NULL;
+        tpg->index = index;
+        tpg->lport_acl = lacl;
+        INIT_LIST_HEAD(&tpg->lun_list);
+        transport_init_queue_obj(&tpg->qobj);
+
+        ret = core_tpg_register(&ft_configfs->tf_ops, wwn, &tpg->se_tpg,
+                                (void *)tpg, TRANSPORT_TPG_TYPE_NORMAL);
+        if (ret < 0) {
+                kfree(tpg);
+                return NULL;
+        }
+
+        tpg->thread = kthread_run(ft_thread, tpg, "ft_tpg%lu", index);
+        if (IS_ERR(tpg->thread)) {
+                kfree(tpg);
+                return NULL;
+        }
+
+        mutex_lock(&ft_lport_lock);
+        list_add_tail(&tpg->list, &lacl->tpg_list);
+        mutex_unlock(&ft_lport_lock);
+
+        return &tpg->se_tpg;
+}
+
+static void ft_del_tpg(struct se_portal_group *se_tpg)
+{
+        struct ft_tpg *tpg = container_of(se_tpg, struct ft_tpg, se_tpg);
+
+        FT_CONF_DBG("del tpg %s\n",
+                    config_item_name(&tpg->se_tpg.tpg_group.cg_item));
+
+        kthread_stop(tpg->thread);
+
+        /* Wait for sessions to be freed thru RCU, for BUG_ON below */
+        synchronize_rcu();
+
+        mutex_lock(&ft_lport_lock);
+        list_del(&tpg->list);
+        if (tpg->tport) {
+                tpg->tport->tpg = NULL;
+                tpg->tport = NULL;
+        }
+        mutex_unlock(&ft_lport_lock);
+
+        core_tpg_deregister(se_tpg);
+        kfree(tpg);
+}
+
+/*
+ * Verify that an lport is configured to use the tcm_fc module, and return
+ * the target port group that should be used.
+ *
+ * The caller holds ft_lport_lock.
+ */
+struct ft_tpg *ft_lport_find_tpg(struct fc_lport *lport)
+{
+        struct ft_lport_acl *lacl;
+        struct ft_tpg *tpg;
+
+        list_for_each_entry(lacl, &ft_lport_list, list) {
+                if (lacl->wwpn == lport->wwpn) {
+                        list_for_each_entry(tpg, &lacl->tpg_list, list)
+                                return tpg; /* XXX for now return first entry */
+                        return NULL;
+                }
+        }
+        return NULL;
+}
+
+/*
+ * target config instance ops.
+ */
+
+/*
+ * Add lport to allowed config.
+ * The name is the WWPN in lower-case ASCII, colon-separated bytes.
+ */
+static struct se_wwn *ft_add_lport(
+        struct target_fabric_configfs *tf,
+        struct config_group *group,
+        const char *name)
+{
+        struct ft_lport_acl *lacl;
+        struct ft_lport_acl *old_lacl;
+        u64 wwpn;
+
+        FT_CONF_DBG("add lport %s\n", name);
+        if (ft_parse_wwn(name, &wwpn, 1) < 0)
+                return NULL;
+        lacl = kzalloc(sizeof(*lacl), GFP_KERNEL);
+        if (!lacl)
+                return NULL;
+        lacl->wwpn = wwpn;
+        INIT_LIST_HEAD(&lacl->tpg_list);
+
+        mutex_lock(&ft_lport_lock);
+        list_for_each_entry(old_lacl, &ft_lport_list, list) {
+                if (old_lacl->wwpn == wwpn) {
+                        mutex_unlock(&ft_lport_lock);
+                        kfree(lacl);
+                        return NULL;
+                }
+        }
+        list_add_tail(&lacl->list, &ft_lport_list);
+        ft_format_wwn(lacl->name, sizeof(lacl->name), wwpn);
+        mutex_unlock(&ft_lport_lock);
+
+        return &lacl->fc_lport_wwn;
+}
+
+static void ft_del_lport(struct se_wwn *wwn)
+{
+        struct ft_lport_acl *lacl = container_of(wwn,
+                                struct ft_lport_acl, fc_lport_wwn);
+
+        FT_CONF_DBG("del lport %s\n",
+                        config_item_name(&wwn->wwn_group.cg_item));
+        mutex_lock(&ft_lport_lock);
+        list_del(&lacl->list);
+        mutex_unlock(&ft_lport_lock);
+
+        kfree(lacl);
+}
+
+static ssize_t ft_wwn_show_attr_version(
+        struct target_fabric_configfs *tf,
+        char *page)
+{
+        return sprintf(page, "TCM FC " FT_VERSION " on %s/%s on "
+                ""UTS_RELEASE"\n",  utsname()->sysname, utsname()->machine);
+}
+
+TF_WWN_ATTR_RO(ft, version);
+
+static struct configfs_attribute *ft_wwn_attrs[] = {
+        &ft_wwn_version.attr,
+        NULL,
+};
+
+static char *ft_get_fabric_name(void)
+{
+        return "fc";
+}
+
+static char *ft_get_fabric_wwn(struct se_portal_group *se_tpg)
+{
+        struct ft_tpg *tpg = se_tpg->se_tpg_fabric_ptr;
+
+        return tpg->lport_acl->name;
+}
+
+static u16 ft_get_tag(struct se_portal_group *se_tpg)
+{
+        struct ft_tpg *tpg = se_tpg->se_tpg_fabric_ptr;
+
+        /*
+         * This tag is used when forming SCSI Name identifier in EVPD=1 0x83
+         * to represent the SCSI Target Port.
+         */
+        return tpg->index;
+}
+
+static u32 ft_get_default_depth(struct se_portal_group *se_tpg)
+{
+        return 1;
+}
+
+static int ft_check_false(struct se_portal_group *se_tpg)
+{
+        return 0;
+}
+
+static void ft_set_default_node_attr(struct se_node_acl *se_nacl)
+{
+}
+
+static u16 ft_get_fabric_sense_len(void)
+{
+        return 0;
+}
+
+static u16 ft_set_fabric_sense_len(struct se_cmd *se_cmd, u32 sense_len)
+{
+        return 0;
+}
+
+static u32 ft_tpg_get_inst_index(struct se_portal_group *se_tpg)
+{
+        struct ft_tpg *tpg = se_tpg->se_tpg_fabric_ptr;
+
+        return tpg->index;
+}
+
+static u64 ft_pack_lun(unsigned int index)
+{
+        WARN_ON(index >= 256);
+        /* Caller wants this byte-swapped */
+        return cpu_to_le64((index & 0xff) << 8);
+}
+
+static struct target_core_fabric_ops ft_fabric_ops = {
+        .get_fabric_name =              ft_get_fabric_name,
+        .get_fabric_proto_ident =       fc_get_fabric_proto_ident,
+        .tpg_get_wwn =                  ft_get_fabric_wwn,
+        .tpg_get_tag =                  ft_get_tag,
+        .tpg_get_default_depth =        ft_get_default_depth,
+        .tpg_get_pr_transport_id =      fc_get_pr_transport_id,
+        .tpg_get_pr_transport_id_len =  fc_get_pr_transport_id_len,
+        .tpg_parse_pr_out_transport_id = fc_parse_pr_out_transport_id,
+        .tpg_check_demo_mode =          ft_check_false,
+        .tpg_check_demo_mode_cache =    ft_check_false,
+        .tpg_check_demo_mode_write_protect = ft_check_false,
+        .tpg_check_prod_mode_write_protect = ft_check_false,
+        .tpg_alloc_fabric_acl =         ft_tpg_alloc_fabric_acl,
+        .tpg_release_fabric_acl =       ft_tpg_release_fabric_acl,
+        .tpg_get_inst_index =           ft_tpg_get_inst_index,
+        .check_stop_free =              ft_check_stop_free,
+        .release_cmd_to_pool =          ft_release_cmd,
+        .release_cmd_direct =           ft_release_cmd,
+        .shutdown_session =             ft_sess_shutdown,
+        .close_session =                ft_sess_close,
+        .stop_session =                 ft_sess_stop,
+        .fall_back_to_erl0 =            ft_sess_set_erl0,
+        .sess_logged_in =               ft_sess_logged_in,
+        .sess_get_index =               ft_sess_get_index,
+        .sess_get_initiator_sid =       NULL,
+        .write_pending =                ft_write_pending,
+        .write_pending_status =         ft_write_pending_status,
+        .set_default_node_attributes =  ft_set_default_node_attr,
+        .get_task_tag =                 ft_get_task_tag,
+        .get_cmd_state =                ft_get_cmd_state,
+        .new_cmd_failure =              ft_new_cmd_failure,
+        .queue_data_in =                ft_queue_data_in,
+        .queue_status =                 ft_queue_status,
+        .queue_tm_rsp =                 ft_queue_tm_resp,
+        .get_fabric_sense_len =         ft_get_fabric_sense_len,
+        .set_fabric_sense_len =         ft_set_fabric_sense_len,
+        .is_state_remove =              ft_is_state_remove,
+        .pack_lun =                     ft_pack_lun,
+        /*
+         * Setup function pointers for generic logic in
+         * target_core_fabric_configfs.c
+         */
+        .fabric_make_wwn =              &ft_add_lport,
+        .fabric_drop_wwn =              &ft_del_lport,
+        .fabric_make_tpg =              &ft_add_tpg,
+        .fabric_drop_tpg =              &ft_del_tpg,
+        .fabric_post_link =             NULL,
+        .fabric_pre_unlink =            NULL,
+        .fabric_make_np =               NULL,
+        .fabric_drop_np =               NULL,
+        .fabric_make_nodeacl =          &ft_add_acl,
+        .fabric_drop_nodeacl =          &ft_del_acl,
+};
+
+int ft_register_configfs(void)
+{
+        struct target_fabric_configfs *fabric;
+        int ret;
+
+        /*
+         * Register the top level struct config_item_type with TCM core
+         */
+        fabric = target_fabric_configfs_init(THIS_MODULE, "fc");
+        if (!fabric) {
+                printk(KERN_INFO "%s: target_fabric_configfs_init() failed!\n",
+                       __func__);
+                return -1;
+        }
+        fabric->tf_ops = ft_fabric_ops;
+
+        /* Allowing support for task_sg_chaining */
+        fabric->tf_ops.task_sg_chaining = 1;
+
+        /*
+         * Setup default attribute lists for various fabric->tf_cit_tmpl
+         */
+        TF_CIT_TMPL(fabric)->tfc_wwn_cit.ct_attrs = ft_wwn_attrs;
+        TF_CIT_TMPL(fabric)->tfc_tpg_base_cit.ct_attrs = NULL;
+        TF_CIT_TMPL(fabric)->tfc_tpg_attrib_cit.ct_attrs = NULL;
+        TF_CIT_TMPL(fabric)->tfc_tpg_param_cit.ct_attrs = NULL;
+        TF_CIT_TMPL(fabric)->tfc_tpg_np_base_cit.ct_attrs = NULL;
+        TF_CIT_TMPL(fabric)->tfc_tpg_nacl_base_cit.ct_attrs =
+                                                    ft_nacl_base_attrs;
+        TF_CIT_TMPL(fabric)->tfc_tpg_nacl_attrib_cit.ct_attrs = NULL;
+        TF_CIT_TMPL(fabric)->tfc_tpg_nacl_auth_cit.ct_attrs = NULL;
+        TF_CIT_TMPL(fabric)->tfc_tpg_nacl_param_cit.ct_attrs = NULL;
+        /*
+         * register the fabric for use within TCM
+         */
+        ret = target_fabric_configfs_register(fabric);
+        if (ret < 0) {
+                FT_CONF_DBG("target_fabric_configfs_register() for"
+                            " FC Target failed!\n");
+                printk(KERN_INFO
+                       "%s: target_fabric_configfs_register() failed!\n",
+                       __func__);
+                target_fabric_configfs_free(fabric);
+                return -1;
+        }
+
+        /*
+         * Setup our local pointer to *fabric.
+         */
+        ft_configfs = fabric;
+        return 0;
+}
+
+void ft_deregister_configfs(void)
+{
+        if (!ft_configfs)
+                return;
+        target_fabric_configfs_deregister(ft_configfs);
+        ft_configfs = NULL;
+}
+
+static struct notifier_block ft_notifier = {
+        .notifier_call = ft_lport_notify
+};
+
+static int __init ft_init(void)
+{
+        if (ft_register_configfs())
+                return -1;
+        if (fc_fc4_register_provider(FC_TYPE_FCP, &ft_prov)) {
+                ft_deregister_configfs();
+                return -1;
+        }
+        blocking_notifier_chain_register(&fc_lport_notifier_head, &ft_notifier);
+        fc_lport_iterate(ft_lport_add, NULL);
+        return 0;
+}
+
+static void __exit ft_exit(void)
+{
+        blocking_notifier_chain_unregister(&fc_lport_notifier_head,
+                                           &ft_notifier);
+        fc_fc4_deregister_provider(FC_TYPE_FCP, &ft_prov);
+        fc_lport_iterate(ft_lport_del, NULL);
+        ft_deregister_configfs();
+        synchronize_rcu();
+}
+
+#ifdef MODULE
+MODULE_DESCRIPTION("FC TCM fabric driver " FT_VERSION);
+MODULE_LICENSE("GPL");
+module_init(ft_init);
+module_exit(ft_exit);
+#endif /* MODULE */
diff --git a/drivers/target/tcm_fc/tfc_io.c b/drivers/target/tcm_fc/tfc_io.c
new file mode 100644
index 000000000000..4c3c0efbe13f
--- /dev/null
+++ b/drivers/target/tcm_fc/tfc_io.c
@@ -0,0 +1,374 @@
+/*
+ * Copyright (c) 2010 Cisco Systems, Inc.
+ *
+ * Portions based on tcm_loop_fabric_scsi.c and libfc/fc_fcp.c
+ *
+ * Copyright (c) 2007 Intel Corporation. All rights reserved.
+ * Copyright (c) 2008 Red Hat, Inc.  All rights reserved.
+ * Copyright (c) 2008 Mike Christie
+ * Copyright (c) 2009 Rising Tide, Inc.
+ * Copyright (c) 2009 Linux-iSCSI.org
+ * Copyright (c) 2009 Nicholas A. Bellinger <nab@linux-iscsi.org>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/* XXX TBD some includes may be extraneous */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/version.h>
+#include <generated/utsrelease.h>
+#include <linux/utsname.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/kthread.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/configfs.h>
+#include <linux/ctype.h>
+#include <linux/hash.h>
+#include <asm/unaligned.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/libfc.h>
+#include <scsi/fc_encode.h>
+
+#include <target/target_core_base.h>
+#include <target/target_core_transport.h>
+#include <target/target_core_fabric_ops.h>
+#include <target/target_core_device.h>
+#include <target/target_core_tpg.h>
+#include <target/target_core_configfs.h>
+#include <target/target_core_base.h>
+#include <target/configfs_macros.h>
+
+#include "tcm_fc.h"
+
+/*
+ * Deliver read data back to initiator.
+ * XXX TBD handle resource problems later.
+ */
+int ft_queue_data_in(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+        struct se_transport_task *task;
+        struct fc_frame *fp = NULL;
+        struct fc_exch *ep;
+        struct fc_lport *lport;
+        struct se_mem *mem;
+        size_t remaining;
+        u32 f_ctl = FC_FC_EX_CTX | FC_FC_REL_OFF;
+        u32 mem_off;
+        u32 fh_off = 0;
+        u32 frame_off = 0;
+        size_t frame_len = 0;
+        size_t mem_len;
+        size_t tlen;
+        size_t off_in_page;
+        struct page *page;
+        int use_sg;
+        int error;
+        void *page_addr;
+        void *from;
+        void *to = NULL;
+
+        ep = fc_seq_exch(cmd->seq);
+        lport = ep->lp;
+        cmd->seq = lport->tt.seq_start_next(cmd->seq);
+
+        task = T_TASK(se_cmd);
+        BUG_ON(!task);
+        remaining = se_cmd->data_length;
+
+        /*
+         * Setup to use first mem list entry if any.
+         */
+        if (task->t_tasks_se_num) {
+                mem = list_first_entry(task->t_mem_list,
+                         struct se_mem, se_list);
+                mem_len = mem->se_len;
+                mem_off = mem->se_off;
+                page = mem->se_page;
+        } else {
+                mem = NULL;
+                mem_len = remaining;
+                mem_off = 0;
+                page = NULL;
+        }
+
+        /* no scatter/gather in skb for odd word length due to fc_seq_send() */
+        use_sg = !(remaining % 4);
+
+        while (remaining) {
+                if (!mem_len) {
+                        BUG_ON(!mem);
+                        mem = list_entry(mem->se_list.next,
+                                struct se_mem, se_list);
+                        mem_len = min((size_t)mem->se_len, remaining);
+                        mem_off = mem->se_off;
+                        page = mem->se_page;
+                }
+                if (!frame_len) {
+                        /*
+                         * If lport's has capability of Large Send Offload LSO)
+                         * , then allow 'frame_len' to be as big as 'lso_max'
+                         * if indicated transfer length is >= lport->lso_max
+                         */
+                        frame_len = (lport->seq_offload) ? lport->lso_max :
+                                                          cmd->sess->max_frame;
+                        frame_len = min(frame_len, remaining);
+                        fp = fc_frame_alloc(lport, use_sg ? 0 : frame_len);
+                        if (!fp)
+                                return -ENOMEM;
+                        to = fc_frame_payload_get(fp, 0);
+                        fh_off = frame_off;
+                        frame_off += frame_len;
+                        /*
+                         * Setup the frame's max payload which is used by base
+                         * driver to indicate HW about max frame size, so that
+                         * HW can do fragmentation appropriately based on
+                         * "gso_max_size" of underline netdev.
+                         */
+                        fr_max_payload(fp) = cmd->sess->max_frame;
+                }
+                tlen = min(mem_len, frame_len);
+
+                if (use_sg) {
+                        if (!mem) {
+                                BUG_ON(!task->t_task_buf);
+                                page_addr = task->t_task_buf + mem_off;
+                                /*
+                                 * In this case, offset is 'offset_in_page' of
+                                 * (t_task_buf + mem_off) instead of 'mem_off'.
+                                 */
+                                off_in_page = offset_in_page(page_addr);
+                                page = virt_to_page(page_addr);
+                                tlen = min(tlen, PAGE_SIZE - off_in_page);
+                        } else
+                                off_in_page = mem_off;
+                        BUG_ON(!page);
+                        get_page(page);
+                        skb_fill_page_desc(fp_skb(fp),
+                                           skb_shinfo(fp_skb(fp))->nr_frags,
+                                           page, off_in_page, tlen);
+                        fr_len(fp) += tlen;
+                        fp_skb(fp)->data_len += tlen;
+                        fp_skb(fp)->truesize +=
+                                        PAGE_SIZE << compound_order(page);
+                } else if (mem) {
+                        BUG_ON(!page);
+                        from = kmap_atomic(page + (mem_off >> PAGE_SHIFT),
+                                           KM_SOFTIRQ0);
+                        page_addr = from;
+                        from += mem_off & ~PAGE_MASK;
+                        tlen = min(tlen, (size_t)(PAGE_SIZE -
+                                                (mem_off & ~PAGE_MASK)));
+                        memcpy(to, from, tlen);
+                        kunmap_atomic(page_addr, KM_SOFTIRQ0);
+                        to += tlen;
+                } else {
+                        from = task->t_task_buf + mem_off;
+                        memcpy(to, from, tlen);
+                        to += tlen;
+                }
+
+                mem_off += tlen;
+                mem_len -= tlen;
+                frame_len -= tlen;
+                remaining -= tlen;
+
+                if (frame_len &&
+                    (skb_shinfo(fp_skb(fp))->nr_frags < FC_FRAME_SG_LEN))
+                        continue;
+                if (!remaining)
+                        f_ctl |= FC_FC_END_SEQ;
+                fc_fill_fc_hdr(fp, FC_RCTL_DD_SOL_DATA, ep->did, ep->sid,
+                               FC_TYPE_FCP, f_ctl, fh_off);
+                error = lport->tt.seq_send(lport, cmd->seq, fp);
+                if (error) {
+                        /* XXX For now, initiator will retry */
+                        if (printk_ratelimit())
+                                printk(KERN_ERR "%s: Failed to send frame %p, "
+                                                "xid <0x%x>, remaining <0x%x>, "
+                                                "lso_max <0x%x>\n",
+                                                __func__, fp, ep->xid,
+                                                remaining, lport->lso_max);
+                }
+        }
+        return ft_queue_status(se_cmd);
+}
+
+/*
+ * Receive write data frame.
+ */
+void ft_recv_write_data(struct ft_cmd *cmd, struct fc_frame *fp)
+{
+        struct se_cmd *se_cmd = &cmd->se_cmd;
+        struct fc_seq *seq = cmd->seq;
+        struct fc_exch *ep;
+        struct fc_lport *lport;
+        struct se_transport_task *task;
+        struct fc_frame_header *fh;
+        struct se_mem *mem;
+        u32 mem_off;
+        u32 rel_off;
+        size_t frame_len;
+        size_t mem_len;
+        size_t tlen;
+        struct page *page;
+        void *page_addr;
+        void *from;
+        void *to;
+        u32 f_ctl;
+        void *buf;
+
+        task = T_TASK(se_cmd);
+        BUG_ON(!task);
+
+        fh = fc_frame_header_get(fp);
+        if (!(ntoh24(fh->fh_f_ctl) & FC_FC_REL_OFF))
+                goto drop;
+
+        /*
+         * Doesn't expect even single byte of payload. Payload
+         * is expected to be copied directly to user buffers
+         * due to DDP (Large Rx offload) feature, hence
+         * BUG_ON if BUF is non-NULL
+         */
+        buf = fc_frame_payload_get(fp, 1);
+        if (cmd->was_ddp_setup && buf) {
+                printk(KERN_INFO "%s: When DDP was setup, not expected to"
+                                 "receive frame with payload, Payload shall be"
+                                 "copied directly to buffer instead of coming "
+                                 "via. legacy receive queues\n", __func__);
+                BUG_ON(buf);
+        }
+
+        /*
+         * If ft_cmd indicated 'ddp_setup', in that case only the last frame
+         * should come with 'TSI bit being set'. If 'TSI bit is not set and if
+         * data frame appears here, means error condition. In both the cases
+         * release the DDP context (ddp_put) and in error case, as well
+         * initiate error recovery mechanism.
+         */
+        ep = fc_seq_exch(seq);
+        if (cmd->was_ddp_setup) {
+                BUG_ON(!ep);
+                lport = ep->lp;
+                BUG_ON(!lport);
+        }
+        if (cmd->was_ddp_setup && ep->xid != FC_XID_UNKNOWN) {
+                f_ctl = ntoh24(fh->fh_f_ctl);
+                /*
+                 * If TSI bit set in f_ctl, means last write data frame is
+                 * received successfully where payload is posted directly
+                 * to user buffer and only the last frame's header is posted
+                 * in legacy receive queue
+                 */
+                if (f_ctl & FC_FC_SEQ_INIT) { /* TSI bit set in FC frame */
+                        cmd->write_data_len = lport->tt.ddp_done(lport,
+                                                                ep->xid);
+                        goto last_frame;
+                } else {
+                        /*
+                         * Updating the write_data_len may be meaningless at
+                         * this point, but just in case if required in future
+                         * for debugging or any other purpose
+                         */
+                        printk(KERN_ERR "%s: Received frame with TSI bit not"
+                                        " being SET, dropping the frame, "
+                                        "cmd->sg <%p>, cmd->sg_cnt <0x%x>\n",
+                                        __func__, cmd->sg, cmd->sg_cnt);
+                        cmd->write_data_len = lport->tt.ddp_done(lport,
+                                                              ep->xid);
+                        lport->tt.seq_exch_abort(cmd->seq, 0);
+                        goto drop;
+                }
+        }
+
+        rel_off = ntohl(fh->fh_parm_offset);
+        frame_len = fr_len(fp);
+        if (frame_len <= sizeof(*fh))
+                goto drop;
+        frame_len -= sizeof(*fh);
+        from = fc_frame_payload_get(fp, 0);
+        if (rel_off >= se_cmd->data_length)
+                goto drop;
+        if (frame_len + rel_off > se_cmd->data_length)
+                frame_len = se_cmd->data_length - rel_off;
+
+        /*
+         * Setup to use first mem list entry if any.
+         */
+        if (task->t_tasks_se_num) {
+                mem = list_first_entry(task->t_mem_list,
+                                       struct se_mem, se_list);
+                mem_len = mem->se_len;
+                mem_off = mem->se_off;
+                page = mem->se_page;
+        } else {
+                mem = NULL;
+                page = NULL;
+                mem_off = 0;
+                mem_len = frame_len;
+        }
+
+        while (frame_len) {
+                if (!mem_len) {
+                        BUG_ON(!mem);
+                        mem = list_entry(mem->se_list.next,
+                                         struct se_mem, se_list);
+                        mem_len = mem->se_len;
+                        mem_off = mem->se_off;
+                        page = mem->se_page;
+                }
+                if (rel_off >= mem_len) {
+                        rel_off -= mem_len;
+                        mem_len = 0;
+                        continue;
+                }
+                mem_off += rel_off;
+                mem_len -= rel_off;
+                rel_off = 0;
+
+                tlen = min(mem_len, frame_len);
+
+                if (mem) {
+                        to = kmap_atomic(page + (mem_off >> PAGE_SHIFT),
+                                         KM_SOFTIRQ0);
+                        page_addr = to;
+                        to += mem_off & ~PAGE_MASK;
+                        tlen = min(tlen, (size_t)(PAGE_SIZE -
+                                                (mem_off & ~PAGE_MASK)));
+                        memcpy(to, from, tlen);
+                        kunmap_atomic(page_addr, KM_SOFTIRQ0);
+                } else {
+                        to = task->t_task_buf + mem_off;
+                        memcpy(to, from, tlen);
+                }
+                from += tlen;
+                frame_len -= tlen;
+                mem_off += tlen;
+                mem_len -= tlen;
+                cmd->write_data_len += tlen;
+        }
+last_frame:
+        if (cmd->write_data_len == se_cmd->data_length)
+                transport_generic_handle_data(se_cmd);
+drop:
+        fc_frame_free(fp);
+}
diff --git a/drivers/target/tcm_fc/tfc_sess.c b/drivers/target/tcm_fc/tfc_sess.c
new file mode 100644
index 000000000000..a3bd57f2ea32
--- /dev/null
+++ b/drivers/target/tcm_fc/tfc_sess.c
@@ -0,0 +1,541 @@
+/*
+ * Copyright (c) 2010 Cisco Systems, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/* XXX TBD some includes may be extraneous */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/version.h>
+#include <generated/utsrelease.h>
+#include <linux/utsname.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/kthread.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/configfs.h>
+#include <linux/ctype.h>
+#include <linux/hash.h>
+#include <linux/rcupdate.h>
+#include <linux/rculist.h>
+#include <linux/kref.h>
+#include <asm/unaligned.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/libfc.h>
+
+#include <target/target_core_base.h>
+#include <target/target_core_transport.h>
+#include <target/target_core_fabric_ops.h>
+#include <target/target_core_device.h>
+#include <target/target_core_tpg.h>
+#include <target/target_core_configfs.h>
+#include <target/target_core_base.h>
+#include <target/configfs_macros.h>
+
+#include <scsi/libfc.h>
+#include "tcm_fc.h"
+
+static void ft_sess_delete_all(struct ft_tport *);
+
+/*
+ * Lookup or allocate target local port.
+ * Caller holds ft_lport_lock.
+ */
+static struct ft_tport *ft_tport_create(struct fc_lport *lport)
+{
+        struct ft_tpg *tpg;
+        struct ft_tport *tport;
+        int i;
+
+        tport = rcu_dereference(lport->prov[FC_TYPE_FCP]);
+        if (tport && tport->tpg)
+                return tport;
+
+        tpg = ft_lport_find_tpg(lport);
+        if (!tpg)
+                return NULL;
+
+        if (tport) {
+                tport->tpg = tpg;
+                return tport;
+        }
+
+        tport = kzalloc(sizeof(*tport), GFP_KERNEL);
+        if (!tport)
+                return NULL;
+
+        tport->lport = lport;
+        tport->tpg = tpg;
+        tpg->tport = tport;
+        for (i = 0; i < FT_SESS_HASH_SIZE; i++)
+                INIT_HLIST_HEAD(&tport->hash[i]);
+
+        rcu_assign_pointer(lport->prov[FC_TYPE_FCP], tport);
+        return tport;
+}
+
+/*
+ * Free tport via RCU.
+ */
+static void ft_tport_rcu_free(struct rcu_head *rcu)
+{
+        struct ft_tport *tport = container_of(rcu, struct ft_tport, rcu);
+
+        kfree(tport);
+}
+
+/*
+ * Delete a target local port.
+ * Caller holds ft_lport_lock.
+ */
+static void ft_tport_delete(struct ft_tport *tport)
+{
+        struct fc_lport *lport;
+        struct ft_tpg *tpg;
+
+        ft_sess_delete_all(tport);
+        lport = tport->lport;
+        BUG_ON(tport != lport->prov[FC_TYPE_FCP]);
+        rcu_assign_pointer(lport->prov[FC_TYPE_FCP], NULL);
+
+        tpg = tport->tpg;
+        if (tpg) {
+                tpg->tport = NULL;
+                tport->tpg = NULL;
+        }
+        call_rcu(&tport->rcu, ft_tport_rcu_free);
+}
+
+/*
+ * Add local port.
+ * Called thru fc_lport_iterate().
+ */
+void ft_lport_add(struct fc_lport *lport, void *arg)
+{
+        mutex_lock(&ft_lport_lock);
+        ft_tport_create(lport);
+        mutex_unlock(&ft_lport_lock);
+}
+
+/*
+ * Delete local port.
+ * Called thru fc_lport_iterate().
+ */
+void ft_lport_del(struct fc_lport *lport, void *arg)
+{
+        struct ft_tport *tport;
+
+        mutex_lock(&ft_lport_lock);
+        tport = lport->prov[FC_TYPE_FCP];
+        if (tport)
+                ft_tport_delete(tport);
+        mutex_unlock(&ft_lport_lock);
+}
+
+/*
+ * Notification of local port change from libfc.
+ * Create or delete local port and associated tport.
+ */
+int ft_lport_notify(struct notifier_block *nb, unsigned long event, void *arg)
+{
+        struct fc_lport *lport = arg;
+
+        switch (event) {
+        case FC_LPORT_EV_ADD:
+                ft_lport_add(lport, NULL);
+                break;
+        case FC_LPORT_EV_DEL:
+                ft_lport_del(lport, NULL);
+                break;
+        }
+        return NOTIFY_DONE;
+}
+
+/*
+ * Hash function for FC_IDs.
+ */
+static u32 ft_sess_hash(u32 port_id)
+{
+        return hash_32(port_id, FT_SESS_HASH_BITS);
+}
+
+/*
+ * Find session in local port.
+ * Sessions and hash lists are RCU-protected.
+ * A reference is taken which must be eventually freed.
+ */
+static struct ft_sess *ft_sess_get(struct fc_lport *lport, u32 port_id)
+{
+        struct ft_tport *tport;
+        struct hlist_head *head;
+        struct hlist_node *pos;
+        struct ft_sess *sess;
+
+        rcu_read_lock();
+        tport = rcu_dereference(lport->prov[FC_TYPE_FCP]);
+        if (!tport)
+                goto out;
+
+        head = &tport->hash[ft_sess_hash(port_id)];
+        hlist_for_each_entry_rcu(sess, pos, head, hash) {
+                if (sess->port_id == port_id) {
+                        kref_get(&sess->kref);
+                        rcu_read_unlock();
+                        FT_SESS_DBG("port_id %x found %p\n", port_id, sess);
+                        return sess;
+                }
+        }
+out:
+        rcu_read_unlock();
+        FT_SESS_DBG("port_id %x not found\n", port_id);
+        return NULL;
+}
+
+/*
+ * Allocate session and enter it in the hash for the local port.
+ * Caller holds ft_lport_lock.
+ */
+static struct ft_sess *ft_sess_create(struct ft_tport *tport, u32 port_id,
+                                      struct ft_node_acl *acl)
+{
+        struct ft_sess *sess;
+        struct hlist_head *head;
+        struct hlist_node *pos;
+
+        head = &tport->hash[ft_sess_hash(port_id)];
+        hlist_for_each_entry_rcu(sess, pos, head, hash)
+                if (sess->port_id == port_id)
+                        return sess;
+
+        sess = kzalloc(sizeof(*sess), GFP_KERNEL);
+        if (!sess)
+                return NULL;
+
+        sess->se_sess = transport_init_session();
+        if (!sess->se_sess) {
+                kfree(sess);
+                return NULL;
+        }
+        sess->se_sess->se_node_acl = &acl->se_node_acl;
+        sess->tport = tport;
+        sess->port_id = port_id;
+        kref_init(&sess->kref); /* ref for table entry */
+        hlist_add_head_rcu(&sess->hash, head);
+        tport->sess_count++;
+
+        FT_SESS_DBG("port_id %x sess %p\n", port_id, sess);
+
+        transport_register_session(&tport->tpg->se_tpg, &acl->se_node_acl,
+                                   sess->se_sess, sess);
+        return sess;
+}
+
+/*
+ * Unhash the session.
+ * Caller holds ft_lport_lock.
+ */
+static void ft_sess_unhash(struct ft_sess *sess)
+{
+        struct ft_tport *tport = sess->tport;
+
+        hlist_del_rcu(&sess->hash);
+        BUG_ON(!tport->sess_count);
+        tport->sess_count--;
+        sess->port_id = -1;
+        sess->params = 0;
+}
+
+/*
+ * Delete session from hash.
+ * Caller holds ft_lport_lock.
+ */
+static struct ft_sess *ft_sess_delete(struct ft_tport *tport, u32 port_id)
+{
+        struct hlist_head *head;
+        struct hlist_node *pos;
+        struct ft_sess *sess;
+
+        head = &tport->hash[ft_sess_hash(port_id)];
+        hlist_for_each_entry_rcu(sess, pos, head, hash) {
+                if (sess->port_id == port_id) {
+                        ft_sess_unhash(sess);
+                        return sess;
+                }
+        }
+        return NULL;
+}
+
+/*
+ * Delete all sessions from tport.
+ * Caller holds ft_lport_lock.
+ */
+static void ft_sess_delete_all(struct ft_tport *tport)
+{
+        struct hlist_head *head;
+        struct hlist_node *pos;
+        struct ft_sess *sess;
+
+        for (head = tport->hash;
+             head < &tport->hash[FT_SESS_HASH_SIZE]; head++) {
+                hlist_for_each_entry_rcu(sess, pos, head, hash) {
+                        ft_sess_unhash(sess);
+                        transport_deregister_session_configfs(sess->se_sess);
+                        ft_sess_put(sess);      /* release from table */
+                }
+        }
+}
+
+/*
+ * TCM ops for sessions.
+ */
+
+/*
+ * Determine whether session is allowed to be shutdown in the current context.
+ * Returns non-zero if the session should be shutdown.
+ */
+int ft_sess_shutdown(struct se_session *se_sess)
+{
+        struct ft_sess *sess = se_sess->fabric_sess_ptr;
+
+        FT_SESS_DBG("port_id %x\n", sess->port_id);
+        return 1;
+}
+
+/*
+ * Remove session and send PRLO.
+ * This is called when the ACL is being deleted or queue depth is changing.
+ */
+void ft_sess_close(struct se_session *se_sess)
+{
+        struct ft_sess *sess = se_sess->fabric_sess_ptr;
+        struct fc_lport *lport;
+        u32 port_id;
+
+        mutex_lock(&ft_lport_lock);
+        lport = sess->tport->lport;
+        port_id = sess->port_id;
+        if (port_id == -1) {
+                mutex_lock(&ft_lport_lock);
+                return;
+        }
+        FT_SESS_DBG("port_id %x\n", port_id);
+        ft_sess_unhash(sess);
+        mutex_unlock(&ft_lport_lock);
+        transport_deregister_session_configfs(se_sess);
+        ft_sess_put(sess);
+        /* XXX Send LOGO or PRLO */
+        synchronize_rcu();              /* let transport deregister happen */
+}
+
+void ft_sess_stop(struct se_session *se_sess, int sess_sleep, int conn_sleep)
+{
+        struct ft_sess *sess = se_sess->fabric_sess_ptr;
+
+        FT_SESS_DBG("port_id %x\n", sess->port_id);
+}
+
+int ft_sess_logged_in(struct se_session *se_sess)
+{
+        struct ft_sess *sess = se_sess->fabric_sess_ptr;
+
+        return sess->port_id != -1;
+}
+
+u32 ft_sess_get_index(struct se_session *se_sess)
+{
+        struct ft_sess *sess = se_sess->fabric_sess_ptr;
+
+        return sess->port_id;   /* XXX TBD probably not what is needed */
+}
+
+u32 ft_sess_get_port_name(struct se_session *se_sess,
+                          unsigned char *buf, u32 len)
+{
+        struct ft_sess *sess = se_sess->fabric_sess_ptr;
+
+        return ft_format_wwn(buf, len, sess->port_name);
+}
+
+void ft_sess_set_erl0(struct se_session *se_sess)
+{
+        /* XXX TBD called when out of memory */
+}
+
+/*
+ * libfc ops involving sessions.
+ */
+
+static int ft_prli_locked(struct fc_rport_priv *rdata, u32 spp_len,
+                          const struct fc_els_spp *rspp, struct fc_els_spp *spp)
+{
+        struct ft_tport *tport;
+        struct ft_sess *sess;
+        struct ft_node_acl *acl;
+        u32 fcp_parm;
+
+        tport = ft_tport_create(rdata->local_port);
+        if (!tport)
+                return 0;       /* not a target for this local port */
+
+        acl = ft_acl_get(tport->tpg, rdata);
+        if (!acl)
+                return 0;
+
+        if (!rspp)
+                goto fill;
+
+        if (rspp->spp_flags & (FC_SPP_OPA_VAL | FC_SPP_RPA_VAL))
+                return FC_SPP_RESP_NO_PA;
+
+        /*
+         * If both target and initiator bits are off, the SPP is invalid.
+         */
+        fcp_parm = ntohl(rspp->spp_params);
+        if (!(fcp_parm & (FCP_SPPF_INIT_FCN | FCP_SPPF_TARG_FCN)))
+                return FC_SPP_RESP_INVL;
+
+        /*
+         * Create session (image pair) only if requested by
+         * EST_IMG_PAIR flag and if the requestor is an initiator.
+         */
+        if (rspp->spp_flags & FC_SPP_EST_IMG_PAIR) {
+                spp->spp_flags |= FC_SPP_EST_IMG_PAIR;
+                if (!(fcp_parm & FCP_SPPF_INIT_FCN))
+                        return FC_SPP_RESP_CONF;
+                sess = ft_sess_create(tport, rdata->ids.port_id, acl);
+                if (!sess)
+                        return FC_SPP_RESP_RES;
+                if (!sess->params)
+                        rdata->prli_count++;
+                sess->params = fcp_parm;
+                sess->port_name = rdata->ids.port_name;
+                sess->max_frame = rdata->maxframe_size;
+
+                /* XXX TBD - clearing actions.  unit attn, see 4.10 */
+        }
+
+        /*
+         * OR in our service parameters with other provider (initiator), if any.
+         * TBD XXX - indicate RETRY capability?
+         */
+fill:
+        fcp_parm = ntohl(spp->spp_params);
+        spp->spp_params = htonl(fcp_parm | FCP_SPPF_TARG_FCN);
+        return FC_SPP_RESP_ACK;
+}
+
+/**
+ * tcm_fcp_prli() - Handle incoming or outgoing PRLI for the FCP target
+ * @rdata: remote port private
+ * @spp_len: service parameter page length
+ * @rspp: received service parameter page (NULL for outgoing PRLI)
+ * @spp: response service parameter page
+ *
+ * Returns spp response code.
+ */
+static int ft_prli(struct fc_rport_priv *rdata, u32 spp_len,
+                   const struct fc_els_spp *rspp, struct fc_els_spp *spp)
+{
+        int ret;
+
+        mutex_lock(&ft_lport_lock);
+        ret = ft_prli_locked(rdata, spp_len, rspp, spp);
+        mutex_unlock(&ft_lport_lock);
+        FT_SESS_DBG("port_id %x flags %x ret %x\n",
+               rdata->ids.port_id, rspp ? rspp->spp_flags : 0, ret);
+        return ret;
+}
+
+static void ft_sess_rcu_free(struct rcu_head *rcu)
+{
+        struct ft_sess *sess = container_of(rcu, struct ft_sess, rcu);
+
+        transport_deregister_session(sess->se_sess);
+        kfree(sess);
+}
+
+static void ft_sess_free(struct kref *kref)
+{
+        struct ft_sess *sess = container_of(kref, struct ft_sess, kref);
+
+        call_rcu(&sess->rcu, ft_sess_rcu_free);
+}
+
+void ft_sess_put(struct ft_sess *sess)
+{
+        int sess_held = atomic_read(&sess->kref.refcount);
+
+        BUG_ON(!sess_held);
+        kref_put(&sess->kref, ft_sess_free);
+}
+
+static void ft_prlo(struct fc_rport_priv *rdata)
+{
+        struct ft_sess *sess;
+        struct ft_tport *tport;
+
+        mutex_lock(&ft_lport_lock);
+        tport = rcu_dereference(rdata->local_port->prov[FC_TYPE_FCP]);
+        if (!tport) {
+                mutex_unlock(&ft_lport_lock);
+                return;
+        }
+        sess = ft_sess_delete(tport, rdata->ids.port_id);
+        if (!sess) {
+                mutex_unlock(&ft_lport_lock);
+                return;
+        }
+        mutex_unlock(&ft_lport_lock);
+        transport_deregister_session_configfs(sess->se_sess);
+        ft_sess_put(sess);              /* release from table */
+        rdata->prli_count--;
+        /* XXX TBD - clearing actions.  unit attn, see 4.10 */
+}
+
+/*
+ * Handle incoming FCP request.
+ * Caller has verified that the frame is type FCP.
+ */
+static void ft_recv(struct fc_lport *lport, struct fc_frame *fp)
+{
+        struct ft_sess *sess;
+        u32 sid = fc_frame_sid(fp);
+
+        FT_SESS_DBG("sid %x\n", sid);
+
+        sess = ft_sess_get(lport, sid);
+        if (!sess) {
+                FT_SESS_DBG("sid %x sess lookup failed\n", sid);
+                /* TBD XXX - if FCP_CMND, send PRLO */
+                fc_frame_free(fp);
+                return;
+        }
+        ft_recv_req(sess, fp);  /* must do ft_sess_put() */
+}
+
+/*
+ * Provider ops for libfc.
+ */
+struct fc4_prov ft_prov = {
+        .prli = ft_prli,
+        .prlo = ft_prlo,
+        .recv = ft_recv,
+        .module = THIS_MODULE,
+};
diff --git a/drivers/usb/storage/isd200.c b/drivers/usb/storage/isd200.c
index 09e52ba47ddf..ffc4193e9505 100644
--- a/drivers/usb/storage/isd200.c
+++ b/drivers/usb/storage/isd200.c
@@ -499,7 +499,6 @@ static int isd200_action( struct us_data *us, int action,
         memset(&ata, 0, sizeof(ata));
         srb->cmnd = info->cmnd;
         srb->device = &srb_dev;
-        ++srb->serial_number;
 
         ata.generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
         ata.generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;