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

394 files changed, 46243 insertions, 11664 deletions

diff --git a/drivers/scsi/3w-9xxx.c b/drivers/scsi/3w-9xxx.c
index 36c21b19e5d7..e9788f55ab13 100644
--- a/drivers/scsi/3w-9xxx.c
+++ b/drivers/scsi/3w-9xxx.c
@@ -76,6 +76,7 @@
                  Fix bug in twa_get_param() on 4GB+.
                  Use pci_resource_len() for ioremap().
    2.26.02.012 - Add power management support.
+   2.26.02.013 - Fix bug in twa_load_sgl().
 */
 
 #include <linux/module.h>
@@ -90,6 +91,7 @@
 #include <linux/time.h>
 #include <linux/mutex.h>
 #include <linux/smp_lock.h>
+#include <linux/slab.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/uaccess.h>
@@ -100,7 +102,7 @@
 #include "3w-9xxx.h"
 
 /* Globals */
-#define TW_DRIVER_VERSION "2.26.02.012"
+#define TW_DRIVER_VERSION "2.26.02.013"
 static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT];
 static unsigned int twa_device_extension_count;
 static int twa_major = -1;
@@ -186,8 +188,12 @@ static ssize_t twa_show_stats(struct device *dev,
 } /* End twa_show_stats() */
 
 /* This function will set a devices queue depth */
-static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth)
+static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth,
+                                  int reason)
 {
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
         if (queue_depth > TW_Q_LENGTH-2)
                 queue_depth = TW_Q_LENGTH-2;
         scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
@@ -732,7 +738,7 @@ static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int
                 break;
         case TW_IOCTL_GET_COMPATIBILITY_INFO:
                 tw_ioctl->driver_command.status = 0;
-                /* Copy compatiblity struct into ioctl data buffer */
+                /* Copy compatibility struct into ioctl data buffer */
                 tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer;
                 memcpy(tw_compat_info, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
                 break;
@@ -1378,10 +1384,12 @@ static void twa_load_sgl(TW_Device_Extension *tw_dev, TW_Command_Full *full_comm
                 newcommand = &full_command_packet->command.newcommand;
                 newcommand->request_id__lunl =
                         cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
-                newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
-                newcommand->sg_list[0].length = cpu_to_le32(length);
+                if (length) {
+                        newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
+                        newcommand->sg_list[0].length = cpu_to_le32(length);
+                }
                 newcommand->sgl_entries__lunh =
-                        cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), 1));
+                        cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), length ? 1 : 0));
         } else {
                 oldcommand = &full_command_packet->command.oldcommand;
                 oldcommand->request_id = request_id;
diff --git a/drivers/scsi/3w-sas.c b/drivers/scsi/3w-sas.c
new file mode 100644
index 000000000000..54c5ffb1eaa1
--- /dev/null
+++ b/drivers/scsi/3w-sas.c
@@ -0,0 +1,1925 @@
+/*
+   3w-sas.c -- LSI 3ware SAS/SATA-RAID Controller device driver for Linux.
+
+   Written By: Adam Radford <linuxraid@lsi.com>
+
+   Copyright (C) 2009 LSI Corporation.
+
+   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; version 2 of the License.
+
+   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.
+
+   NO WARRANTY
+   THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
+   LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+   solely responsible for determining the appropriateness of using and
+   distributing the Program and assumes all risks associated with its
+   exercise of rights under this Agreement, including but not limited to
+   the risks and costs of program errors, damage to or loss of data,
+   programs or equipment, and unavailability or interruption of operations.
+
+   DISCLAIMER OF LIABILITY
+   NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
+   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
+   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+   TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+   USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+   HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
+
+   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+   Controllers supported by this driver:
+
+   LSI 3ware 9750 6Gb/s SAS/SATA-RAID
+
+   Bugs/Comments/Suggestions should be mailed to:
+   linuxraid@lsi.com
+
+   For more information, goto:
+   http://www.lsi.com
+
+   History
+   -------
+   3.26.02.000 - Initial driver release.
+*/
+
+#include <linux/module.h>
+#include <linux/reboot.h>
+#include <linux/spinlock.h>
+#include <linux/interrupt.h>
+#include <linux/moduleparam.h>
+#include <linux/errno.h>
+#include <linux/types.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+#include <linux/time.h>
+#include <linux/mutex.h>
+#include <linux/smp_lock.h>
+#include <linux/slab.h>
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_tcq.h>
+#include <scsi/scsi_cmnd.h>
+#include "3w-sas.h"
+
+/* Globals */
+#define TW_DRIVER_VERSION "3.26.02.000"
+static TW_Device_Extension *twl_device_extension_list[TW_MAX_SLOT];
+static unsigned int twl_device_extension_count;
+static int twl_major = -1;
+extern struct timezone sys_tz;
+
+/* Module parameters */
+MODULE_AUTHOR ("LSI");
+MODULE_DESCRIPTION ("LSI 3ware SAS/SATA-RAID Linux Driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(TW_DRIVER_VERSION);
+
+static int use_msi;
+module_param(use_msi, int, S_IRUGO);
+MODULE_PARM_DESC(use_msi, "Use Message Signaled Interrupts. Default: 0");
+
+/* Function prototypes */
+static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset);
+
+/* Functions */
+
+/* This function returns AENs through sysfs */
+static ssize_t twl_sysfs_aen_read(struct kobject *kobj,
+                                  struct bin_attribute *bin_attr,
+                                  char *outbuf, loff_t offset, size_t count)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct Scsi_Host *shost = class_to_shost(dev);
+        TW_Device_Extension *tw_dev = (TW_Device_Extension *)shost->hostdata;
+        unsigned long flags = 0;
+        ssize_t ret;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+
+        spin_lock_irqsave(tw_dev->host->host_lock, flags);
+        ret = memory_read_from_buffer(outbuf, count, &offset, tw_dev->event_queue[0], sizeof(TW_Event) * TW_Q_LENGTH);
+        spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
+
+        return ret;
+} /* End twl_sysfs_aen_read() */
+
+/* aen_read sysfs attribute initializer */
+static struct bin_attribute twl_sysfs_aen_read_attr = {
+        .attr = {
+                .name = "3ware_aen_read",
+                .mode = S_IRUSR,
+        }, 
+        .size = 0,
+        .read = twl_sysfs_aen_read
+};
+
+/* This function returns driver compatibility info through sysfs */
+static ssize_t twl_sysfs_compat_info(struct kobject *kobj,
+                                     struct bin_attribute *bin_attr,
+                                     char *outbuf, loff_t offset, size_t count)
+{
+        struct device *dev = container_of(kobj, struct device, kobj);
+        struct Scsi_Host *shost = class_to_shost(dev);
+        TW_Device_Extension *tw_dev = (TW_Device_Extension *)shost->hostdata;
+        unsigned long flags = 0;
+        ssize_t ret;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+
+        spin_lock_irqsave(tw_dev->host->host_lock, flags);
+        ret = memory_read_from_buffer(outbuf, count, &offset, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
+        spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
+
+        return ret;
+} /* End twl_sysfs_compat_info() */
+
+/* compat_info sysfs attribute initializer */
+static struct bin_attribute twl_sysfs_compat_info_attr = {
+        .attr = {
+                .name = "3ware_compat_info",
+                .mode = S_IRUSR,
+        }, 
+        .size = 0,
+        .read = twl_sysfs_compat_info
+};
+
+/* Show some statistics about the card */
+static ssize_t twl_show_stats(struct device *dev,
+                              struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *host = class_to_shost(dev);
+        TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
+        unsigned long flags = 0;
+        ssize_t len;
+
+        spin_lock_irqsave(tw_dev->host->host_lock, flags);
+        len = snprintf(buf, PAGE_SIZE, "3w-sas Driver version: %s\n"
+                       "Current commands posted:   %4d\n"
+                       "Max commands posted:       %4d\n"
+                       "Last sgl length:           %4d\n"
+                       "Max sgl length:            %4d\n"
+                       "Last sector count:         %4d\n"
+                       "Max sector count:          %4d\n"
+                       "SCSI Host Resets:          %4d\n"
+                       "AEN's:                     %4d\n", 
+                       TW_DRIVER_VERSION,
+                       tw_dev->posted_request_count,
+                       tw_dev->max_posted_request_count,
+                       tw_dev->sgl_entries,
+                       tw_dev->max_sgl_entries,
+                       tw_dev->sector_count,
+                       tw_dev->max_sector_count,
+                       tw_dev->num_resets,
+                       tw_dev->aen_count);
+        spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
+        return len;
+} /* End twl_show_stats() */
+
+/* This function will set a devices queue depth */
+static int twl_change_queue_depth(struct scsi_device *sdev, int queue_depth,
+                                  int reason)
+{
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
+        if (queue_depth > TW_Q_LENGTH-2)
+                queue_depth = TW_Q_LENGTH-2;
+        scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
+        return queue_depth;
+} /* End twl_change_queue_depth() */
+
+/* stats sysfs attribute initializer */
+static struct device_attribute twl_host_stats_attr = {
+        .attr = {
+                .name =         "3ware_stats",
+                .mode =         S_IRUGO,
+        },
+        .show = twl_show_stats
+};
+
+/* Host attributes initializer */
+static struct device_attribute *twl_host_attrs[] = {
+        &twl_host_stats_attr,
+        NULL,
+};
+
+/* This function will look up an AEN severity string */
+static char *twl_aen_severity_lookup(unsigned char severity_code)
+{
+        char *retval = NULL;
+
+        if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
+            (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
+                goto out;
+
+        retval = twl_aen_severity_table[severity_code];
+out:
+        return retval;
+} /* End twl_aen_severity_lookup() */
+
+/* This function will queue an event */
+static void twl_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
+{
+        u32 local_time;
+        struct timeval time;
+        TW_Event *event;
+        unsigned short aen;
+        char host[16];
+        char *error_str;
+
+        tw_dev->aen_count++;
+
+        /* Fill out event info */
+        event = tw_dev->event_queue[tw_dev->error_index];
+
+        host[0] = '\0';
+        if (tw_dev->host)
+                sprintf(host, " scsi%d:", tw_dev->host->host_no);
+
+        aen = le16_to_cpu(header->status_block.error);
+        memset(event, 0, sizeof(TW_Event));
+
+        event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
+        do_gettimeofday(&time);
+        local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60));
+        event->time_stamp_sec = local_time;
+        event->aen_code = aen;
+        event->retrieved = TW_AEN_NOT_RETRIEVED;
+        event->sequence_id = tw_dev->error_sequence_id;
+        tw_dev->error_sequence_id++;
+
+        /* Check for embedded error string */
+        error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
+
+        header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
+        event->parameter_len = strlen(header->err_specific_desc);
+        memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + 1 + strlen(error_str));
+        if (event->severity != TW_AEN_SEVERITY_DEBUG)
+                printk(KERN_WARNING "3w-sas:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
+                       host,
+                       twl_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
+                       TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen, error_str,
+                       header->err_specific_desc);
+        else
+                tw_dev->aen_count--;
+
+        tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
+} /* End twl_aen_queue_event() */
+
+/* This function will attempt to post a command packet to the board */
+static int twl_post_command_packet(TW_Device_Extension *tw_dev, int request_id)
+{
+        dma_addr_t command_que_value;
+
+        command_que_value = tw_dev->command_packet_phys[request_id];
+        command_que_value += TW_COMMAND_OFFSET;
+
+        /* First write upper 4 bytes */
+        writel((u32)((u64)command_que_value >> 32), TWL_HIBQPH_REG_ADDR(tw_dev));
+        /* Then the lower 4 bytes */
+        writel((u32)(command_que_value | TWL_PULL_MODE), TWL_HIBQPL_REG_ADDR(tw_dev));
+
+        tw_dev->state[request_id] = TW_S_POSTED;
+        tw_dev->posted_request_count++;
+        if (tw_dev->posted_request_count > tw_dev->max_posted_request_count)
+                tw_dev->max_posted_request_count = tw_dev->posted_request_count;
+
+        return 0;
+} /* End twl_post_command_packet() */
+
+/* This function will perform a pci-dma mapping for a scatter gather list */
+static int twl_map_scsi_sg_data(TW_Device_Extension *tw_dev, int request_id)
+{
+        int use_sg;
+        struct scsi_cmnd *cmd = tw_dev->srb[request_id];
+
+        use_sg = scsi_dma_map(cmd);
+        if (!use_sg)
+                return 0;
+        else if (use_sg < 0) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Failed to map scatter gather list");
+                return 0;
+        }
+
+        cmd->SCp.phase = TW_PHASE_SGLIST;
+        cmd->SCp.have_data_in = use_sg;
+
+        return use_sg;
+} /* End twl_map_scsi_sg_data() */
+
+/* This function hands scsi cdb's to the firmware */
+static int twl_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry_ISO *sglistarg)
+{
+        TW_Command_Full *full_command_packet;
+        TW_Command_Apache *command_packet;
+        int i, sg_count;
+        struct scsi_cmnd *srb = NULL;
+        struct scatterlist *sglist = NULL, *sg;
+        int retval = 1;
+
+        if (tw_dev->srb[request_id]) {
+                srb = tw_dev->srb[request_id];
+                if (scsi_sglist(srb))
+                        sglist = scsi_sglist(srb);
+        }
+
+        /* Initialize command packet */
+        full_command_packet = tw_dev->command_packet_virt[request_id];
+        full_command_packet->header.header_desc.size_header = 128;
+        full_command_packet->header.status_block.error = 0;
+        full_command_packet->header.status_block.severity__reserved = 0;
+
+        command_packet = &full_command_packet->command.newcommand;
+        command_packet->status = 0;
+        command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
+
+        /* We forced 16 byte cdb use earlier */
+        if (!cdb)
+                memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
+        else
+                memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
+
+        if (srb) {
+                command_packet->unit = srb->device->id;
+                command_packet->request_id__lunl =
+                        cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
+        } else {
+                command_packet->request_id__lunl =
+                        cpu_to_le16(TW_REQ_LUN_IN(0, request_id));
+                command_packet->unit = 0;
+        }
+
+        command_packet->sgl_offset = 16;
+
+        if (!sglistarg) {
+                /* Map sglist from scsi layer to cmd packet */
+                if (scsi_sg_count(srb)) {
+                        sg_count = twl_map_scsi_sg_data(tw_dev, request_id);
+                        if (sg_count == 0)
+                                goto out;
+
+                        scsi_for_each_sg(srb, sg, sg_count, i) {
+                                command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg));
+                                command_packet->sg_list[i].length = TW_CPU_TO_SGL(sg_dma_len(sg));
+                        }
+                        command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id])));
+                }
+        } else {
+                /* Internal cdb post */
+                for (i = 0; i < use_sg; i++) {
+                        command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address);
+                        command_packet->sg_list[i].length = TW_CPU_TO_SGL(sglistarg[i].length);
+                }
+                command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg));
+        }
+
+        /* Update some stats */
+        if (srb) {
+                tw_dev->sector_count = scsi_bufflen(srb) / 512;
+                if (tw_dev->sector_count > tw_dev->max_sector_count)
+                        tw_dev->max_sector_count = tw_dev->sector_count;
+                tw_dev->sgl_entries = scsi_sg_count(srb);
+                if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
+                        tw_dev->max_sgl_entries = tw_dev->sgl_entries;
+        }
+
+        /* Now post the command to the board */
+        retval = twl_post_command_packet(tw_dev, request_id);
+
+out:
+        return retval;
+} /* End twl_scsiop_execute_scsi() */
+
+/* This function will read the aen queue from the isr */
+static int twl_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
+{
+        char cdb[TW_MAX_CDB_LEN];
+        TW_SG_Entry_ISO sglist[1];
+        TW_Command_Full *full_command_packet;
+        int retval = 1;
+
+        full_command_packet = tw_dev->command_packet_virt[request_id];
+        memset(full_command_packet, 0, sizeof(TW_Command_Full));
+
+        /* Initialize cdb */
+        memset(&cdb, 0, TW_MAX_CDB_LEN);
+        cdb[0] = REQUEST_SENSE; /* opcode */
+        cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
+
+        /* Initialize sglist */
+        memset(&sglist, 0, sizeof(TW_SG_Entry_ISO));
+        sglist[0].length = TW_SECTOR_SIZE;
+        sglist[0].address = tw_dev->generic_buffer_phys[request_id];
+
+        /* Mark internal command */
+        tw_dev->srb[request_id] = NULL;
+
+        /* Now post the command packet */
+        if (twl_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Post failed while reading AEN queue");
+                goto out;
+        }
+        retval = 0;
+out:
+        return retval;
+} /* End twl_aen_read_queue() */
+
+/* This function will sync firmware time with the host time */
+static void twl_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
+{
+        u32 schedulertime;
+        struct timeval utc;
+        TW_Command_Full *full_command_packet;
+        TW_Command *command_packet;
+        TW_Param_Apache *param;
+        u32 local_time;
+
+        /* Fill out the command packet */
+        full_command_packet = tw_dev->command_packet_virt[request_id];
+        memset(full_command_packet, 0, sizeof(TW_Command_Full));
+        command_packet = &full_command_packet->command.oldcommand;
+        command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
+        command_packet->request_id = request_id;
+        command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
+        command_packet->byte8_offset.param.sgl[0].length = TW_CPU_TO_SGL(TW_SECTOR_SIZE);
+        command_packet->size = TW_COMMAND_SIZE;
+        command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
+
+        /* Setup the param */
+        param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
+        memset(param, 0, TW_SECTOR_SIZE);
+        param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */
+        param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */
+        param->parameter_size_bytes = cpu_to_le16(4);
+
+        /* Convert system time in UTC to local time seconds since last 
+           Sunday 12:00AM */
+        do_gettimeofday(&utc);
+        local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60));
+        schedulertime = local_time - (3 * 86400);
+        schedulertime = cpu_to_le32(schedulertime % 604800);
+
+        memcpy(param->data, &schedulertime, sizeof(u32));
+
+        /* Mark internal command */
+        tw_dev->srb[request_id] = NULL;
+
+        /* Now post the command */
+        twl_post_command_packet(tw_dev, request_id);
+} /* End twl_aen_sync_time() */
+
+/* This function will assign an available request id */
+static void twl_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
+{
+        *request_id = tw_dev->free_queue[tw_dev->free_head];
+        tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
+        tw_dev->state[*request_id] = TW_S_STARTED;
+} /* End twl_get_request_id() */
+
+/* This function will free a request id */
+static void twl_free_request_id(TW_Device_Extension *tw_dev, int request_id)
+{
+        tw_dev->free_queue[tw_dev->free_tail] = request_id;
+        tw_dev->state[request_id] = TW_S_FINISHED;
+        tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
+} /* End twl_free_request_id() */
+
+/* This function will complete an aen request from the isr */
+static int twl_aen_complete(TW_Device_Extension *tw_dev, int request_id)
+{
+        TW_Command_Full *full_command_packet;
+        TW_Command *command_packet;
+        TW_Command_Apache_Header *header;
+        unsigned short aen;
+        int retval = 1;
+
+        header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
+        tw_dev->posted_request_count--;
+        aen = le16_to_cpu(header->status_block.error);
+        full_command_packet = tw_dev->command_packet_virt[request_id];
+        command_packet = &full_command_packet->command.oldcommand;
+
+        /* First check for internal completion of set param for time sync */
+        if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
+                /* Keep reading the queue in case there are more aen's */
+                if (twl_aen_read_queue(tw_dev, request_id))
+                        goto out2;
+                else {
+                        retval = 0;
+                        goto out;
+                }
+        }
+
+        switch (aen) {
+        case TW_AEN_QUEUE_EMPTY:
+                /* Quit reading the queue if this is the last one */
+                break;
+        case TW_AEN_SYNC_TIME_WITH_HOST:
+                twl_aen_sync_time(tw_dev, request_id);
+                retval = 0;
+                goto out;
+        default:
+                twl_aen_queue_event(tw_dev, header);
+
+                /* If there are more aen's, keep reading the queue */
+                if (twl_aen_read_queue(tw_dev, request_id))
+                        goto out2;
+                else {
+                        retval = 0;
+                        goto out;
+                }
+        }
+        retval = 0;
+out2:
+        tw_dev->state[request_id] = TW_S_COMPLETED;
+        twl_free_request_id(tw_dev, request_id);
+        clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
+out:
+        return retval;
+} /* End twl_aen_complete() */
+
+/* This function will poll for a response */
+static int twl_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
+{
+        unsigned long before;
+        dma_addr_t mfa;
+        u32 regh, regl;
+        u32 response;
+        int retval = 1;
+        int found = 0;
+
+        before = jiffies;
+
+        while (!found) {
+                if (sizeof(dma_addr_t) > 4) {
+                        regh = readl(TWL_HOBQPH_REG_ADDR(tw_dev));
+                        regl = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
+                        mfa = ((u64)regh << 32) | regl;
+                } else
+                        mfa = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
+
+                response = (u32)mfa;
+
+                if (TW_RESID_OUT(response) == request_id)
+                        found = 1;
+
+                if (time_after(jiffies, before + HZ * seconds))
+                        goto out;
+
+                msleep(50);
+        }
+        retval = 0;
+out: 
+        return retval;
+} /* End twl_poll_response() */
+
+/* This function will drain the aen queue */
+static int twl_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
+{
+        int request_id = 0;
+        char cdb[TW_MAX_CDB_LEN];
+        TW_SG_Entry_ISO sglist[1];
+        int finished = 0, count = 0;
+        TW_Command_Full *full_command_packet;
+        TW_Command_Apache_Header *header;
+        unsigned short aen;
+        int first_reset = 0, queue = 0, retval = 1;
+
+        if (no_check_reset)
+                first_reset = 0;
+        else
+                first_reset = 1;
+
+        full_command_packet = tw_dev->command_packet_virt[request_id];
+        memset(full_command_packet, 0, sizeof(TW_Command_Full));
+
+        /* Initialize cdb */
+        memset(&cdb, 0, TW_MAX_CDB_LEN);
+        cdb[0] = REQUEST_SENSE; /* opcode */
+        cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
+
+        /* Initialize sglist */
+        memset(&sglist, 0, sizeof(TW_SG_Entry_ISO));
+        sglist[0].length = TW_SECTOR_SIZE;
+        sglist[0].address = tw_dev->generic_buffer_phys[request_id];
+
+        /* Mark internal command */
+        tw_dev->srb[request_id] = NULL;
+
+        do {
+                /* Send command to the board */
+                if (twl_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
+                        TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "Error posting request sense");
+                        goto out;
+                }
+
+                /* Now poll for completion */
+                if (twl_poll_response(tw_dev, request_id, 30)) {
+                        TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "No valid response while draining AEN queue");
+                        tw_dev->posted_request_count--;
+                        goto out;
+                }
+
+                tw_dev->posted_request_count--;
+                header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
+                aen = le16_to_cpu(header->status_block.error);
+                queue = 0;
+                count++;
+
+                switch (aen) {
+                case TW_AEN_QUEUE_EMPTY:
+                        if (first_reset != 1)
+                                goto out;
+                        else
+                                finished = 1;
+                        break;
+                case TW_AEN_SOFT_RESET:
+                        if (first_reset == 0)
+                                first_reset = 1;
+                        else
+                                queue = 1;
+                        break;
+                case TW_AEN_SYNC_TIME_WITH_HOST:
+                        break;
+                default:
+                        queue = 1;
+                }
+
+                /* Now queue an event info */
+                if (queue)
+                        twl_aen_queue_event(tw_dev, header);
+        } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
+
+        if (count == TW_MAX_AEN_DRAIN)
+                goto out;
+
+        retval = 0;
+out:
+        tw_dev->state[request_id] = TW_S_INITIAL;
+        return retval;
+} /* End twl_aen_drain_queue() */
+
+/* This function will allocate memory and check if it is correctly aligned */
+static int twl_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
+{
+        int i;
+        dma_addr_t dma_handle;
+        unsigned long *cpu_addr;
+        int retval = 1;
+
+        cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
+        if (!cpu_addr) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
+                goto out;
+        }
+
+        memset(cpu_addr, 0, size*TW_Q_LENGTH);
+
+        for (i = 0; i < TW_Q_LENGTH; i++) {
+                switch(which) {
+                case 0:
+                        tw_dev->command_packet_phys[i] = dma_handle+(i*size);
+                        tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
+                        break;
+                case 1:
+                        tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
+                        tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
+                        break;
+                case 2:
+                        tw_dev->sense_buffer_phys[i] = dma_handle+(i*size);
+                        tw_dev->sense_buffer_virt[i] = (TW_Command_Apache_Header *)((unsigned char *)cpu_addr + (i*size));
+                        break;
+                }
+        }
+        retval = 0;
+out:
+        return retval;
+} /* End twl_allocate_memory() */
+
+/* This function will load the request id and various sgls for ioctls */
+static void twl_load_sgl(TW_Device_Extension *tw_dev, TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length)
+{
+        TW_Command *oldcommand;
+        TW_Command_Apache *newcommand;
+        TW_SG_Entry_ISO *sgl;
+        unsigned int pae = 0;
+
+        if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
+                pae = 1;
+
+        if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
+                newcommand = &full_command_packet->command.newcommand;
+                newcommand->request_id__lunl =
+                        cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
+                if (length) {
+                        newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
+                        newcommand->sg_list[0].length = TW_CPU_TO_SGL(length);
+                }
+                newcommand->sgl_entries__lunh =
+                        cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), length ? 1 : 0));
+        } else {
+                oldcommand = &full_command_packet->command.oldcommand;
+                oldcommand->request_id = request_id;
+
+                if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
+                        /* Load the sg list */
+                        sgl = (TW_SG_Entry_ISO *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry_ISO)/4) + pae + (sizeof(dma_addr_t) > 4 ? 1 : 0));
+                        sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
+                        sgl->length = TW_CPU_TO_SGL(length);
+                        oldcommand->size += pae;
+                        oldcommand->size += sizeof(dma_addr_t) > 4 ? 1 : 0;
+                }
+        }
+} /* End twl_load_sgl() */
+
+/* This function handles ioctl for the character device
+   This interface is used by smartmontools open source software */
+static int twl_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+{
+        long timeout;
+        unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
+        dma_addr_t dma_handle;
+        int request_id = 0;
+        TW_Ioctl_Driver_Command driver_command;
+        TW_Ioctl_Buf_Apache *tw_ioctl;
+        TW_Command_Full *full_command_packet;
+        TW_Device_Extension *tw_dev = twl_device_extension_list[iminor(inode)];
+        int retval = -EFAULT;
+        void __user *argp = (void __user *)arg;
+
+        /* Only let one of these through at a time */
+        if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
+                retval = -EINTR;
+                goto out;
+        }
+
+        /* First copy down the driver command */
+        if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
+                goto out2;
+
+        /* Check data buffer size */
+        if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) {
+                retval = -EINVAL;
+                goto out2;
+        }
+
+        /* Hardware can only do multiple of 512 byte transfers */
+        data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
+
+        /* Now allocate ioctl buf memory */
+        cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, &dma_handle, GFP_KERNEL);
+        if (!cpu_addr) {
+                retval = -ENOMEM;
+                goto out2;
+        }
+
+        tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
+
+        /* Now copy down the entire ioctl */
+        if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
+                goto out3;
+
+        /* See which ioctl we are doing */
+        switch (cmd) {
+        case TW_IOCTL_FIRMWARE_PASS_THROUGH:
+                spin_lock_irqsave(tw_dev->host->host_lock, flags);
+                twl_get_request_id(tw_dev, &request_id);
+
+                /* Flag internal command */
+                tw_dev->srb[request_id] = NULL;
+
+                /* Flag chrdev ioctl */
+                tw_dev->chrdev_request_id = request_id;
+
+                full_command_packet = (TW_Command_Full *)&tw_ioctl->firmware_command;
+
+                /* Load request id and sglist for both command types */
+                twl_load_sgl(tw_dev, full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
+
+                memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
+
+                /* Now post the command packet to the controller */
+                twl_post_command_packet(tw_dev, request_id);
+                spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
+
+                timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
+
+                /* Now wait for command to complete */
+                timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
+
+                /* We timed out, and didn't get an interrupt */
+                if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
+                        /* Now we need to reset the board */
+                        printk(KERN_WARNING "3w-sas: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
+                               tw_dev->host->host_no, TW_DRIVER, 0x6,
+                               cmd);
+                        retval = -EIO;
+                        twl_reset_device_extension(tw_dev, 1);
+                        goto out3;
+                }
+
+                /* Now copy in the command packet response */
+                memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
+                
+                /* Now complete the io */
+                spin_lock_irqsave(tw_dev->host->host_lock, flags);
+                tw_dev->posted_request_count--;
+                tw_dev->state[request_id] = TW_S_COMPLETED;
+                twl_free_request_id(tw_dev, request_id);
+                spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
+                break;
+        default:
+                retval = -ENOTTY;
+                goto out3;
+        }
+
+        /* Now copy the entire response to userspace */
+        if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
+                retval = 0;
+out3:
+        /* Now free ioctl buf memory */
+        dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
+out2:
+        mutex_unlock(&tw_dev->ioctl_lock);
+out:
+        return retval;
+} /* End twl_chrdev_ioctl() */
+
+/* This function handles open for the character device */
+static int twl_chrdev_open(struct inode *inode, struct file *file)
+{
+        unsigned int minor_number;
+        int retval = -ENODEV;
+
+        if (!capable(CAP_SYS_ADMIN)) {
+                retval = -EACCES;
+                goto out;
+        }
+
+        cycle_kernel_lock();
+        minor_number = iminor(inode);
+        if (minor_number >= twl_device_extension_count)
+                goto out;
+        retval = 0;
+out:
+        return retval;
+} /* End twl_chrdev_open() */
+
+/* File operations struct for character device */
+static const struct file_operations twl_fops = {
+        .owner          = THIS_MODULE,
+        .ioctl          = twl_chrdev_ioctl,
+        .open           = twl_chrdev_open,
+        .release        = NULL
+};
+
+/* This function passes sense data from firmware to scsi layer */
+static int twl_fill_sense(TW_Device_Extension *tw_dev, int i, int request_id, int copy_sense, int print_host)
+{
+        TW_Command_Apache_Header *header;
+        TW_Command_Full *full_command_packet;
+        unsigned short error;
+        char *error_str;
+        int retval = 1;
+
+        header = tw_dev->sense_buffer_virt[i];
+        full_command_packet = tw_dev->command_packet_virt[request_id];
+
+        /* Get embedded firmware error string */
+        error_str = &(header->err_specific_desc[strlen(header->err_specific_desc) + 1]);
+
+        /* Don't print error for Logical unit not supported during rollcall */
+        error = le16_to_cpu(header->status_block.error);
+        if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE) && (error != TW_ERROR_INVALID_FIELD_IN_CDB)) {
+                if (print_host)
+                        printk(KERN_WARNING "3w-sas: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
+                               tw_dev->host->host_no,
+                               TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
+                               header->status_block.error,
+                               error_str, 
+                               header->err_specific_desc);
+                else
+                        printk(KERN_WARNING "3w-sas: ERROR: (0x%02X:0x%04X): %s:%s.\n",
+                               TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
+                               header->status_block.error,
+                               error_str,
+                               header->err_specific_desc);
+        }
+
+        if (copy_sense) {
+                memcpy(tw_dev->srb[request_id]->sense_buffer, header->sense_data, TW_SENSE_DATA_LENGTH);
+                tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
+                goto out;
+        }
+out:
+        return retval;
+} /* End twl_fill_sense() */
+
+/* This function will free up device extension resources */
+static void twl_free_device_extension(TW_Device_Extension *tw_dev)
+{
+        if (tw_dev->command_packet_virt[0])
+                pci_free_consistent(tw_dev->tw_pci_dev,
+                                    sizeof(TW_Command_Full)*TW_Q_LENGTH,
+                                    tw_dev->command_packet_virt[0],
+                                    tw_dev->command_packet_phys[0]);
+
+        if (tw_dev->generic_buffer_virt[0])
+                pci_free_consistent(tw_dev->tw_pci_dev,
+                                    TW_SECTOR_SIZE*TW_Q_LENGTH,
+                                    tw_dev->generic_buffer_virt[0],
+                                    tw_dev->generic_buffer_phys[0]);
+
+        if (tw_dev->sense_buffer_virt[0])
+                pci_free_consistent(tw_dev->tw_pci_dev,
+                                    sizeof(TW_Command_Apache_Header)*
+                                    TW_Q_LENGTH,
+                                    tw_dev->sense_buffer_virt[0],
+                                    tw_dev->sense_buffer_phys[0]);
+
+        kfree(tw_dev->event_queue[0]);
+} /* End twl_free_device_extension() */
+
+/* This function will get parameter table entries from the firmware */
+static void *twl_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
+{
+        TW_Command_Full *full_command_packet;
+        TW_Command *command_packet;
+        TW_Param_Apache *param;
+        void *retval = NULL;
+
+        /* Setup the command packet */
+        full_command_packet = tw_dev->command_packet_virt[request_id];
+        memset(full_command_packet, 0, sizeof(TW_Command_Full));
+        command_packet = &full_command_packet->command.oldcommand;
+
+        command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
+        command_packet->size              = TW_COMMAND_SIZE;
+        command_packet->request_id        = request_id;
+        command_packet->byte6_offset.block_count = cpu_to_le16(1);
+
+        /* Now setup the param */
+        param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
+        memset(param, 0, TW_SECTOR_SIZE);
+        param->table_id = cpu_to_le16(table_id | 0x8000);
+        param->parameter_id = cpu_to_le16(parameter_id);
+        param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
+
+        command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
+        command_packet->byte8_offset.param.sgl[0].length = TW_CPU_TO_SGL(TW_SECTOR_SIZE);
+
+        /* Post the command packet to the board */
+        twl_post_command_packet(tw_dev, request_id);
+
+        /* Poll for completion */
+        if (twl_poll_response(tw_dev, request_id, 30))
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "No valid response during get param")
+        else
+                retval = (void *)&(param->data[0]);
+
+        tw_dev->posted_request_count--;
+        tw_dev->state[request_id] = TW_S_INITIAL;
+
+        return retval;
+} /* End twl_get_param() */
+
+/* This function will send an initconnection command to controller */
+static int twl_initconnection(TW_Device_Extension *tw_dev, int message_credits,
+                              u32 set_features, unsigned short current_fw_srl, 
+                              unsigned short current_fw_arch_id, 
+                              unsigned short current_fw_branch, 
+                              unsigned short current_fw_build, 
+                              unsigned short *fw_on_ctlr_srl, 
+                              unsigned short *fw_on_ctlr_arch_id, 
+                              unsigned short *fw_on_ctlr_branch, 
+                              unsigned short *fw_on_ctlr_build, 
+                              u32 *init_connect_result)
+{
+        TW_Command_Full *full_command_packet;
+        TW_Initconnect *tw_initconnect;
+        int request_id = 0, retval = 1;
+
+        /* Initialize InitConnection command packet */
+        full_command_packet = tw_dev->command_packet_virt[request_id];
+        memset(full_command_packet, 0, sizeof(TW_Command_Full));
+        full_command_packet->header.header_desc.size_header = 128;
+        
+        tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
+        tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
+        tw_initconnect->request_id = request_id;
+        tw_initconnect->message_credits = cpu_to_le16(message_credits);
+        tw_initconnect->features = set_features;
+
+        /* Turn on 64-bit sgl support if we need to */
+        tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
+
+        tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
+
+        if (set_features & TW_EXTENDED_INIT_CONNECT) {
+                tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
+                tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
+                tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
+                tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
+                tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
+        } else 
+                tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
+
+        /* Send command packet to the board */
+        twl_post_command_packet(tw_dev, request_id);
+
+        /* Poll for completion */
+        if (twl_poll_response(tw_dev, request_id, 30)) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x8, "No valid response during init connection");
+        } else {
+                if (set_features & TW_EXTENDED_INIT_CONNECT) {
+                        *fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
+                        *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
+                        *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
+                        *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
+                        *init_connect_result = le32_to_cpu(tw_initconnect->result);
+                }
+                retval = 0;
+        }
+
+        tw_dev->posted_request_count--;
+        tw_dev->state[request_id] = TW_S_INITIAL;
+
+        return retval;
+} /* End twl_initconnection() */
+
+/* This function will initialize the fields of a device extension */
+static int twl_initialize_device_extension(TW_Device_Extension *tw_dev)
+{
+        int i, retval = 1;
+
+        /* Initialize command packet buffers */
+        if (twl_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x9, "Command packet memory allocation failed");
+                goto out;
+        }
+
+        /* Initialize generic buffer */
+        if (twl_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Generic memory allocation failed");
+                goto out;
+        }
+
+        /* Allocate sense buffers */
+        if (twl_allocate_memory(tw_dev, sizeof(TW_Command_Apache_Header), 2)) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0xb, "Sense buffer allocation failed");
+                goto out;
+        }
+
+        /* Allocate event info space */
+        tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL);
+        if (!tw_dev->event_queue[0]) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "Event info memory allocation failed");
+                goto out;
+        }
+
+        for (i = 0; i < TW_Q_LENGTH; i++) {
+                tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
+                tw_dev->free_queue[i] = i;
+                tw_dev->state[i] = TW_S_INITIAL;
+        }
+
+        tw_dev->free_head = TW_Q_START;
+        tw_dev->free_tail = TW_Q_START;
+        tw_dev->error_sequence_id = 1;
+        tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
+
+        mutex_init(&tw_dev->ioctl_lock);
+        init_waitqueue_head(&tw_dev->ioctl_wqueue);
+
+        retval = 0;
+out:
+        return retval;
+} /* End twl_initialize_device_extension() */
+
+/* This function will perform a pci-dma unmap */
+static void twl_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id)
+{
+        struct scsi_cmnd *cmd = tw_dev->srb[request_id];
+
+        if (cmd->SCp.phase == TW_PHASE_SGLIST)
+                scsi_dma_unmap(cmd);
+} /* End twl_unmap_scsi_data() */
+
+/* This function will handle attention interrupts */
+static int twl_handle_attention_interrupt(TW_Device_Extension *tw_dev)
+{
+        int retval = 1;
+        u32 request_id, doorbell;
+
+        /* Read doorbell status */
+        doorbell = readl(TWL_HOBDB_REG_ADDR(tw_dev));
+
+        /* Check for controller errors */
+        if (doorbell & TWL_DOORBELL_CONTROLLER_ERROR) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "Microcontroller Error: clearing");
+                goto out;
+        }
+
+        /* Check if we need to perform an AEN drain */
+        if (doorbell & TWL_DOORBELL_ATTENTION_INTERRUPT) {
+                if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
+                        twl_get_request_id(tw_dev, &request_id);
+                        if (twl_aen_read_queue(tw_dev, request_id)) {
+                                tw_dev->state[request_id] = TW_S_COMPLETED;
+                                twl_free_request_id(tw_dev, request_id);
+                                clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
+                        }
+                }
+        }
+
+        retval = 0;
+out:
+        /* Clear doorbell interrupt */
+        TWL_CLEAR_DB_INTERRUPT(tw_dev);
+
+        /* Make sure the clear was flushed by reading it back */
+        readl(TWL_HOBDBC_REG_ADDR(tw_dev));
+
+        return retval;
+} /* End twl_handle_attention_interrupt() */
+
+/* Interrupt service routine */
+static irqreturn_t twl_interrupt(int irq, void *dev_instance)
+{
+        TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
+        int i, handled = 0, error = 0;
+        dma_addr_t mfa = 0;
+        u32 reg, regl, regh, response, request_id = 0;
+        struct scsi_cmnd *cmd;
+        TW_Command_Full *full_command_packet;
+
+        spin_lock(tw_dev->host->host_lock);
+
+        /* Read host interrupt status */
+        reg = readl(TWL_HISTAT_REG_ADDR(tw_dev));
+
+        /* Check if this is our interrupt, otherwise bail */
+        if (!(reg & TWL_HISTATUS_VALID_INTERRUPT))
+                goto twl_interrupt_bail;
+
+        handled = 1;
+
+        /* If we are resetting, bail */
+        if (test_bit(TW_IN_RESET, &tw_dev->flags))
+                goto twl_interrupt_bail;
+
+        /* Attention interrupt */
+        if (reg & TWL_HISTATUS_ATTENTION_INTERRUPT) {
+                if (twl_handle_attention_interrupt(tw_dev)) {
+                        TWL_MASK_INTERRUPTS(tw_dev);
+                        goto twl_interrupt_bail;
+                }
+        }
+
+        /* Response interrupt */
+        while (reg & TWL_HISTATUS_RESPONSE_INTERRUPT) {
+                if (sizeof(dma_addr_t) > 4) {
+                        regh = readl(TWL_HOBQPH_REG_ADDR(tw_dev));
+                        regl = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
+                        mfa = ((u64)regh << 32) | regl;
+                } else
+                        mfa = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
+
+                error = 0;
+                response = (u32)mfa;
+
+                /* Check for command packet error */
+                if (!TW_NOTMFA_OUT(response)) {
+                        for (i=0;i<TW_Q_LENGTH;i++) {
+                                if (tw_dev->sense_buffer_phys[i] == mfa) {
+                                        request_id = le16_to_cpu(tw_dev->sense_buffer_virt[i]->header_desc.request_id);
+                                        if (tw_dev->srb[request_id] != NULL)
+                                                error = twl_fill_sense(tw_dev, i, request_id, 1, 1);
+                                        else {
+                                                /* Skip ioctl error prints */
+                                                if (request_id != tw_dev->chrdev_request_id)
+                                                        error = twl_fill_sense(tw_dev, i, request_id, 0, 1);
+                                                else
+                                                        memcpy(tw_dev->command_packet_virt[request_id], tw_dev->sense_buffer_virt[i], sizeof(TW_Command_Apache_Header));
+                                        }
+
+                                        /* Now re-post the sense buffer */
+                                        writel((u32)((u64)tw_dev->sense_buffer_phys[i] >> 32), TWL_HOBQPH_REG_ADDR(tw_dev));
+                                        writel((u32)tw_dev->sense_buffer_phys[i], TWL_HOBQPL_REG_ADDR(tw_dev));
+                                        break;
+                                }
+                        }
+                } else
+                        request_id = TW_RESID_OUT(response);
+
+                full_command_packet = tw_dev->command_packet_virt[request_id];
+
+                /* Check for correct state */
+                if (tw_dev->state[request_id] != TW_S_POSTED) {
+                        if (tw_dev->srb[request_id] != NULL) {
+                                TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Received a request id that wasn't posted");
+                                TWL_MASK_INTERRUPTS(tw_dev);
+                                goto twl_interrupt_bail;
+                        }
+                }
+
+                /* Check for internal command completion */
+                if (tw_dev->srb[request_id] == NULL) {
+                        if (request_id != tw_dev->chrdev_request_id) {
+                                if (twl_aen_complete(tw_dev, request_id))
+                                        TW_PRINTK(tw_dev->host, TW_DRIVER, 0xf, "Error completing AEN during attention interrupt");
+                        } else {
+                                tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
+                                wake_up(&tw_dev->ioctl_wqueue);
+                        }
+                } else {
+                        cmd = tw_dev->srb[request_id];
+
+                        if (!error)
+                                cmd->result = (DID_OK << 16);
+                        
+                        /* Report residual bytes for single sgl */
+                        if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
+                                if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
+                                        scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
+                        }
+
+                        /* Now complete the io */
+                        tw_dev->state[request_id] = TW_S_COMPLETED;
+                        twl_free_request_id(tw_dev, request_id);
+                        tw_dev->posted_request_count--;
+                        tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
+                        twl_unmap_scsi_data(tw_dev, request_id);
+                }
+
+                /* Check for another response interrupt */
+                reg = readl(TWL_HISTAT_REG_ADDR(tw_dev));
+        }
+
+twl_interrupt_bail:
+        spin_unlock(tw_dev->host->host_lock);
+        return IRQ_RETVAL(handled);
+} /* End twl_interrupt() */
+
+/* This function will poll for a register change */
+static int twl_poll_register(TW_Device_Extension *tw_dev, void *reg, u32 value, u32 result, int seconds)
+{
+        unsigned long before;
+        int retval = 1;
+        u32 reg_value;
+
+        reg_value = readl(reg);
+        before = jiffies;
+
+        while ((reg_value & value) != result) {
+                reg_value = readl(reg);
+                if (time_after(jiffies, before + HZ * seconds))
+                        goto out;
+                msleep(50);
+        }
+        retval = 0;
+out:
+        return retval;
+} /* End twl_poll_register() */
+
+/* This function will reset a controller */
+static int twl_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
+{
+        int retval = 1;
+        int i = 0;
+        u32 status = 0;
+        unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
+        unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
+        u32 init_connect_result = 0;
+        int tries = 0;
+        int do_soft_reset = soft_reset;
+
+        while (tries < TW_MAX_RESET_TRIES) {
+                /* Do a soft reset if one is needed */
+                if (do_soft_reset) {
+                        TWL_SOFT_RESET(tw_dev);
+
+                        /* Make sure controller is in a good state */
+                        if (twl_poll_register(tw_dev, TWL_SCRPD3_REG_ADDR(tw_dev), TWL_CONTROLLER_READY, 0x0, 30)) {
+                                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Controller never went non-ready during reset sequence");
+                                tries++;
+                                continue;
+                        }
+                        if (twl_poll_register(tw_dev, TWL_SCRPD3_REG_ADDR(tw_dev), TWL_CONTROLLER_READY, TWL_CONTROLLER_READY, 60)) {
+                                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x11, "Controller not ready during reset sequence");
+                                tries++;
+                                continue;
+                        }
+                }
+
+                /* Initconnect */
+                if (twl_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
+                                       TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
+                                       TW_9750_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
+                                       TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
+                                       &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
+                                       &fw_on_ctlr_build, &init_connect_result)) {
+                        TW_PRINTK(tw_dev->host, TW_DRIVER, 0x12, "Initconnection failed while checking SRL");
+                        do_soft_reset = 1;
+                        tries++;
+                        continue;
+                }
+
+                /* Load sense buffers */
+                while (i < TW_Q_LENGTH) {
+                        writel((u32)((u64)tw_dev->sense_buffer_phys[i] >> 32), TWL_HOBQPH_REG_ADDR(tw_dev));
+                        writel((u32)tw_dev->sense_buffer_phys[i], TWL_HOBQPL_REG_ADDR(tw_dev));
+
+                        /* Check status for over-run after each write */
+                        status = readl(TWL_STATUS_REG_ADDR(tw_dev));
+                        if (!(status & TWL_STATUS_OVERRUN_SUBMIT))
+                            i++;
+                }
+
+                /* Now check status */
+                status = readl(TWL_STATUS_REG_ADDR(tw_dev));
+                if (status) {
+                        TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "Bad controller status after loading sense buffers");
+                        do_soft_reset = 1;
+                        tries++;
+                        continue;
+                }
+
+                /* Drain the AEN queue */
+                if (twl_aen_drain_queue(tw_dev, soft_reset)) {
+                        TW_PRINTK(tw_dev->host, TW_DRIVER, 0x14, "AEN drain failed during reset sequence");
+                        do_soft_reset = 1;
+                        tries++;
+                        continue;
+                }
+
+                /* Load rest of compatibility struct */
+                strncpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
+                tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL;
+                tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
+                tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD;
+                tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL;
+                tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH;
+                tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD;
+                tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl;
+                tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch;
+                tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build;
+
+                /* If we got here, controller is in a good state */
+                retval = 0;
+                goto out;
+        }
+out:
+        return retval;
+} /* End twl_reset_sequence() */
+
+/* This function will reset a device extension */
+static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset)
+{
+        int i = 0, retval = 1;
+        unsigned long flags = 0;
+
+        /* Block SCSI requests while we are resetting */
+        if (ioctl_reset)
+                scsi_block_requests(tw_dev->host);
+
+        set_bit(TW_IN_RESET, &tw_dev->flags);
+        TWL_MASK_INTERRUPTS(tw_dev);
+        TWL_CLEAR_DB_INTERRUPT(tw_dev);
+
+        spin_lock_irqsave(tw_dev->host->host_lock, flags);
+
+        /* Abort all requests that are in progress */
+        for (i = 0; i < TW_Q_LENGTH; i++) {
+                if ((tw_dev->state[i] != TW_S_FINISHED) &&
+                    (tw_dev->state[i] != TW_S_INITIAL) &&
+                    (tw_dev->state[i] != TW_S_COMPLETED)) {
+                        if (tw_dev->srb[i]) {
+                                tw_dev->srb[i]->result = (DID_RESET << 16);
+                                tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
+                                twl_unmap_scsi_data(tw_dev, i);
+                        }
+                }
+        }
+
+        /* Reset queues and counts */
+        for (i = 0; i < TW_Q_LENGTH; i++) {
+                tw_dev->free_queue[i] = i;
+                tw_dev->state[i] = TW_S_INITIAL;
+        }
+        tw_dev->free_head = TW_Q_START;
+        tw_dev->free_tail = TW_Q_START;
+        tw_dev->posted_request_count = 0;
+
+        spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
+
+        if (twl_reset_sequence(tw_dev, 1))
+                goto out;
+
+        TWL_UNMASK_INTERRUPTS(tw_dev);
+
+        clear_bit(TW_IN_RESET, &tw_dev->flags);
+        tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
+
+        retval = 0;
+out:
+        if (ioctl_reset)
+                scsi_unblock_requests(tw_dev->host);
+        return retval;
+} /* End twl_reset_device_extension() */
+
+/* This funciton returns unit geometry in cylinders/heads/sectors */
+static int twl_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
+{
+        int heads, sectors;
+        TW_Device_Extension *tw_dev;
+
+        tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
+
+        if (capacity >= 0x200000) {
+                heads = 255;
+                sectors = 63;
+        } else {
+                heads = 64;
+                sectors = 32;
+        }
+
+        geom[0] = heads;
+        geom[1] = sectors;
+        geom[2] = sector_div(capacity, heads * sectors); /* cylinders */
+
+        return 0;
+} /* End twl_scsi_biosparam() */
+
+/* This is the new scsi eh reset function */
+static int twl_scsi_eh_reset(struct scsi_cmnd *SCpnt)
+{
+        TW_Device_Extension *tw_dev = NULL;
+        int retval = FAILED;
+
+        tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
+
+        tw_dev->num_resets++;
+
+        sdev_printk(KERN_WARNING, SCpnt->device,
+                "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
+                TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
+
+        /* Make sure we are not issuing an ioctl or resetting from ioctl */
+        mutex_lock(&tw_dev->ioctl_lock);
+
+        /* Now reset the card and some of the device extension data */
+        if (twl_reset_device_extension(tw_dev, 0)) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "Controller reset failed during scsi host reset");
+                goto out;
+        }
+
+        retval = SUCCESS;
+out:
+        mutex_unlock(&tw_dev->ioctl_lock);
+        return retval;
+} /* End twl_scsi_eh_reset() */
+
+/* This is the main scsi queue function to handle scsi opcodes */
+static int twl_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
+{
+        int request_id, retval;
+        TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
+
+        /* If we are resetting due to timed out ioctl, report as busy */
+        if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
+                retval = SCSI_MLQUEUE_HOST_BUSY;
+                goto out;
+        }
+
+        /* Save done function into scsi_cmnd struct */
+        SCpnt->scsi_done = done;
+                
+        /* Get a free request id */
+        twl_get_request_id(tw_dev, &request_id);
+
+        /* Save the scsi command for use by the ISR */
+        tw_dev->srb[request_id] = SCpnt;
+
+        /* Initialize phase to zero */
+        SCpnt->SCp.phase = TW_PHASE_INITIAL;
+
+        retval = twl_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
+        if (retval) {
+                tw_dev->state[request_id] = TW_S_COMPLETED;
+                twl_free_request_id(tw_dev, request_id);
+                SCpnt->result = (DID_ERROR << 16);
+                done(SCpnt);
+                retval = 0;
+        }
+out:
+        return retval;
+} /* End twl_scsi_queue() */
+
+/* This function tells the controller to shut down */
+static void __twl_shutdown(TW_Device_Extension *tw_dev)
+{
+        /* Disable interrupts */
+        TWL_MASK_INTERRUPTS(tw_dev);
+
+        /* Free up the IRQ */
+        free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
+
+        printk(KERN_WARNING "3w-sas: Shutting down host %d.\n", tw_dev->host->host_no);
+
+        /* Tell the card we are shutting down */
+        if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Connection shutdown failed");
+        } else {
+                printk(KERN_WARNING "3w-sas: Shutdown complete.\n");
+        }
+
+        /* Clear doorbell interrupt just before exit */
+        TWL_CLEAR_DB_INTERRUPT(tw_dev);
+} /* End __twl_shutdown() */
+
+/* Wrapper for __twl_shutdown */
+static void twl_shutdown(struct pci_dev *pdev)
+{
+        struct Scsi_Host *host = pci_get_drvdata(pdev);
+        TW_Device_Extension *tw_dev;
+
+        if (!host)
+                return;
+
+        tw_dev = (TW_Device_Extension *)host->hostdata;
+
+        if (tw_dev->online) 
+                __twl_shutdown(tw_dev);
+} /* End twl_shutdown() */
+
+/* This function configures unit settings when a unit is coming on-line */
+static int twl_slave_configure(struct scsi_device *sdev)
+{
+        /* Force 60 second timeout */
+        blk_queue_rq_timeout(sdev->request_queue, 60 * HZ);
+
+        return 0;
+} /* End twl_slave_configure() */
+
+/* scsi_host_template initializer */
+static struct scsi_host_template driver_template = {
+        .module                 = THIS_MODULE,
+        .name                   = "3w-sas",
+        .queuecommand           = twl_scsi_queue,
+        .eh_host_reset_handler  = twl_scsi_eh_reset,
+        .bios_param             = twl_scsi_biosparam,
+        .change_queue_depth     = twl_change_queue_depth,
+        .can_queue              = TW_Q_LENGTH-2,
+        .slave_configure        = twl_slave_configure,
+        .this_id                = -1,
+        .sg_tablesize           = TW_LIBERATOR_MAX_SGL_LENGTH,
+        .max_sectors            = TW_MAX_SECTORS,
+        .cmd_per_lun            = TW_MAX_CMDS_PER_LUN,
+        .use_clustering         = ENABLE_CLUSTERING,
+        .shost_attrs            = twl_host_attrs,
+        .emulated               = 1
+};
+
+/* This function will probe and initialize a card */
+static int __devinit twl_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
+{
+        struct Scsi_Host *host = NULL;
+        TW_Device_Extension *tw_dev;
+        int retval = -ENODEV;
+        int *ptr_phycount, phycount=0;
+
+        retval = pci_enable_device(pdev);
+        if (retval) {
+                TW_PRINTK(host, TW_DRIVER, 0x17, "Failed to enable pci device");
+                goto out_disable_device;
+        }
+
+        pci_set_master(pdev);
+        pci_try_set_mwi(pdev);
+
+        if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
+            || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
+                if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
+                    || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
+                        TW_PRINTK(host, TW_DRIVER, 0x18, "Failed to set dma mask");
+                        retval = -ENODEV;
+                        goto out_disable_device;
+                }
+
+        host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
+        if (!host) {
+                TW_PRINTK(host, TW_DRIVER, 0x19, "Failed to allocate memory for device extension");
+                retval = -ENOMEM;
+                goto out_disable_device;
+        }
+        tw_dev = shost_priv(host);
+
+        /* Save values to device extension */
+        tw_dev->host = host;
+        tw_dev->tw_pci_dev = pdev;
+
+        if (twl_initialize_device_extension(tw_dev)) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Failed to initialize device extension");
+                goto out_free_device_extension;
+        }
+
+        /* Request IO regions */
+        retval = pci_request_regions(pdev, "3w-sas");
+        if (retval) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Failed to get mem region");
+                goto out_free_device_extension;
+        }
+
+        /* Save base address, use region 1 */
+        tw_dev->base_addr = pci_iomap(pdev, 1, 0);
+        if (!tw_dev->base_addr) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to ioremap");
+                goto out_release_mem_region;
+        }
+
+        /* Disable interrupts on the card */
+        TWL_MASK_INTERRUPTS(tw_dev);
+
+        /* Initialize the card */
+        if (twl_reset_sequence(tw_dev, 0)) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1d, "Controller reset failed during probe");
+                goto out_iounmap;
+        }
+
+        /* Set host specific parameters */
+        host->max_id = TW_MAX_UNITS;
+        host->max_cmd_len = TW_MAX_CDB_LEN;
+        host->max_lun = TW_MAX_LUNS;
+        host->max_channel = 0;
+
+        /* Register the card with the kernel SCSI layer */
+        retval = scsi_add_host(host, &pdev->dev);
+        if (retval) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "scsi add host failed");
+                goto out_iounmap;
+        }
+
+        pci_set_drvdata(pdev, host);
+
+        printk(KERN_WARNING "3w-sas: scsi%d: Found an LSI 3ware %s Controller at 0x%llx, IRQ: %d.\n",
+               host->host_no,
+               (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE,
+                                     TW_PARAM_MODEL, TW_PARAM_MODEL_LENGTH),
+               (u64)pci_resource_start(pdev, 1), pdev->irq);
+
+        ptr_phycount = twl_get_param(tw_dev, 2, TW_PARAM_PHY_SUMMARY_TABLE,
+                                     TW_PARAM_PHYCOUNT, TW_PARAM_PHYCOUNT_LENGTH);
+        if (ptr_phycount)
+                phycount = le32_to_cpu(*(int *)ptr_phycount);
+
+        printk(KERN_WARNING "3w-sas: scsi%d: Firmware %s, BIOS %s, Phys: %d.\n",
+               host->host_no,
+               (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE,
+                                     TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
+               (char *)twl_get_param(tw_dev, 2, TW_VERSION_TABLE,
+                                     TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
+               phycount);
+
+        /* Try to enable MSI */
+        if (use_msi && !pci_enable_msi(pdev))
+                set_bit(TW_USING_MSI, &tw_dev->flags);
+
+        /* Now setup the interrupt handler */
+        retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev);
+        if (retval) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Error requesting IRQ");
+                goto out_remove_host;
+        }
+
+        twl_device_extension_list[twl_device_extension_count] = tw_dev;
+        twl_device_extension_count++;
+
+        /* Re-enable interrupts on the card */
+        TWL_UNMASK_INTERRUPTS(tw_dev);
+        
+        /* Finally, scan the host */
+        scsi_scan_host(host);
+
+        /* Add sysfs binary files */
+        if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr))
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Failed to create sysfs binary file: 3ware_aen_read");
+        if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr))
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Failed to create sysfs binary file: 3ware_compat_info");
+
+        if (twl_major == -1) {
+                if ((twl_major = register_chrdev (0, "twl", &twl_fops)) < 0)
+                        TW_PRINTK(host, TW_DRIVER, 0x22, "Failed to register character device");
+        }
+        tw_dev->online = 1;
+        return 0;
+
+out_remove_host:
+        if (test_bit(TW_USING_MSI, &tw_dev->flags))
+                pci_disable_msi(pdev);
+        scsi_remove_host(host);
+out_iounmap:
+        iounmap(tw_dev->base_addr);
+out_release_mem_region:
+        pci_release_regions(pdev);
+out_free_device_extension:
+        twl_free_device_extension(tw_dev);
+        scsi_host_put(host);
+out_disable_device:
+        pci_disable_device(pdev);
+
+        return retval;
+} /* End twl_probe() */
+
+/* This function is called to remove a device */
+static void twl_remove(struct pci_dev *pdev)
+{
+        struct Scsi_Host *host = pci_get_drvdata(pdev);
+        TW_Device_Extension *tw_dev;
+
+        if (!host)
+                return;
+
+        tw_dev = (TW_Device_Extension *)host->hostdata;
+
+        if (!tw_dev->online)
+                return;
+
+        /* Remove sysfs binary files */
+        sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr);
+        sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr);
+
+        scsi_remove_host(tw_dev->host);
+
+        /* Unregister character device */
+        if (twl_major >= 0) {
+                unregister_chrdev(twl_major, "twl");
+                twl_major = -1;
+        }
+
+        /* Shutdown the card */
+        __twl_shutdown(tw_dev);
+
+        /* Disable MSI if enabled */
+        if (test_bit(TW_USING_MSI, &tw_dev->flags))
+                pci_disable_msi(pdev);
+
+        /* Free IO remapping */
+        iounmap(tw_dev->base_addr);
+
+        /* Free up the mem region */
+        pci_release_regions(pdev);
+
+        /* Free up device extension resources */
+        twl_free_device_extension(tw_dev);
+
+        scsi_host_put(tw_dev->host);
+        pci_disable_device(pdev);
+        twl_device_extension_count--;
+} /* End twl_remove() */
+
+#ifdef CONFIG_PM
+/* This function is called on PCI suspend */
+static int twl_suspend(struct pci_dev *pdev, pm_message_t state)
+{
+        struct Scsi_Host *host = pci_get_drvdata(pdev);
+        TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
+
+        printk(KERN_WARNING "3w-sas: Suspending host %d.\n", tw_dev->host->host_no);
+        /* Disable interrupts */
+        TWL_MASK_INTERRUPTS(tw_dev);
+
+        free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
+
+        /* Tell the card we are shutting down */
+        if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x23, "Connection shutdown failed during suspend");
+        } else {
+                printk(KERN_WARNING "3w-sas: Suspend complete.\n");
+        }
+
+        /* Clear doorbell interrupt */
+        TWL_CLEAR_DB_INTERRUPT(tw_dev);
+
+        pci_save_state(pdev);
+        pci_disable_device(pdev);
+        pci_set_power_state(pdev, pci_choose_state(pdev, state));
+
+        return 0;
+} /* End twl_suspend() */
+
+/* This function is called on PCI resume */
+static int twl_resume(struct pci_dev *pdev)
+{
+        int retval = 0;
+        struct Scsi_Host *host = pci_get_drvdata(pdev);
+        TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
+
+        printk(KERN_WARNING "3w-sas: Resuming host %d.\n", tw_dev->host->host_no);
+        pci_set_power_state(pdev, PCI_D0);
+        pci_enable_wake(pdev, PCI_D0, 0);
+        pci_restore_state(pdev);
+
+        retval = pci_enable_device(pdev);
+        if (retval) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x24, "Enable device failed during resume");
+                return retval;
+        }
+
+        pci_set_master(pdev);
+        pci_try_set_mwi(pdev);
+
+        if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
+            || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
+                if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
+                    || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
+                        TW_PRINTK(host, TW_DRIVER, 0x25, "Failed to set dma mask during resume");
+                        retval = -ENODEV;
+                        goto out_disable_device;
+                }
+
+        /* Initialize the card */
+        if (twl_reset_sequence(tw_dev, 0)) {
+                retval = -ENODEV;
+                goto out_disable_device;
+        }
+
+        /* Now setup the interrupt handler */
+        retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev);
+        if (retval) {
+                TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Error requesting IRQ during resume");
+                retval = -ENODEV;
+                goto out_disable_device;
+        }
+
+        /* Now enable MSI if enabled */
+        if (test_bit(TW_USING_MSI, &tw_dev->flags))
+                pci_enable_msi(pdev);
+
+        /* Re-enable interrupts on the card */
+        TWL_UNMASK_INTERRUPTS(tw_dev);
+
+        printk(KERN_WARNING "3w-sas: Resume complete.\n");
+        return 0;
+
+out_disable_device:
+        scsi_remove_host(host);
+        pci_disable_device(pdev);
+
+        return retval;
+} /* End twl_resume() */
+#endif
+
+/* PCI Devices supported by this driver */
+static struct pci_device_id twl_pci_tbl[] __devinitdata = {
+        { PCI_VDEVICE(3WARE, PCI_DEVICE_ID_3WARE_9750) },
+        { }
+};
+MODULE_DEVICE_TABLE(pci, twl_pci_tbl);
+
+/* pci_driver initializer */
+static struct pci_driver twl_driver = {
+        .name           = "3w-sas",
+        .id_table       = twl_pci_tbl,
+        .probe          = twl_probe,
+        .remove         = twl_remove,
+#ifdef CONFIG_PM
+        .suspend        = twl_suspend,
+        .resume         = twl_resume,
+#endif
+        .shutdown       = twl_shutdown
+};
+
+/* This function is called on driver initialization */
+static int __init twl_init(void)
+{
+        printk(KERN_INFO "LSI 3ware SAS/SATA-RAID Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
+
+        return pci_register_driver(&twl_driver);
+} /* End twl_init() */
+
+/* This function is called on driver exit */
+static void __exit twl_exit(void)
+{
+        pci_unregister_driver(&twl_driver);
+} /* End twl_exit() */
+
+module_init(twl_init);
+module_exit(twl_exit);
+
diff --git a/drivers/scsi/3w-sas.h b/drivers/scsi/3w-sas.h
new file mode 100644
index 000000000000..d474892701d4
--- /dev/null
+++ b/drivers/scsi/3w-sas.h
@@ -0,0 +1,396 @@
+/*
+   3w-sas.h -- LSI 3ware SAS/SATA-RAID Controller device driver for Linux.
+
+   Written By: Adam Radford <linuxraid@lsi.com>
+
+   Copyright (C) 2009 LSI Corporation.
+
+   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; version 2 of the License.
+
+   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.
+
+   NO WARRANTY
+   THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
+   LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
+   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
+   solely responsible for determining the appropriateness of using and
+   distributing the Program and assumes all risks associated with its
+   exercise of rights under this Agreement, including but not limited to
+   the risks and costs of program errors, damage to or loss of data,
+   programs or equipment, and unavailability or interruption of operations.
+
+   DISCLAIMER OF LIABILITY
+   NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
+   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
+   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+   TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+   USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+   HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
+
+   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+   Bugs/Comments/Suggestions should be mailed to:
+   linuxraid@lsi.com
+
+   For more information, goto:
+   http://www.lsi.com
+*/
+
+#ifndef _3W_SAS_H
+#define _3W_SAS_H
+
+/* AEN severity table */
+static char *twl_aen_severity_table[] =
+{
+        "None", "ERROR", "WARNING", "INFO", "DEBUG", NULL
+};
+
+/* Liberator register offsets */
+#define TWL_STATUS                         0x0  /* Status */
+#define TWL_HIBDB                          0x20 /* Inbound doorbell */
+#define TWL_HISTAT                         0x30 /* Host interrupt status */
+#define TWL_HIMASK                         0x34 /* Host interrupt mask */
+#define TWL_HOBDB                          0x9C /* Outbound doorbell */
+#define TWL_HOBDBC                         0xA0 /* Outbound doorbell clear */
+#define TWL_SCRPD3                         0xBC /* Scratchpad */
+#define TWL_HIBQPL                         0xC0 /* Host inbound Q low */
+#define TWL_HIBQPH                         0xC4 /* Host inbound Q high */
+#define TWL_HOBQPL                         0xC8 /* Host outbound Q low */
+#define TWL_HOBQPH                         0xCC /* Host outbound Q high */
+#define TWL_HISTATUS_VALID_INTERRUPT       0xC
+#define TWL_HISTATUS_ATTENTION_INTERRUPT   0x4
+#define TWL_HISTATUS_RESPONSE_INTERRUPT    0x8
+#define TWL_STATUS_OVERRUN_SUBMIT          0x2000
+#define TWL_ISSUE_SOFT_RESET               0x100
+#define TWL_CONTROLLER_READY               0x2000
+#define TWL_DOORBELL_CONTROLLER_ERROR      0x200000
+#define TWL_DOORBELL_ATTENTION_INTERRUPT   0x40000
+#define TWL_PULL_MODE                      0x1
+
+/* Command packet opcodes used by the driver */
+#define TW_OP_INIT_CONNECTION 0x1
+#define TW_OP_GET_PARAM       0x12
+#define TW_OP_SET_PARAM       0x13
+#define TW_OP_EXECUTE_SCSI    0x10
+
+/* Asynchronous Event Notification (AEN) codes used by the driver */
+#define TW_AEN_QUEUE_EMPTY       0x0000
+#define TW_AEN_SOFT_RESET        0x0001
+#define TW_AEN_SYNC_TIME_WITH_HOST 0x031
+#define TW_AEN_SEVERITY_ERROR    0x1
+#define TW_AEN_SEVERITY_DEBUG    0x4
+#define TW_AEN_NOT_RETRIEVED 0x1
+
+/* Command state defines */
+#define TW_S_INITIAL   0x1  /* Initial state */
+#define TW_S_STARTED   0x2  /* Id in use */
+#define TW_S_POSTED    0x4  /* Posted to the controller */
+#define TW_S_COMPLETED 0x8  /* Completed by isr */
+#define TW_S_FINISHED  0x10 /* I/O completely done */
+
+/* Compatibility defines */
+#define TW_9750_ARCH_ID 10
+#define TW_CURRENT_DRIVER_SRL 40
+#define TW_CURRENT_DRIVER_BUILD 0
+#define TW_CURRENT_DRIVER_BRANCH 0
+
+/* Phase defines */
+#define TW_PHASE_INITIAL 0
+#define TW_PHASE_SGLIST  2
+
+/* Misc defines */
+#define TW_SECTOR_SIZE                        512
+#define TW_MAX_UNITS                          32
+#define TW_INIT_MESSAGE_CREDITS               0x100
+#define TW_INIT_COMMAND_PACKET_SIZE           0x3
+#define TW_INIT_COMMAND_PACKET_SIZE_EXTENDED  0x6
+#define TW_EXTENDED_INIT_CONNECT              0x2
+#define TW_BASE_FW_SRL                        24
+#define TW_BASE_FW_BRANCH                     0
+#define TW_BASE_FW_BUILD                      1
+#define TW_Q_LENGTH                           256
+#define TW_Q_START                            0
+#define TW_MAX_SLOT                           32
+#define TW_MAX_RESET_TRIES                    2
+#define TW_MAX_CMDS_PER_LUN                   254
+#define TW_MAX_AEN_DRAIN                      255
+#define TW_IN_RESET                           2
+#define TW_USING_MSI                          3
+#define TW_IN_ATTENTION_LOOP                  4
+#define TW_MAX_SECTORS                        256
+#define TW_MAX_CDB_LEN                        16
+#define TW_IOCTL_CHRDEV_TIMEOUT               60 /* 60 seconds */
+#define TW_IOCTL_CHRDEV_FREE                  -1
+#define TW_COMMAND_OFFSET                     128 /* 128 bytes */
+#define TW_VERSION_TABLE                      0x0402
+#define TW_TIMEKEEP_TABLE                     0x040A
+#define TW_INFORMATION_TABLE                  0x0403
+#define TW_PARAM_FWVER                        3
+#define TW_PARAM_FWVER_LENGTH                 16
+#define TW_PARAM_BIOSVER                      4
+#define TW_PARAM_BIOSVER_LENGTH               16
+#define TW_PARAM_MODEL                        8
+#define TW_PARAM_MODEL_LENGTH                 16
+#define TW_PARAM_PHY_SUMMARY_TABLE            1
+#define TW_PARAM_PHYCOUNT                     2
+#define TW_PARAM_PHYCOUNT_LENGTH              1
+#define TW_IOCTL_FIRMWARE_PASS_THROUGH        0x108  // Used by smartmontools
+#define TW_ALLOCATION_LENGTH                  128
+#define TW_SENSE_DATA_LENGTH                  18
+#define TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED   0x10a
+#define TW_ERROR_INVALID_FIELD_IN_CDB         0x10d
+#define TW_ERROR_UNIT_OFFLINE                 0x128
+#define TW_MESSAGE_SOURCE_CONTROLLER_ERROR    3
+#define TW_MESSAGE_SOURCE_CONTROLLER_EVENT    4
+#define TW_DRIVER                             6
+#ifndef PCI_DEVICE_ID_3WARE_9750
+#define PCI_DEVICE_ID_3WARE_9750 0x1010
+#endif
+
+/* Bitmask macros to eliminate bitfields */
+
+/* opcode: 5, reserved: 3 */
+#define TW_OPRES_IN(x,y) ((x << 5) | (y & 0x1f))
+#define TW_OP_OUT(x) (x & 0x1f)
+
+/* opcode: 5, sgloffset: 3 */
+#define TW_OPSGL_IN(x,y) ((x << 5) | (y & 0x1f))
+#define TW_SGL_OUT(x) ((x >> 5) & 0x7)
+
+/* severity: 3, reserved: 5 */
+#define TW_SEV_OUT(x) (x & 0x7)
+
+/* not_mfa: 1, reserved: 7, status: 8, request_id: 16 */
+#define TW_RESID_OUT(x) ((x >> 16) & 0xffff)
+#define TW_NOTMFA_OUT(x) (x & 0x1)
+
+/* request_id: 12, lun: 4 */
+#define TW_REQ_LUN_IN(lun, request_id) (((lun << 12) & 0xf000) | (request_id & 0xfff))
+#define TW_LUN_OUT(lun) ((lun >> 12) & 0xf)
+
+/* Register access macros */
+#define TWL_STATUS_REG_ADDR(x) ((unsigned char __iomem *)x->base_addr + TWL_STATUS)
+#define TWL_HOBQPL_REG_ADDR(x) ((unsigned char __iomem *)x->base_addr + TWL_HOBQPL)
+#define TWL_HOBQPH_REG_ADDR(x) ((unsigned char __iomem *)x->base_addr + TWL_HOBQPH)
+#define TWL_HOBDB_REG_ADDR(x) ((unsigned char __iomem *)x->base_addr + TWL_HOBDB)
+#define TWL_HOBDBC_REG_ADDR(x) ((unsigned char __iomem *)x->base_addr + TWL_HOBDBC)
+#define TWL_HIMASK_REG_ADDR(x) ((unsigned char __iomem *)x->base_addr + TWL_HIMASK)
+#define TWL_HISTAT_REG_ADDR(x) ((unsigned char __iomem *)x->base_addr + TWL_HISTAT)
+#define TWL_HIBQPH_REG_ADDR(x) ((unsigned char __iomem *)x->base_addr + TWL_HIBQPH)
+#define TWL_HIBQPL_REG_ADDR(x) ((unsigned char __iomem *)x->base_addr + TWL_HIBQPL)
+#define TWL_HIBDB_REG_ADDR(x) ((unsigned char __iomem *)x->base_addr + TWL_HIBDB)
+#define TWL_SCRPD3_REG_ADDR(x) ((unsigned char __iomem *)x->base_addr + TWL_SCRPD3)
+#define TWL_MASK_INTERRUPTS(x) (writel(~0, TWL_HIMASK_REG_ADDR(tw_dev)))
+#define TWL_UNMASK_INTERRUPTS(x) (writel(~TWL_HISTATUS_VALID_INTERRUPT, TWL_HIMASK_REG_ADDR(tw_dev)))
+#define TWL_CLEAR_DB_INTERRUPT(x) (writel(~0, TWL_HOBDBC_REG_ADDR(tw_dev)))
+#define TWL_SOFT_RESET(x) (writel(TWL_ISSUE_SOFT_RESET, TWL_HIBDB_REG_ADDR(tw_dev)))
+
+/* Macros */
+#define TW_PRINTK(h,a,b,c) { \
+if (h) \
+printk(KERN_WARNING "3w-sas: scsi%d: ERROR: (0x%02X:0x%04X): %s.\n",h->host_no,a,b,c); \
+else \
+printk(KERN_WARNING "3w-sas: ERROR: (0x%02X:0x%04X): %s.\n",a,b,c); \
+}
+#define TW_MAX_LUNS 16
+#define TW_COMMAND_SIZE (sizeof(dma_addr_t) > 4 ? 6 : 4)
+#define TW_LIBERATOR_MAX_SGL_LENGTH (sizeof(dma_addr_t) > 4 ? 46 : 92)
+#define TW_LIBERATOR_MAX_SGL_LENGTH_OLD (sizeof(dma_addr_t) > 4 ? 47 : 94)
+#define TW_PADDING_LENGTH_LIBERATOR 136
+#define TW_PADDING_LENGTH_LIBERATOR_OLD 132
+#define TW_CPU_TO_SGL(x) (sizeof(dma_addr_t) > 4 ? cpu_to_le64(x) : cpu_to_le32(x))
+
+#pragma pack(1)
+
+/* SGL entry */
+typedef struct TAG_TW_SG_Entry_ISO {
+        dma_addr_t address;
+        dma_addr_t length;
+} TW_SG_Entry_ISO;
+
+/* Old Command Packet with ISO SGL */
+typedef struct TW_Command {
+        unsigned char opcode__sgloffset;
+        unsigned char size;
+        unsigned char request_id;
+        unsigned char unit__hostid;
+        /* Second DWORD */
+        unsigned char status;
+        unsigned char flags;
+        union {
+                unsigned short block_count;
+                unsigned short parameter_count;
+        } byte6_offset;
+        union {
+                struct {
+                        u32 lba;
+                        TW_SG_Entry_ISO sgl[TW_LIBERATOR_MAX_SGL_LENGTH_OLD];
+                        unsigned char padding[TW_PADDING_LENGTH_LIBERATOR_OLD];
+                } io;
+                struct {
+                        TW_SG_Entry_ISO sgl[TW_LIBERATOR_MAX_SGL_LENGTH_OLD];
+                        u32 padding;
+                        unsigned char padding2[TW_PADDING_LENGTH_LIBERATOR_OLD];
+                } param;
+        } byte8_offset;
+} TW_Command;
+
+/* New Command Packet with ISO SGL */
+typedef struct TAG_TW_Command_Apache {
+        unsigned char opcode__reserved;
+        unsigned char unit;
+        unsigned short request_id__lunl;
+        unsigned char status;
+        unsigned char sgl_offset;
+        unsigned short sgl_entries__lunh;
+        unsigned char cdb[16];
+        TW_SG_Entry_ISO sg_list[TW_LIBERATOR_MAX_SGL_LENGTH];
+        unsigned char padding[TW_PADDING_LENGTH_LIBERATOR];
+} TW_Command_Apache;
+
+/* New command packet header */
+typedef struct TAG_TW_Command_Apache_Header {
+        unsigned char sense_data[TW_SENSE_DATA_LENGTH];
+        struct {
+                char reserved[4];
+                unsigned short error;
+                unsigned char padding;
+                unsigned char severity__reserved;
+        } status_block;
+        unsigned char err_specific_desc[98];
+        struct {
+                unsigned char size_header;
+                unsigned short request_id;
+                unsigned char size_sense;
+        } header_desc;
+} TW_Command_Apache_Header;
+
+/* This struct is a union of the 2 command packets */
+typedef struct TAG_TW_Command_Full {
+        TW_Command_Apache_Header header;
+        union {
+                TW_Command oldcommand;
+                TW_Command_Apache newcommand;
+        } command;
+} TW_Command_Full;
+
+/* Initconnection structure */
+typedef struct TAG_TW_Initconnect {
+        unsigned char opcode__reserved;
+        unsigned char size;
+        unsigned char request_id;
+        unsigned char res2;
+        unsigned char status;
+        unsigned char flags;
+        unsigned short message_credits;
+        u32 features;
+        unsigned short fw_srl;
+        unsigned short fw_arch_id;
+        unsigned short fw_branch;
+        unsigned short fw_build;
+        u32 result;
+} TW_Initconnect;
+
+/* Event info structure */
+typedef struct TAG_TW_Event
+{
+        unsigned int sequence_id;
+        unsigned int time_stamp_sec;
+        unsigned short aen_code;
+        unsigned char severity;
+        unsigned char retrieved;
+        unsigned char repeat_count;
+        unsigned char parameter_len;
+        unsigned char parameter_data[98];
+} TW_Event;
+
+typedef struct TAG_TW_Ioctl_Driver_Command {
+        unsigned int control_code;
+        unsigned int status;
+        unsigned int unique_id;
+        unsigned int sequence_id;
+        unsigned int os_specific;
+        unsigned int buffer_length;
+} TW_Ioctl_Driver_Command;
+
+typedef struct TAG_TW_Ioctl_Apache {
+        TW_Ioctl_Driver_Command driver_command;
+        char padding[488];
+        TW_Command_Full firmware_command;
+        char data_buffer[1];
+} TW_Ioctl_Buf_Apache;
+
+/* GetParam descriptor */
+typedef struct {
+        unsigned short  table_id;
+        unsigned short  parameter_id;
+        unsigned short  parameter_size_bytes;
+        unsigned short  actual_parameter_size_bytes;
+        unsigned char   data[1];
+} TW_Param_Apache;
+
+/* Compatibility information structure */
+typedef struct TAG_TW_Compatibility_Info
+{
+        char driver_version[32];
+        unsigned short working_srl;
+        unsigned short working_branch;
+        unsigned short working_build;
+        unsigned short driver_srl_high;
+        unsigned short driver_branch_high;
+        unsigned short driver_build_high;
+        unsigned short driver_srl_low;
+        unsigned short driver_branch_low;
+        unsigned short driver_build_low;
+        unsigned short fw_on_ctlr_srl;
+        unsigned short fw_on_ctlr_branch;
+        unsigned short fw_on_ctlr_build;
+} TW_Compatibility_Info;
+
+#pragma pack()
+
+typedef struct TAG_TW_Device_Extension {
+        void                     __iomem *base_addr;
+        unsigned long           *generic_buffer_virt[TW_Q_LENGTH];
+        dma_addr_t              generic_buffer_phys[TW_Q_LENGTH];
+        TW_Command_Full         *command_packet_virt[TW_Q_LENGTH];
+        dma_addr_t              command_packet_phys[TW_Q_LENGTH];
+        TW_Command_Apache_Header *sense_buffer_virt[TW_Q_LENGTH];
+        dma_addr_t              sense_buffer_phys[TW_Q_LENGTH];
+        struct pci_dev          *tw_pci_dev;
+        struct scsi_cmnd        *srb[TW_Q_LENGTH];
+        unsigned char           free_queue[TW_Q_LENGTH];
+        unsigned char           free_head;
+        unsigned char           free_tail;
+        int                     state[TW_Q_LENGTH];
+        unsigned int            posted_request_count;
+        unsigned int            max_posted_request_count;
+        unsigned int            max_sgl_entries;
+        unsigned int            sgl_entries;
+        unsigned int            num_resets;
+        unsigned int            sector_count;
+        unsigned int            max_sector_count;
+        unsigned int            aen_count;
+        struct Scsi_Host        *host;
+        long                    flags;
+        TW_Event                *event_queue[TW_Q_LENGTH];
+        unsigned char           error_index;
+        unsigned int            error_sequence_id;
+        int                     chrdev_request_id;
+        wait_queue_head_t       ioctl_wqueue;
+        struct mutex            ioctl_lock;
+        TW_Compatibility_Info   tw_compat_info;
+        char                    online;
+} TW_Device_Extension;
+
+#endif /* _3W_SAS_H */
+
diff --git a/drivers/scsi/3w-xxxx.c b/drivers/scsi/3w-xxxx.c
index faa0fcfed71e..5faf903ca8c8 100644
--- a/drivers/scsi/3w-xxxx.c
+++ b/drivers/scsi/3w-xxxx.c
@@ -8,7 +8,7 @@
 
    Copyright (C) 1999-2009 3ware Inc.
 
-   Kernel compatiblity By:      Andre Hedrick <andre@suse.com>
+   Kernel compatibility By:     Andre Hedrick <andre@suse.com>
    Non-Copyright (C) 2000       Andre Hedrick <andre@suse.com>
    
    Further tiny build fixes and trivial hoovering    Alan Cox
@@ -205,6 +205,7 @@
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/delay.h>
+#include <linux/gfp.h>
 #include <linux/pci.h>
 #include <linux/time.h>
 #include <linux/mutex.h>
@@ -521,8 +522,12 @@ static ssize_t tw_show_stats(struct device *dev, struct device_attribute *attr,
 } /* End tw_show_stats() */
 
 /* This function will set a devices queue depth */
-static int tw_change_queue_depth(struct scsi_device *sdev, int queue_depth)
+static int tw_change_queue_depth(struct scsi_device *sdev, int queue_depth,
+                                 int reason)
 {
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
         if (queue_depth > TW_Q_LENGTH-2)
                 queue_depth = TW_Q_LENGTH-2;
         scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
diff --git a/drivers/scsi/53c700.c b/drivers/scsi/53c700.c
index f5a9addb7050..80dc3ac12cde 100644
--- a/drivers/scsi/53c700.c
+++ b/drivers/scsi/53c700.c
@@ -117,6 +117,7 @@
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/delay.h>
 #include <linux/spinlock.h>
@@ -175,7 +176,7 @@ STATIC void NCR_700_chip_reset(struct Scsi_Host *host);
 STATIC int NCR_700_slave_alloc(struct scsi_device *SDpnt);
 STATIC int NCR_700_slave_configure(struct scsi_device *SDpnt);
 STATIC void NCR_700_slave_destroy(struct scsi_device *SDpnt);
-static int NCR_700_change_queue_depth(struct scsi_device *SDpnt, int depth);
+static int NCR_700_change_queue_depth(struct scsi_device *SDpnt, int depth, int reason);
 static int NCR_700_change_queue_type(struct scsi_device *SDpnt, int depth);
 
 STATIC struct device_attribute *NCR_700_dev_attrs[];
@@ -1491,7 +1492,7 @@ NCR_700_intr(int irq, void *dev_id)
         unsigned long flags;
         int handled = 0;
 
-        /* Use the host lock to serialise acess to the 53c700
+        /* Use the host lock to serialise access to the 53c700
          * hardware.  Note: In future, we may need to take the queue
          * lock to enter the done routines.  When that happens, we
          * need to ensure that for this driver, the host lock and the
@@ -2082,8 +2083,11 @@ NCR_700_slave_destroy(struct scsi_device *SDp)
 }
 
 static int
-NCR_700_change_queue_depth(struct scsi_device *SDp, int depth)
+NCR_700_change_queue_depth(struct scsi_device *SDp, int depth, int reason)
 {
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
         if (depth > NCR_700_MAX_TAGS)
                 depth = NCR_700_MAX_TAGS;
 
diff --git a/drivers/scsi/BusLogic.c b/drivers/scsi/BusLogic.c
index 1ddcf4031d4c..fc0b4b81d552 100644
--- a/drivers/scsi/BusLogic.c
+++ b/drivers/scsi/BusLogic.c
@@ -42,6 +42,7 @@
 #include <linux/spinlock.h>
 #include <linux/jiffies.h>
 #include <linux/dma-mapping.h>
+#include <linux/slab.h>
 #include <scsi/scsicam.h>
 
 #include <asm/dma.h>
diff --git a/drivers/scsi/FlashPoint.c b/drivers/scsi/FlashPoint.c
index b898d382b7b0..e40cdfb7541f 100644
--- a/drivers/scsi/FlashPoint.c
+++ b/drivers/scsi/FlashPoint.c
@@ -3924,7 +3924,7 @@ static void FPT_sinits(struct sccb *p_sccb, unsigned char p_card)
 {
         struct sccb_mgr_tar_info *currTar_Info;
 
-        if ((p_sccb->TargID > MAX_SCSI_TAR) || (p_sccb->Lun > MAX_LUN)) {
+        if ((p_sccb->TargID >= MAX_SCSI_TAR) || (p_sccb->Lun >= MAX_LUN)) {
                 return;
         }
         currTar_Info = &FPT_sccbMgrTbl[p_card][p_sccb->TargID];
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index e11cca4c784c..75f2336807cb 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -1,9 +1,15 @@
 menu "SCSI device support"
 
+config SCSI_MOD
+       tristate
+       default y if SCSI=n || SCSI=y
+       default m if SCSI=m
+
 config RAID_ATTRS
         tristate "RAID Transport Class"
         default n
         depends on BLOCK
+        depends on SCSI_MOD
         ---help---
           Provides RAID
 
@@ -388,6 +394,16 @@ config BLK_DEV_3W_XXXX_RAID
           Please read the comments at the top of
           <file:drivers/scsi/3w-xxxx.c>.
 
+config SCSI_HPSA
+        tristate "HP Smart Array SCSI driver"
+        depends on PCI && SCSI
+        help
+          This driver supports HP Smart Array Controllers (circa 2009).
+          It is a SCSI alternative to the cciss driver, which is a block
+          driver.  Anyone wishing to use HP Smart Array controllers who
+          would prefer the devices be presented to linux as SCSI devices,
+          rather than as generic block devices should say Y here.
+
 config SCSI_3W_9XXX
         tristate "3ware 9xxx SATA-RAID support"
         depends on PCI && SCSI
@@ -399,6 +415,17 @@ config SCSI_3W_9XXX
           Please read the comments at the top of
           <file:drivers/scsi/3w-9xxx.c>.
 
+config SCSI_3W_SAS
+        tristate "3ware 97xx SAS/SATA-RAID support"
+        depends on PCI && SCSI
+        help
+          This driver supports the LSI 3ware 9750 6Gb/s SAS/SATA-RAID cards.
+
+          <http://www.lsi.com>
+
+          Please read the comments at the top of
+          <file:drivers/scsi/3w-sas.c>.
+
 config SCSI_7000FASST
         tristate "7000FASST SCSI support"
         depends on ISA && SCSI && ISA_DMA_API
@@ -621,6 +648,14 @@ config SCSI_FLASHPOINT
           substantial, so users of MultiMaster Host Adapters may not
           wish to include it.
 
+config VMWARE_PVSCSI
+        tristate "VMware PVSCSI driver support"
+        depends on PCI && SCSI && X86
+        help
+          This driver supports VMware's para virtualized SCSI HBA.
+          To compile this driver as a module, choose M here: the
+          module will be called vmw_pvscsi.
+
 config LIBFC
         tristate "LibFC module"
         select SCSI_FC_ATTRS
@@ -644,7 +679,7 @@ config FCOE
 config FCOE_FNIC
         tristate "Cisco FNIC Driver"
         depends on PCI && X86
-        select LIBFC
+        select LIBFCOE
         help
           This is support for the Cisco PCI-Express FCoE HBA.
 
@@ -1818,6 +1853,14 @@ config SCSI_PMCRAID
         ---help---
           This driver supports the PMC SIERRA MaxRAID adapters.
 
+config SCSI_PM8001
+        tristate "PMC-Sierra SPC 8001 SAS/SATA Based Host Adapter driver"
+        depends on PCI && SCSI
+        select SCSI_SAS_LIBSAS
+        help
+          This driver supports PMC-Sierra PCIE SAS/SATA 8x6G SPC 8001 chip
+          based host adapters.
+
 config SCSI_SRP
         tristate "SCSI RDMA Protocol helper library"
         depends on SCSI && PCI
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 3ad61db5e3fa..92a8c500b23d 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -70,6 +70,7 @@ obj-$(CONFIG_SCSI_AIC79XX)	+= aic7xxx/
 obj-$(CONFIG_SCSI_AACRAID)      += aacraid/
 obj-$(CONFIG_SCSI_AIC7XXX_OLD)  += aic7xxx_old.o
 obj-$(CONFIG_SCSI_AIC94XX)      += aic94xx/
+obj-$(CONFIG_SCSI_PM8001)       += pm8001/
 obj-$(CONFIG_SCSI_IPS)          += ips.o
 obj-$(CONFIG_SCSI_FD_MCS)       += fd_mcs.o
 obj-$(CONFIG_SCSI_FUTURE_DOMAIN)+= fdomain.o
@@ -90,6 +91,7 @@ obj-$(CONFIG_SCSI_BFA_FC)	+= bfa/
 obj-$(CONFIG_SCSI_PAS16)        += pas16.o
 obj-$(CONFIG_SCSI_T128)         += t128.o
 obj-$(CONFIG_SCSI_DMX3191D)     += dmx3191d.o
+obj-$(CONFIG_SCSI_HPSA)         += hpsa.o
 obj-$(CONFIG_SCSI_DTC3280)      += dtc.o
 obj-$(CONFIG_SCSI_SYM53C8XX_2)  += sym53c8xx_2/
 obj-$(CONFIG_SCSI_ZALON)        += zalon7xx.o
@@ -113,6 +115,7 @@ obj-$(CONFIG_SCSI_MESH)		+= mesh.o
 obj-$(CONFIG_SCSI_MAC53C94)     += mac53c94.o
 obj-$(CONFIG_BLK_DEV_3W_XXXX_RAID) += 3w-xxxx.o
 obj-$(CONFIG_SCSI_3W_9XXX)      += 3w-9xxx.o
+obj-$(CONFIG_SCSI_3W_SAS)       += 3w-sas.o
 obj-$(CONFIG_SCSI_PPA)          += ppa.o
 obj-$(CONFIG_SCSI_IMM)          += imm.o
 obj-$(CONFIG_JAZZ_ESP)          += esp_scsi.o   jazz_esp.o
@@ -133,6 +136,7 @@ obj-$(CONFIG_SCSI_CXGB3_ISCSI)	+= libiscsi.o libiscsi_tcp.o cxgb3i/
 obj-$(CONFIG_SCSI_BNX2_ISCSI)   += libiscsi.o bnx2i/
 obj-$(CONFIG_BE2ISCSI)          += libiscsi.o be2iscsi/
 obj-$(CONFIG_SCSI_PMCRAID)      += pmcraid.o
+obj-$(CONFIG_VMWARE_PVSCSI)     += vmw_pvscsi.o
 
 obj-$(CONFIG_ARM)               += arm/
 
diff --git a/drivers/scsi/NCR_D700.c b/drivers/scsi/NCR_D700.c
index 1cdf09a4779a..8647256ad66d 100644
--- a/drivers/scsi/NCR_D700.c
+++ b/drivers/scsi/NCR_D700.c
@@ -97,6 +97,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/mca.h>
+#include <linux/slab.h>
 #include <asm/io.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
diff --git a/drivers/scsi/NCR_Q720.c b/drivers/scsi/NCR_Q720.c
index a8bbdc2273b8..afdbb9addf18 100644
--- a/drivers/scsi/NCR_Q720.c
+++ b/drivers/scsi/NCR_Q720.c
@@ -10,6 +10,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/mca.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/init.h>
 #include <linux/delay.h>
diff --git a/drivers/scsi/a100u2w.c b/drivers/scsi/a100u2w.c
index 208d6df9ed59..dbbc601948e5 100644
--- a/drivers/scsi/a100u2w.c
+++ b/drivers/scsi/a100u2w.c
@@ -69,7 +69,6 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/ioport.h>
-#include <linux/slab.h>
 #include <linux/dma-mapping.h>
 
 #include <asm/io.h>
@@ -492,7 +491,7 @@ static void init_alloc_map(struct orc_host * host)
  *      init_orchid             -       initialise the host adapter
  *      @host:host adapter to initialise
  *
- *      Initialise the controller and if neccessary load the firmware.
+ *      Initialise the controller and if necessary load the firmware.
  *
  *      Returns -1 if the initialisation fails.
  */
diff --git a/drivers/scsi/a2091.c b/drivers/scsi/a2091.c
index 4b38c4750f77..d8fe5b76fee0 100644
--- a/drivers/scsi/a2091.c
+++ b/drivers/scsi/a2091.c
@@ -1,5 +1,6 @@
 #include <linux/types.h>
 #include <linux/mm.h>
+#include <linux/slab.h>
 #include <linux/blkdev.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
diff --git a/drivers/scsi/a3000.c b/drivers/scsi/a3000.c
index 6970ce82c4ac..c35fc55f1c96 100644
--- a/drivers/scsi/a3000.c
+++ b/drivers/scsi/a3000.c
@@ -1,5 +1,6 @@
 #include <linux/types.h>
 #include <linux/mm.h>
+#include <linux/slab.h>
 #include <linux/blkdev.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
diff --git a/drivers/scsi/a4000t.c b/drivers/scsi/a4000t.c
index e3519fa5a3ba..11ae6be8aeaf 100644
--- a/drivers/scsi/a4000t.c
+++ b/drivers/scsi/a4000t.c
@@ -12,6 +12,7 @@
 #include <linux/platform_device.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 #include <asm/amigahw.h>
 #include <asm/amigaints.h>
 #include <scsi/scsi_host.h>
diff --git a/drivers/scsi/aacraid/aachba.c b/drivers/scsi/aacraid/aachba.c
index 2a889853a106..7e26ebc26661 100644
--- a/drivers/scsi/aacraid/aachba.c
+++ b/drivers/scsi/aacraid/aachba.c
@@ -293,7 +293,10 @@ int aac_get_config_status(struct aac_dev *dev, int commit_flag)
                         status = -EINVAL;
                 }
         }
-        aac_fib_complete(fibptr);
+        /* Do not set XferState to zero unless receives a response from F/W */
+        if (status >= 0)
+                aac_fib_complete(fibptr);
+
         /* Send a CT_COMMIT_CONFIG to enable discovery of devices */
         if (status >= 0) {
                 if ((aac_commit == 1) || commit_flag) {
@@ -310,13 +313,18 @@ int aac_get_config_status(struct aac_dev *dev, int commit_flag)
                                     FsaNormal,
                                     1, 1,
                                     NULL, NULL);
-                        aac_fib_complete(fibptr);
+                        /* Do not set XferState to zero unless
+                         * receives a response from F/W */
+                        if (status >= 0)
+                                aac_fib_complete(fibptr);
                 } else if (aac_commit == 0) {
                         printk(KERN_WARNING
                           "aac_get_config_status: Foreign device configurations are being ignored\n");
                 }
         }
-        aac_fib_free(fibptr);
+        /* FIB should be freed only after getting the response from the F/W */
+        if (status != -ERESTARTSYS)
+                aac_fib_free(fibptr);
         return status;
 }
 
@@ -355,7 +363,9 @@ int aac_get_containers(struct aac_dev *dev)
                 maximum_num_containers = le32_to_cpu(dresp->ContainerSwitchEntries);
                 aac_fib_complete(fibptr);
         }
-        aac_fib_free(fibptr);
+        /* FIB should be freed only after getting the response from the F/W */
+        if (status != -ERESTARTSYS)
+                aac_fib_free(fibptr);
 
         if (maximum_num_containers < MAXIMUM_NUM_CONTAINERS)
                 maximum_num_containers = MAXIMUM_NUM_CONTAINERS;
@@ -1245,8 +1255,12 @@ int aac_get_adapter_info(struct aac_dev* dev)
                          NULL);
 
         if (rcode < 0) {
-                aac_fib_complete(fibptr);
-                aac_fib_free(fibptr);
+                /* FIB should be freed only after
+                 * getting the response from the F/W */
+                if (rcode != -ERESTARTSYS) {
+                        aac_fib_complete(fibptr);
+                        aac_fib_free(fibptr);
+                }
                 return rcode;
         }
         memcpy(&dev->adapter_info, info, sizeof(*info));
@@ -1270,6 +1284,12 @@ int aac_get_adapter_info(struct aac_dev* dev)
 
                 if (rcode >= 0)
                         memcpy(&dev->supplement_adapter_info, sinfo, sizeof(*sinfo));
+                if (rcode == -ERESTARTSYS) {
+                        fibptr = aac_fib_alloc(dev);
+                        if (!fibptr)
+                                return -ENOMEM;
+                }
+
         }
 
 
@@ -1470,9 +1490,11 @@ int aac_get_adapter_info(struct aac_dev* dev)
                           (dev->scsi_host_ptr->sg_tablesize * 8) + 112;
                 }
         }
-
-        aac_fib_complete(fibptr);
-        aac_fib_free(fibptr);
+        /* FIB should be freed only after getting the response from the F/W */
+        if (rcode != -ERESTARTSYS) {
+                aac_fib_complete(fibptr);
+                aac_fib_free(fibptr);
+        }
 
         return rcode;
 }
@@ -1633,6 +1655,7 @@ static int aac_read(struct scsi_cmnd * scsicmd)
          *      Alocate and initialize a Fib
          */
         if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
+                printk(KERN_WARNING "aac_read: fib allocation failed\n");
                 return -1;
         }
 
@@ -1712,9 +1735,14 @@ static int aac_write(struct scsi_cmnd * scsicmd)
          *      Allocate and initialize a Fib then setup a BlockWrite command
          */
         if (!(cmd_fibcontext = aac_fib_alloc(dev))) {
-                scsicmd->result = DID_ERROR << 16;
-                scsicmd->scsi_done(scsicmd);
-                return 0;
+                /* FIB temporarily unavailable,not catastrophic failure */
+
+                /* scsicmd->result = DID_ERROR << 16;
+                 * scsicmd->scsi_done(scsicmd);
+                 * return 0;
+                 */
+                printk(KERN_WARNING "aac_write: fib allocation failed\n");
+                return -1;
         }
 
         status = aac_adapter_write(cmd_fibcontext, scsicmd, lba, count, fua);
diff --git a/drivers/scsi/aacraid/aacraid.h b/drivers/scsi/aacraid/aacraid.h
index cdbdec9f4fb2..619c02d9c862 100644
--- a/drivers/scsi/aacraid/aacraid.h
+++ b/drivers/scsi/aacraid/aacraid.h
@@ -12,7 +12,7 @@
  *----------------------------------------------------------------------------*/
 
 #ifndef AAC_DRIVER_BUILD
-# define AAC_DRIVER_BUILD 2461
+# define AAC_DRIVER_BUILD 24702
 # define AAC_DRIVER_BRANCH "-ms"
 #endif
 #define MAXIMUM_NUM_CONTAINERS  32
@@ -526,10 +526,10 @@ struct aac_driver_ident
 
 /*
  *      The adapter interface specs all queues to be located in the same
- *      physically contigous block. The host structure that defines the
+ *      physically contiguous block. The host structure that defines the
  *      commuication queues will assume they are each a separate physically
- *      contigous memory region that will support them all being one big
- *      contigous block.
+ *      contiguous memory region that will support them all being one big
+ *      contiguous block.
  *      There is a command and response queue for each level and direction of
  *      commuication. These regions are accessed by both the host and adapter.
  */
@@ -1036,6 +1036,9 @@ struct aac_dev
         u8                      printf_enabled;
         u8                      in_reset;
         u8                      msi;
+        int                     management_fib_count;
+        spinlock_t              manage_lock;
+
 };
 
 #define aac_adapter_interrupt(dev) \
diff --git a/drivers/scsi/aacraid/commctrl.c b/drivers/scsi/aacraid/commctrl.c
index 0391d759dfdb..9c0c91178538 100644
--- a/drivers/scsi/aacraid/commctrl.c
+++ b/drivers/scsi/aacraid/commctrl.c
@@ -153,7 +153,7 @@ cleanup:
                 fibptr->hw_fib_pa = hw_fib_pa;
                 fibptr->hw_fib_va = hw_fib;
         }
-        if (retval != -EINTR)
+        if (retval != -ERESTARTSYS)
                 aac_fib_free(fibptr);
         return retval;
 }
@@ -322,7 +322,7 @@ return_fib:
                 }
                 if (f.wait) {
                         if(down_interruptible(&fibctx->wait_sem) < 0) {
-                                status = -EINTR;
+                                status = -ERESTARTSYS;
                         } else {
                                 /* Lock again and retry */
                                 spin_lock_irqsave(&dev->fib_lock, flags);
@@ -593,10 +593,10 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                                 u64 addr;
                                 void* p;
                                 if (upsg->sg[i].count >
-                                    (dev->adapter_info.options &
+                                    ((dev->adapter_info.options &
                                      AAC_OPT_NEW_COMM) ?
                                       (dev->scsi_host_ptr->max_sectors << 9) :
-                                      65536) {
+                                      65536)) {
                                         rcode = -EINVAL;
                                         goto cleanup;
                                 }
@@ -645,10 +645,10 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                                 u64 addr;
                                 void* p;
                                 if (usg->sg[i].count >
-                                    (dev->adapter_info.options &
+                                    ((dev->adapter_info.options &
                                      AAC_OPT_NEW_COMM) ?
                                       (dev->scsi_host_ptr->max_sectors << 9) :
-                                      65536) {
+                                      65536)) {
                                         rcode = -EINVAL;
                                         goto cleanup;
                                 }
@@ -695,10 +695,10 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                                 uintptr_t addr;
                                 void* p;
                                 if (usg->sg[i].count >
-                                    (dev->adapter_info.options &
+                                    ((dev->adapter_info.options &
                                      AAC_OPT_NEW_COMM) ?
                                       (dev->scsi_host_ptr->max_sectors << 9) :
-                                      65536) {
+                                      65536)) {
                                         rcode = -EINVAL;
                                         goto cleanup;
                                 }
@@ -734,10 +734,10 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                                 dma_addr_t addr;
                                 void* p;
                                 if (upsg->sg[i].count >
-                                    (dev->adapter_info.options &
+                                    ((dev->adapter_info.options &
                                      AAC_OPT_NEW_COMM) ?
                                       (dev->scsi_host_ptr->max_sectors << 9) :
-                                      65536) {
+                                      65536)) {
                                         rcode = -EINVAL;
                                         goto cleanup;
                                 }
@@ -772,8 +772,8 @@ static int aac_send_raw_srb(struct aac_dev* dev, void __user * arg)
                 psg->count = cpu_to_le32(sg_indx+1);
                 status = aac_fib_send(ScsiPortCommand, srbfib, actual_fibsize, FsaNormal, 1, 1, NULL, NULL);
         }
-        if (status == -EINTR) {
-                rcode = -EINTR;
+        if (status == -ERESTARTSYS) {
+                rcode = -ERESTARTSYS;
                 goto cleanup;
         }
 
@@ -810,7 +810,7 @@ cleanup:
         for(i=0; i <= sg_indx; i++){
                 kfree(sg_list[i]);
         }
-        if (rcode != -EINTR) {
+        if (rcode != -ERESTARTSYS) {
                 aac_fib_complete(srbfib);
                 aac_fib_free(srbfib);
         }
@@ -848,7 +848,7 @@ int aac_do_ioctl(struct aac_dev * dev, int cmd, void __user *arg)
          */
 
         status = aac_dev_ioctl(dev, cmd, arg);
-        if(status != -ENOTTY)
+        if (status != -ENOTTY)
                 return status;
 
         switch (cmd) {
diff --git a/drivers/scsi/aacraid/comminit.c b/drivers/scsi/aacraid/comminit.c
index d598eba630d0..a7261486ccd4 100644
--- a/drivers/scsi/aacraid/comminit.c
+++ b/drivers/scsi/aacraid/comminit.c
@@ -194,7 +194,9 @@ int aac_send_shutdown(struct aac_dev * dev)
 
         if (status >= 0)
                 aac_fib_complete(fibctx);
-        aac_fib_free(fibctx);
+        /* FIB should be freed only after getting the response from the F/W */
+        if (status != -ERESTARTSYS)
+                aac_fib_free(fibctx);
         return status;
 }
 
@@ -226,7 +228,7 @@ static int aac_comm_init(struct aac_dev * dev)
         spin_lock_init(&dev->fib_lock);
 
         /*
-         *      Allocate the physically contigous space for the commuication
+         *      Allocate the physically contiguous space for the commuication
          *      queue headers. 
          */
 
@@ -304,6 +306,8 @@ struct aac_dev *aac_init_adapter(struct aac_dev *dev)
         /*
          *      Check the preferred comm settings, defaults from template.
          */
+        dev->management_fib_count = 0;
+        spin_lock_init(&dev->manage_lock);
         dev->max_fib_size = sizeof(struct hw_fib);
         dev->sg_tablesize = host->sg_tablesize = (dev->max_fib_size
                 - sizeof(struct aac_fibhdr)
diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index 956261f25181..94d2954d79ae 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -189,7 +189,14 @@ struct fib *aac_fib_alloc(struct aac_dev *dev)
 
 void aac_fib_free(struct fib *fibptr)
 {
-        unsigned long flags;
+        unsigned long flags, flagsv;
+
+        spin_lock_irqsave(&fibptr->event_lock, flagsv);
+        if (fibptr->done == 2) {
+                spin_unlock_irqrestore(&fibptr->event_lock, flagsv);
+                return;
+        }
+        spin_unlock_irqrestore(&fibptr->event_lock, flagsv);
 
         spin_lock_irqsave(&fibptr->dev->fib_lock, flags);
         if (unlikely(fibptr->flags & FIB_CONTEXT_FLAG_TIMED_OUT))
@@ -390,6 +397,8 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
         struct hw_fib * hw_fib = fibptr->hw_fib_va;
         unsigned long flags = 0;
         unsigned long qflags;
+        unsigned long mflags = 0;
+
 
         if (!(hw_fib->header.XferState & cpu_to_le32(HostOwned)))
                 return -EBUSY;
@@ -471,9 +480,31 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
         if (!dev->queues)
                 return -EBUSY;
 
-        if(wait)
+        if (wait) {
+
+                spin_lock_irqsave(&dev->manage_lock, mflags);
+                if (dev->management_fib_count >= AAC_NUM_MGT_FIB) {
+                        printk(KERN_INFO "No management Fibs Available:%d\n",
+                                                dev->management_fib_count);
+                        spin_unlock_irqrestore(&dev->manage_lock, mflags);
+                        return -EBUSY;
+                }
+                dev->management_fib_count++;
+                spin_unlock_irqrestore(&dev->manage_lock, mflags);
                 spin_lock_irqsave(&fibptr->event_lock, flags);
-        aac_adapter_deliver(fibptr);
+        }
+
+        if (aac_adapter_deliver(fibptr) != 0) {
+                printk(KERN_ERR "aac_fib_send: returned -EBUSY\n");
+                if (wait) {
+                        spin_unlock_irqrestore(&fibptr->event_lock, flags);
+                        spin_lock_irqsave(&dev->manage_lock, mflags);
+                        dev->management_fib_count--;
+                        spin_unlock_irqrestore(&dev->manage_lock, mflags);
+                }
+                return -EBUSY;
+        }
+
 
         /*
          *      If the caller wanted us to wait for response wait now.
@@ -516,14 +547,15 @@ int aac_fib_send(u16 command, struct fib *fibptr, unsigned long size,
                                 udelay(5);
                         }
                 } else if (down_interruptible(&fibptr->event_wait)) {
-                        fibptr->done = 2;
-                        up(&fibptr->event_wait);
+                        /* Do nothing ... satisfy
+                         * down_interruptible must_check */
                 }
+
                 spin_lock_irqsave(&fibptr->event_lock, flags);
-                if ((fibptr->done == 0) || (fibptr->done == 2)) {
+                if (fibptr->done == 0) {
                         fibptr->done = 2; /* Tell interrupt we aborted */
                         spin_unlock_irqrestore(&fibptr->event_lock, flags);
-                        return -EINTR;
+                        return -ERESTARTSYS;
                 }
                 spin_unlock_irqrestore(&fibptr->event_lock, flags);
                 BUG_ON(fibptr->done == 0);
@@ -689,6 +721,7 @@ int aac_fib_adapter_complete(struct fib *fibptr, unsigned short size)
 
 int aac_fib_complete(struct fib *fibptr)
 {
+        unsigned long flags;
         struct hw_fib * hw_fib = fibptr->hw_fib_va;
 
         /*
@@ -709,6 +742,13 @@ int aac_fib_complete(struct fib *fibptr)
          *      command is complete that we had sent to the adapter and this
          *      cdb could be reused.
          */
+        spin_lock_irqsave(&fibptr->event_lock, flags);
+        if (fibptr->done == 2) {
+                spin_unlock_irqrestore(&fibptr->event_lock, flags);
+                return 0;
+        }
+        spin_unlock_irqrestore(&fibptr->event_lock, flags);
+
         if((hw_fib->header.XferState & cpu_to_le32(SentFromHost)) &&
                 (hw_fib->header.XferState & cpu_to_le32(AdapterProcessed)))
         {
@@ -1355,7 +1395,10 @@ int aac_reset_adapter(struct aac_dev * aac, int forced)
 
                         if (status >= 0)
                                 aac_fib_complete(fibctx);
-                        aac_fib_free(fibctx);
+                        /* FIB should be freed only after getting
+                         * the response from the F/W */
+                        if (status != -ERESTARTSYS)
+                                aac_fib_free(fibctx);
                 }
         }
 
@@ -1759,6 +1802,7 @@ int aac_command_thread(void *data)
                                 struct fib *fibptr;
 
                                 if ((fibptr = aac_fib_alloc(dev))) {
+                                        int status;
                                         __le32 *info;
 
                                         aac_fib_init(fibptr);
@@ -1769,15 +1813,21 @@ int aac_command_thread(void *data)
 
                                         *info = cpu_to_le32(now.tv_sec);
 
-                                        (void)aac_fib_send(SendHostTime,
+                                        status = aac_fib_send(SendHostTime,
                                                 fibptr,
                                                 sizeof(*info),
                                                 FsaNormal,
                                                 1, 1,
                                                 NULL,
                                                 NULL);
-                                        aac_fib_complete(fibptr);
-                                        aac_fib_free(fibptr);
+                                        /* Do not set XferState to zero unless
+                                         * receives a response from F/W */
+                                        if (status >= 0)
+                                                aac_fib_complete(fibptr);
+                                        /* FIB should be freed only after
+                                         * getting the response from the F/W */
+                                        if (status != -ERESTARTSYS)
+                                                aac_fib_free(fibptr);
                                 }
                                 difference = (long)(unsigned)update_interval*HZ;
                         } else {
diff --git a/drivers/scsi/aacraid/dpcsup.c b/drivers/scsi/aacraid/dpcsup.c
index abc9ef5d1b10..9c7408fe8c7d 100644
--- a/drivers/scsi/aacraid/dpcsup.c
+++ b/drivers/scsi/aacraid/dpcsup.c
@@ -57,9 +57,9 @@ unsigned int aac_response_normal(struct aac_queue * q)
         struct hw_fib * hwfib;
         struct fib * fib;
         int consumed = 0;
-        unsigned long flags;
+        unsigned long flags, mflags;
 
-        spin_lock_irqsave(q->lock, flags);      
+        spin_lock_irqsave(q->lock, flags);
         /*
          *      Keep pulling response QEs off the response queue and waking
          *      up the waiters until there are no more QEs. We then return
@@ -125,12 +125,21 @@ unsigned int aac_response_normal(struct aac_queue * q)
                 } else {
                         unsigned long flagv;
                         spin_lock_irqsave(&fib->event_lock, flagv);
-                        if (!fib->done)
+                        if (!fib->done) {
                                 fib->done = 1;
-                        up(&fib->event_wait);
+                                up(&fib->event_wait);
+                        }
                         spin_unlock_irqrestore(&fib->event_lock, flagv);
+
+                        spin_lock_irqsave(&dev->manage_lock, mflags);
+                        dev->management_fib_count--;
+                        spin_unlock_irqrestore(&dev->manage_lock, mflags);
+
                         FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
                         if (fib->done == 2) {
+                                spin_lock_irqsave(&fib->event_lock, flagv);
+                                fib->done = 0;
+                                spin_unlock_irqrestore(&fib->event_lock, flagv);
                                 aac_fib_complete(fib);
                                 aac_fib_free(fib);
                         }
@@ -232,6 +241,7 @@ unsigned int aac_command_normal(struct aac_queue *q)
 
 unsigned int aac_intr_normal(struct aac_dev * dev, u32 index)
 {
+        unsigned long mflags;
         dprintk((KERN_INFO "aac_intr_normal(%p,%x)\n", dev, index));
         if ((index & 0x00000002L)) {
                 struct hw_fib * hw_fib;
@@ -320,11 +330,25 @@ unsigned int aac_intr_normal(struct aac_dev * dev, u32 index)
                         unsigned long flagv;
                         dprintk((KERN_INFO "event_wait up\n"));
                         spin_lock_irqsave(&fib->event_lock, flagv);
-                        if (!fib->done)
+                        if (!fib->done) {
                                 fib->done = 1;
-                        up(&fib->event_wait);
+                                up(&fib->event_wait);
+                        }
                         spin_unlock_irqrestore(&fib->event_lock, flagv);
+
+                        spin_lock_irqsave(&dev->manage_lock, mflags);
+                        dev->management_fib_count--;
+                        spin_unlock_irqrestore(&dev->manage_lock, mflags);
+
                         FIB_COUNTER_INCREMENT(aac_config.NormalRecved);
+                        if (fib->done == 2) {
+                                spin_lock_irqsave(&fib->event_lock, flagv);
+                                fib->done = 0;
+                                spin_unlock_irqrestore(&fib->event_lock, flagv);
+                                aac_fib_complete(fib);
+                                aac_fib_free(fib);
+                        }
+
                 }
                 return 0;
         }
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index 9b97c3e016fe..e9373a2d14fa 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -472,8 +472,12 @@ static int aac_slave_configure(struct scsi_device *sdev)
  *      total capacity and the queue depth supported by the target device.
  */
 
-static int aac_change_queue_depth(struct scsi_device *sdev, int depth)
+static int aac_change_queue_depth(struct scsi_device *sdev, int depth,
+                                  int reason)
 {
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
         if (sdev->tagged_supported && (sdev->type == TYPE_DISK) &&
             (sdev_channel(sdev) == CONTAINER_CHANNEL)) {
                 struct scsi_device * dev;
diff --git a/drivers/scsi/aacraid/rx.c b/drivers/scsi/aacraid/rx.c
index f70d9f8e79e5..04057ab72a8b 100644
--- a/drivers/scsi/aacraid/rx.c
+++ b/drivers/scsi/aacraid/rx.c
@@ -33,7 +33,6 @@
 #include <linux/types.h>
 #include <linux/pci.h>
 #include <linux/spinlock.h>
-#include <linux/slab.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/completion.h>
diff --git a/drivers/scsi/aacraid/sa.c b/drivers/scsi/aacraid/sa.c
index b6a3c5c187b6..622c21c68e65 100644
--- a/drivers/scsi/aacraid/sa.c
+++ b/drivers/scsi/aacraid/sa.c
@@ -33,7 +33,6 @@
 #include <linux/types.h>
 #include <linux/pci.h>
 #include <linux/spinlock.h>
-#include <linux/slab.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
 #include <linux/completion.h>
diff --git a/drivers/scsi/advansys.c b/drivers/scsi/advansys.c
index b756041f0b26..7f87979da22d 100644
--- a/drivers/scsi/advansys.c
+++ b/drivers/scsi/advansys.c
@@ -4724,6 +4724,10 @@ static ushort AscInitMicroCodeVar(ASC_DVC_VAR *asc_dvc)
         BUG_ON((unsigned long)asc_dvc->overrun_buf & 7);
         asc_dvc->overrun_dma = dma_map_single(board->dev, asc_dvc->overrun_buf,
                                         ASC_OVERRUN_BSIZE, DMA_FROM_DEVICE);
+        if (dma_mapping_error(board->dev, asc_dvc->overrun_dma)) {
+                warn_code = -ENOMEM;
+                goto err_dma_map;
+        }
         phy_addr = cpu_to_le32(asc_dvc->overrun_dma);
         AscMemDWordCopyPtrToLram(iop_base, ASCV_OVERRUN_PADDR_D,
                                  (uchar *)&phy_addr, 1);
@@ -4739,14 +4743,23 @@ static ushort AscInitMicroCodeVar(ASC_DVC_VAR *asc_dvc)
         AscSetPCAddr(iop_base, ASC_MCODE_START_ADDR);
         if (AscGetPCAddr(iop_base) != ASC_MCODE_START_ADDR) {
                 asc_dvc->err_code |= ASC_IERR_SET_PC_ADDR;
-                return warn_code;
+                warn_code = UW_ERR;
+                goto err_mcode_start;
         }
         if (AscStartChip(iop_base) != 1) {
                 asc_dvc->err_code |= ASC_IERR_START_STOP_CHIP;
-                return warn_code;
+                warn_code = UW_ERR;
+                goto err_mcode_start;
         }
 
         return warn_code;
+
+err_mcode_start:
+        dma_unmap_single(board->dev, asc_dvc->overrun_dma,
+                         ASC_OVERRUN_BSIZE, DMA_FROM_DEVICE);
+err_dma_map:
+        asc_dvc->overrun_dma = 0;
+        return warn_code;
 }
 
 static ushort AscInitAsc1000Driver(ASC_DVC_VAR *asc_dvc)
@@ -4781,12 +4794,14 @@ static ushort AscInitAsc1000Driver(ASC_DVC_VAR *asc_dvc)
         if (err) {
                 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
                        fwname, err);
+                asc_dvc->err_code |= ASC_IERR_MCODE_CHKSUM;
                 return err;
         }
         if (fw->size < 4) {
                 printk(KERN_ERR "Bogus length %zu in image \"%s\"\n",
                        fw->size, fwname);
                 release_firmware(fw);
+                asc_dvc->err_code |= ASC_IERR_MCODE_CHKSUM;
                 return -EINVAL;
         }
         chksum = (fw->data[3] << 24) | (fw->data[2] << 16) |
@@ -4800,6 +4815,8 @@ static ushort AscInitAsc1000Driver(ASC_DVC_VAR *asc_dvc)
         }
         release_firmware(fw);
         warn_code |= AscInitMicroCodeVar(asc_dvc);
+        if (!asc_dvc->overrun_dma)
+                return warn_code;
         asc_dvc->init_state |= ASC_INIT_STATE_END_LOAD_MC;
         AscEnableInterrupt(iop_base);
         return warn_code;
@@ -5110,12 +5127,14 @@ static int AdvInitAsc3550Driver(ADV_DVC_VAR *asc_dvc)
         if (err) {
                 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
                        fwname, err);
+                asc_dvc->err_code = ASC_IERR_MCODE_CHKSUM;
                 return err;
         }
         if (fw->size < 4) {
                 printk(KERN_ERR "Bogus length %zu in image \"%s\"\n",
                        fw->size, fwname);
                 release_firmware(fw);
+                asc_dvc->err_code = ASC_IERR_MCODE_CHKSUM;
                 return -EINVAL;
         }
         chksum = (fw->data[3] << 24) | (fw->data[2] << 16) |
@@ -5624,12 +5643,14 @@ static int AdvInitAsc38C0800Driver(ADV_DVC_VAR *asc_dvc)
         if (err) {
                 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
                        fwname, err);
+                asc_dvc->err_code = ASC_IERR_MCODE_CHKSUM;
                 return err;
         }
         if (fw->size < 4) {
                 printk(KERN_ERR "Bogus length %zu in image \"%s\"\n",
                        fw->size, fwname);
                 release_firmware(fw);
+                asc_dvc->err_code = ASC_IERR_MCODE_CHKSUM;
                 return -EINVAL;
         }
         chksum = (fw->data[3] << 24) | (fw->data[2] << 16) |
@@ -6124,12 +6145,14 @@ static int AdvInitAsc38C1600Driver(ADV_DVC_VAR *asc_dvc)
         if (err) {
                 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
                        fwname, err);
+                asc_dvc->err_code = ASC_IERR_MCODE_CHKSUM;
                 return err;
         }
         if (fw->size < 4) {
                 printk(KERN_ERR "Bogus length %zu in image \"%s\"\n",
                        fw->size, fwname);
                 release_firmware(fw);
+                asc_dvc->err_code = ASC_IERR_MCODE_CHKSUM;
                 return -EINVAL;
         }
         chksum = (fw->data[3] << 24) | (fw->data[2] << 16) |
@@ -7969,10 +7992,11 @@ static int advansys_reset(struct scsi_cmnd *scp)
                 ASC_DBG(1, "before AscInitAsc1000Driver()\n");
                 status = AscInitAsc1000Driver(asc_dvc);
 
-                /* Refer to ASC_IERR_* defintions for meaning of 'err_code'. */
-                if (asc_dvc->err_code) {
+                /* Refer to ASC_IERR_* definitions for meaning of 'err_code'. */
+                if (asc_dvc->err_code || !asc_dvc->overrun_dma) {
                         scmd_printk(KERN_INFO, scp, "SCSI bus reset error: "
-                                    "0x%x\n", asc_dvc->err_code);
+                                    "0x%x, status: 0x%x\n", asc_dvc->err_code,
+                                    status);
                         ret = FAILED;
                 } else if (status) {
                         scmd_printk(KERN_INFO, scp, "SCSI bus reset warning: "
@@ -12303,7 +12327,7 @@ static int __devinit advansys_board_found(struct Scsi_Host *shost,
                 asc_dvc_varp->overrun_buf = kzalloc(ASC_OVERRUN_BSIZE, GFP_KERNEL);
                 if (!asc_dvc_varp->overrun_buf) {
                         ret = -ENOMEM;
-                        goto err_free_wide_mem;
+                        goto err_free_irq;
                 }
                 warn_code = AscInitAsc1000Driver(asc_dvc_varp);
 
@@ -12312,30 +12336,36 @@ static int __devinit advansys_board_found(struct Scsi_Host *shost,
                                         "warn 0x%x, error 0x%x\n",
                                         asc_dvc_varp->init_state, warn_code,
                                         asc_dvc_varp->err_code);
-                        if (asc_dvc_varp->err_code) {
+                        if (!asc_dvc_varp->overrun_dma) {
                                 ret = -ENODEV;
-                                kfree(asc_dvc_varp->overrun_buf);
+                                goto err_free_mem;
                         }
                 }
         } else {
-                if (advansys_wide_init_chip(shost))
+                if (advansys_wide_init_chip(shost)) {
                         ret = -ENODEV;
+                        goto err_free_mem;
+                }
         }
 
-        if (ret)
-                goto err_free_wide_mem;
-
         ASC_DBG_PRT_SCSI_HOST(2, shost);
 
         ret = scsi_add_host(shost, boardp->dev);
         if (ret)
-                goto err_free_wide_mem;
+                goto err_free_mem;
 
         scsi_scan_host(shost);
         return 0;
 
- err_free_wide_mem:
-        advansys_wide_free_mem(boardp);
+ err_free_mem:
+        if (ASC_NARROW_BOARD(boardp)) {
+                if (asc_dvc_varp->overrun_dma)
+                        dma_unmap_single(boardp->dev, asc_dvc_varp->overrun_dma,
+                                         ASC_OVERRUN_BSIZE, DMA_FROM_DEVICE);
+                kfree(asc_dvc_varp->overrun_buf);
+        } else
+                advansys_wide_free_mem(boardp);
+ err_free_irq:
         free_irq(boardp->irq, shost);
  err_free_dma:
 #ifdef CONFIG_ISA
diff --git a/drivers/scsi/aha152x.c b/drivers/scsi/aha152x.c
index 1e5478abd90e..8eab8587ff21 100644
--- a/drivers/scsi/aha152x.c
+++ b/drivers/scsi/aha152x.c
@@ -254,6 +254,7 @@
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
 #include <linux/list.h>
+#include <linux/slab.h>
 #include <scsi/scsicam.h>
 
 #include "scsi.h"
diff --git a/drivers/scsi/aha1542.c b/drivers/scsi/aha1542.c
index 80594947c6f6..2a8cf137f609 100644
--- a/drivers/scsi/aha1542.c
+++ b/drivers/scsi/aha1542.c
@@ -39,6 +39,7 @@
 #include <linux/blkdev.h>
 #include <linux/mca.h>
 #include <linux/mca-legacy.h>
+#include <linux/slab.h>
 
 #include <asm/dma.h>
 #include <asm/system.h>
diff --git a/drivers/scsi/aha1740.c b/drivers/scsi/aha1740.c
index 538135783aab..0107a4cc3331 100644
--- a/drivers/scsi/aha1740.c
+++ b/drivers/scsi/aha1740.c
@@ -50,6 +50,7 @@
 #include <linux/device.h>
 #include <linux/eisa.h>
 #include <linux/dma-mapping.h>
+#include <linux/gfp.h>
 
 #include <asm/dma.h>
 #include <asm/system.h>
diff --git a/drivers/scsi/aic7xxx/aic79xx.seq b/drivers/scsi/aic7xxx/aic79xx.seq
index 58bc17591b54..2fb78e35a9e5 100644
--- a/drivers/scsi/aic7xxx/aic79xx.seq
+++ b/drivers/scsi/aic7xxx/aic79xx.seq
@@ -217,7 +217,7 @@ BEGIN_CRITICAL;
 scbdma_tohost_done:
         test    CCSCBCTL, CCARREN jz fill_qoutfifo_dmadone;
         /*
-         * An SCB has been succesfully uploaded to the host.
+         * An SCB has been successfully uploaded to the host.
          * If the SCB was uploaded for some reason other than
          * bad SCSI status (currently only for underruns), we
          * queue the SCB for normal completion.  Otherwise, we
@@ -1281,7 +1281,7 @@ END_CRITICAL;
  * Is it a disconnect message?  Set a flag in the SCB to remind us
  * and await the bus going free.  If this is an untagged transaction
  * store the SCB id for it in our untagged target table for lookup on
- * a reselction.
+ * a reselection.
  */
 mesgin_disconnect:
         /*
diff --git a/drivers/scsi/aic7xxx/aic79xx_core.c b/drivers/scsi/aic7xxx/aic79xx_core.c
index 63b521d615f2..78971db5b60e 100644
--- a/drivers/scsi/aic7xxx/aic79xx_core.c
+++ b/drivers/scsi/aic7xxx/aic79xx_core.c
@@ -2487,7 +2487,7 @@ ahd_handle_scsiint(struct ahd_softc *ahd, u_int intstat)
                 /*
                  * Although the driver does not care about the
                  * 'Selection in Progress' status bit, the busy
-                 * LED does.  SELINGO is only cleared by a sucessfull
+                 * LED does.  SELINGO is only cleared by a successfull
                  * selection, so we must manually clear it to insure
                  * the LED turns off just incase no future successful
                  * selections occur (e.g. no devices on the bus).
@@ -3171,13 +3171,16 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                                 tinfo->curr.transport_version = 2;
                                 tinfo->goal.transport_version = 2;
                                 tinfo->goal.ppr_options = 0;
-                                /*
-                                 * Remove any SCBs in the waiting for selection
-                                 * queue that may also be for this target so
-                                 * that command ordering is preserved.
-                                 */
-                                ahd_freeze_devq(ahd, scb);
-                                ahd_qinfifo_requeue_tail(ahd, scb);
+                                if (scb != NULL) {
+                                        /*
+                                         * Remove any SCBs in the waiting
+                                         * for selection queue that may
+                                         * also be for this target so that
+                                         * command ordering is preserved.
+                                         */
+                                        ahd_freeze_devq(ahd, scb);
+                                        ahd_qinfifo_requeue_tail(ahd, scb);
+                                }
                                 printerror = 0;
                         }
                 } else if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_WDTR, FALSE)
@@ -3194,13 +3197,16 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                                       MSG_EXT_WDTR_BUS_8_BIT,
                                       AHD_TRANS_CUR|AHD_TRANS_GOAL,
                                       /*paused*/TRUE);
-                        /*
-                         * Remove any SCBs in the waiting for selection
-                         * queue that may also be for this target so that
-                         * command ordering is preserved.
-                         */
-                        ahd_freeze_devq(ahd, scb);
-                        ahd_qinfifo_requeue_tail(ahd, scb);
+                        if (scb != NULL) {
+                                /*
+                                 * Remove any SCBs in the waiting for
+                                 * selection queue that may also be for
+                                 * this target so that command ordering
+                                 * is preserved.
+                                 */
+                                ahd_freeze_devq(ahd, scb);
+                                ahd_qinfifo_requeue_tail(ahd, scb);
+                        }
                         printerror = 0;
                 } else if (ahd_sent_msg(ahd, AHDMSG_EXT, MSG_EXT_SDTR, FALSE)
                         && ppr_busfree == 0) {
@@ -3217,13 +3223,16 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
                                         /*ppr_options*/0,
                                         AHD_TRANS_CUR|AHD_TRANS_GOAL,
                                         /*paused*/TRUE);
-                        /*
-                         * Remove any SCBs in the waiting for selection
-                         * queue that may also be for this target so that
-                         * command ordering is preserved.
-                         */
-                        ahd_freeze_devq(ahd, scb);
-                        ahd_qinfifo_requeue_tail(ahd, scb);
+                        if (scb != NULL) {
+                                /*
+                                 * Remove any SCBs in the waiting for
+                                 * selection queue that may also be for
+                                 * this target so that command ordering
+                                 * is preserved.
+                                 */
+                                ahd_freeze_devq(ahd, scb);
+                                ahd_qinfifo_requeue_tail(ahd, scb);
+                        }
                         printerror = 0;
                 } else if ((ahd->msg_flags & MSG_FLAG_EXPECT_IDE_BUSFREE) != 0
                         && ahd_sent_msg(ahd, AHDMSG_1B,
@@ -3251,7 +3260,7 @@ ahd_handle_nonpkt_busfree(struct ahd_softc *ahd)
          * the message phases.  We check it last in case we
          * had to send some other message that caused a busfree.
          */
-        if (printerror != 0
+        if (scb != NULL && printerror != 0
          && (lastphase == P_MESGIN || lastphase == P_MESGOUT)
          && ((ahd->msg_flags & MSG_FLAG_EXPECT_PPR_BUSFREE) != 0)) {
 
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.c b/drivers/scsi/aic7xxx/aic79xx_osm.c
index 75b23317bd26..4c41332a354b 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.c
@@ -53,6 +53,7 @@ static struct scsi_transport_template *ahd_linux_transport_template = NULL;
 #include <linux/blkdev.h>               /* For block_size() */
 #include <linux/delay.h>        /* For ssleep/msleep */
 #include <linux/device.h>
+#include <linux/slab.h>
 
 /*
  * Bucket size for counting good commands in between bad ones.
@@ -2335,7 +2336,7 @@ ahd_linux_queue_abort_cmd(struct scsi_cmnd *cmd)
                         /*
                          * The sequencer will never re-reference the
                          * in-core SCB.  To make sure we are notified
-                         * during reslection, set the MK_MESSAGE flag in
+                         * during reselection, set the MK_MESSAGE flag in
                          * the card's copy of the SCB.
                          */
                         ahd_outb(ahd, SCB_CONTROL,
diff --git a/drivers/scsi/aic7xxx/aic7xxx.seq b/drivers/scsi/aic7xxx/aic7xxx.seq
index 15196390e28d..5a4cfc954a9f 100644
--- a/drivers/scsi/aic7xxx/aic7xxx.seq
+++ b/drivers/scsi/aic7xxx/aic7xxx.seq
@@ -1693,7 +1693,7 @@ if ((ahc->flags & AHC_INITIATORROLE) != 0) {
  * Is it a disconnect message?  Set a flag in the SCB to remind us
  * and await the bus going free.  If this is an untagged transaction
  * store the SCB id for it in our untagged target table for lookup on
- * a reselction.
+ * a reselection.
  */
 mesgin_disconnect:
         /*
diff --git a/drivers/scsi/aic7xxx/aic7xxx_core.c b/drivers/scsi/aic7xxx/aic7xxx_core.c
index 8dfb59d58992..45aa728a76b2 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_core.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_core.c
@@ -1733,7 +1733,7 @@ ahc_handle_scsiint(struct ahc_softc *ahc, u_int intstat)
                 /*
                  * Although the driver does not care about the
                  * 'Selection in Progress' status bit, the busy
-                 * LED does.  SELINGO is only cleared by a sucessfull
+                 * LED does.  SELINGO is only cleared by a successfull
                  * selection, so we must manually clear it to insure
                  * the LED turns off just incase no future successful
                  * selections occur (e.g. no devices on the bus).
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm.c b/drivers/scsi/aic7xxx/aic7xxx_osm.c
index fd2b9785ff4f..5e42dac23505 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm.c
@@ -129,6 +129,7 @@ static struct scsi_transport_template *ahc_linux_transport_template = NULL;
 #include <linux/mm.h>           /* For fetching system memory size */
 #include <linux/blkdev.h>               /* For block_size() */
 #include <linux/delay.h>        /* For ssleep/msleep */
+#include <linux/slab.h>
 
 
 /*
@@ -2290,7 +2291,7 @@ ahc_linux_queue_recovery_cmd(struct scsi_cmnd *cmd, scb_flag flag)
                  * In the non-paging case, the sequencer will
                  * never re-reference the in-core SCB.
                  * To make sure we are notified during
-                 * reslection, set the MK_MESSAGE flag in
+                 * reselection, set the MK_MESSAGE flag in
                  * the card's copy of the SCB.
                  */
                 if ((ahc->flags & AHC_PAGESCBS) == 0) {
diff --git a/drivers/scsi/aic94xx/aic94xx_hwi.c b/drivers/scsi/aic94xx/aic94xx_hwi.c
index eb9dc3195fdf..81b736c76fff 100644
--- a/drivers/scsi/aic94xx/aic94xx_hwi.c
+++ b/drivers/scsi/aic94xx/aic94xx_hwi.c
@@ -25,6 +25,7 @@
  */
 
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/module.h>
 #include <linux/firmware.h>
diff --git a/drivers/scsi/aic94xx/aic94xx_init.c b/drivers/scsi/aic94xx/aic94xx_init.c
index 996f7224f90e..24ac2315c5c7 100644
--- a/drivers/scsi/aic94xx/aic94xx_init.c
+++ b/drivers/scsi/aic94xx/aic94xx_init.c
@@ -30,6 +30,7 @@
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <linux/firmware.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi_host.h>
 
diff --git a/drivers/scsi/aic94xx/aic94xx_reg_def.h b/drivers/scsi/aic94xx/aic94xx_reg_def.h
index a43e8cdf4ee4..28aaf349c111 100644
--- a/drivers/scsi/aic94xx/aic94xx_reg_def.h
+++ b/drivers/scsi/aic94xx/aic94xx_reg_def.h
@@ -1,5 +1,5 @@
 /*
- * Aic94xx SAS/SATA driver hardware registers defintions.
+ * Aic94xx SAS/SATA driver hardware registers definitions.
  *
  * Copyright (C) 2004 Adaptec, Inc.  All rights reserved.
  * Copyright (C) 2004 David Chaw <david_chaw@adaptec.com>
diff --git a/drivers/scsi/aic94xx/aic94xx_scb.c b/drivers/scsi/aic94xx/aic94xx_scb.c
index ca55013b6ae5..c43698b1cb64 100644
--- a/drivers/scsi/aic94xx/aic94xx_scb.c
+++ b/drivers/scsi/aic94xx/aic94xx_scb.c
@@ -24,6 +24,7 @@
  *
  */
 
+#include <linux/gfp.h>
 #include <scsi/scsi_host.h>
 
 #include "aic94xx.h"
diff --git a/drivers/scsi/aic94xx/aic94xx_sds.c b/drivers/scsi/aic94xx/aic94xx_sds.c
index 8630a75b2872..edb43fda9f36 100644
--- a/drivers/scsi/aic94xx/aic94xx_sds.c
+++ b/drivers/scsi/aic94xx/aic94xx_sds.c
@@ -26,6 +26,7 @@
  */
 
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <linux/delay.h>
 
 #include "aic94xx.h"
diff --git a/drivers/scsi/aic94xx/aic94xx_seq.c b/drivers/scsi/aic94xx/aic94xx_seq.c
index 8f98e33155e9..d01dcc62b39a 100644
--- a/drivers/scsi/aic94xx/aic94xx_seq.c
+++ b/drivers/scsi/aic94xx/aic94xx_seq.c
@@ -27,6 +27,7 @@
  */
 
 #include <linux/delay.h>
+#include <linux/gfp.h>
 #include <linux/pci.h>
 #include <linux/module.h>
 #include <linux/firmware.h>
diff --git a/drivers/scsi/aic94xx/aic94xx_tmf.c b/drivers/scsi/aic94xx/aic94xx_tmf.c
index 78eb86fc6276..0add73bdf2a4 100644
--- a/drivers/scsi/aic94xx/aic94xx_tmf.c
+++ b/drivers/scsi/aic94xx/aic94xx_tmf.c
@@ -25,6 +25,7 @@
  */
 
 #include <linux/spinlock.h>
+#include <linux/gfp.h>
 #include "aic94xx.h"
 #include "aic94xx_sas.h"
 #include "aic94xx_hwi.h"
diff --git a/drivers/scsi/arcmsr/arcmsr_hba.c b/drivers/scsi/arcmsr/arcmsr_hba.c
index 80aac01b5a6f..ffbe2192da3c 100644
--- a/drivers/scsi/arcmsr/arcmsr_hba.c
+++ b/drivers/scsi/arcmsr/arcmsr_hba.c
@@ -58,6 +58,7 @@
 #include <linux/timer.h>
 #include <linux/pci.h>
 #include <linux/aer.h>
+#include <linux/slab.h>
 #include <asm/dma.h>
 #include <asm/io.h>
 #include <asm/system.h>
@@ -98,8 +99,11 @@ static void arcmsr_flush_hbb_cache(struct AdapterControlBlock *acb);
 static const char *arcmsr_info(struct Scsi_Host *);
 static irqreturn_t arcmsr_interrupt(struct AdapterControlBlock *acb);
 static int arcmsr_adjust_disk_queue_depth(struct scsi_device *sdev,
-                                                                int queue_depth)
+                                          int queue_depth, int reason)
 {
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
         if (queue_depth > ARCMSR_MAX_CMD_PERLUN)
                 queue_depth = ARCMSR_MAX_CMD_PERLUN;
         scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
diff --git a/drivers/scsi/arm/fas216.c b/drivers/scsi/arm/fas216.c
index 477542602284..9e71ac611146 100644
--- a/drivers/scsi/arm/fas216.c
+++ b/drivers/scsi/arm/fas216.c
@@ -2516,7 +2516,7 @@ int fas216_eh_device_reset(struct scsi_cmnd *SCpnt)
                 if (info->scsi.phase == PHASE_IDLE)
                         fas216_kick(info);
 
-                mod_timer(&info->eh_timer, 30 * HZ);
+                mod_timer(&info->eh_timer, jiffies + 30 * HZ);
                 spin_unlock_irqrestore(&info->host_lock, flags);
 
                 /*
diff --git a/drivers/scsi/atari_NCR5380.c b/drivers/scsi/atari_NCR5380.c
index 4240b05aef6d..158ebc3644d8 100644
--- a/drivers/scsi/atari_NCR5380.c
+++ b/drivers/scsi/atari_NCR5380.c
@@ -651,6 +651,7 @@ static inline void NCR5380_print_phase(struct Scsi_Host *instance)
  * interrupt or bottom half.
  */
 
+#include <linux/gfp.h>
 #include <linux/workqueue.h>
 #include <linux/interrupt.h>
 
diff --git a/drivers/scsi/atp870u.c b/drivers/scsi/atp870u.c
index b137e561f5bc..ab5bdda6903e 100644
--- a/drivers/scsi/atp870u.c
+++ b/drivers/scsi/atp870u.c
@@ -29,6 +29,7 @@
 #include <linux/pci.h>
 #include <linux/blkdev.h>
 #include <linux/dma-mapping.h>
+#include <linux/slab.h>
 #include <asm/system.h>
 #include <asm/io.h>
 
diff --git a/drivers/scsi/be2iscsi/be.h b/drivers/scsi/be2iscsi/be.h
index b36020dcf012..136b49cea791 100644
--- a/drivers/scsi/be2iscsi/be.h
+++ b/drivers/scsi/be2iscsi/be.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -20,8 +20,14 @@
 
 #include <linux/pci.h>
 #include <linux/if_vlan.h>
-
-#define FW_VER_LEN 32
+#include <linux/blk-iopoll.h>
+#define FW_VER_LEN      32
+#define MCC_Q_LEN       128
+#define MCC_CQ_LEN      256
+#define MAX_MCC_CMD     16
+/* BladeEngine Generation numbers */
+#define BE_GEN2 2
+#define BE_GEN3 3
 
 struct be_dma_mem {
         void *va;
@@ -55,6 +61,11 @@ static inline void *queue_head_node(struct be_queue_info *q)
         return q->dma_mem.va + q->head * q->entry_size;
 }
 
+static inline void *queue_get_wrb(struct be_queue_info *q, unsigned int wrb_num)
+{
+        return q->dma_mem.va + wrb_num * q->entry_size;
+}
+
 static inline void *queue_tail_node(struct be_queue_info *q)
 {
         return q->dma_mem.va + q->tail * q->entry_size;
@@ -74,18 +85,14 @@ static inline void queue_tail_inc(struct be_queue_info *q)
 
 struct be_eq_obj {
         struct be_queue_info q;
-        char desc[32];
-
-        /* Adaptive interrupt coalescing (AIC) info */
-        bool enable_aic;
-        u16 min_eqd;            /* in usecs */
-        u16 max_eqd;            /* in usecs */
-        u16 cur_eqd;            /* in usecs */
+        struct beiscsi_hba *phba;
+        struct be_queue_info *cq;
+        struct blk_iopoll       iopoll;
 };
 
 struct be_mcc_obj {
-        struct be_queue_info *q;
-        struct be_queue_info *cq;
+        struct be_queue_info q;
+        struct be_queue_info cq;
 };
 
 struct be_ctrl_info {
@@ -106,15 +113,19 @@ struct be_ctrl_info {
         spinlock_t mcc_lock;    /* For serializing mcc cmds to BE card */
         spinlock_t mcc_cq_lock;
 
-        /* MCC Async callback */
-        void (*async_cb) (void *adapter, bool link_up);
-        void *adapter_ctxt;
+        wait_queue_head_t mcc_wait[MAX_MCC_CMD + 1];
+        unsigned int mcc_tag[MAX_MCC_CMD];
+        unsigned int mcc_numtag[MAX_MCC_CMD + 1];
+        unsigned short mcc_alloc_index;
+        unsigned short mcc_free_index;
+        unsigned int mcc_tag_available;
 };
 
 #include "be_cmds.h"
 
 #define PAGE_SHIFT_4K 12
 #define PAGE_SIZE_4K (1 << PAGE_SHIFT_4K)
+#define mcc_timeout             120000 /* 5s timeout */
 
 /* Returns number of pages spanned by the data starting at the given addr */
 #define PAGES_4K_SPANNED(_address, size)                                \
@@ -176,8 +187,4 @@ static inline void swap_dws(void *wrb, int len)
         } while (len);
 #endif /* __BIG_ENDIAN */
 }
-
-extern void beiscsi_cq_notify(struct be_ctrl_info *ctrl, u16 qid, bool arm,
-                              u16 num_popped);
-
 #endif /* BEISCSI_H */
diff --git a/drivers/scsi/be2iscsi/be_cmds.c b/drivers/scsi/be2iscsi/be_cmds.c
index 08007b6e42df..cda6642c7368 100644
--- a/drivers/scsi/be2iscsi/be_cmds.c
+++ b/drivers/scsi/be2iscsi/be_cmds.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -19,6 +19,55 @@
 #include "be_mgmt.h"
 #include "be_main.h"
 
+void be_mcc_notify(struct beiscsi_hba *phba)
+{
+        struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
+        u32 val = 0;
+
+        val |= mccq->id & DB_MCCQ_RING_ID_MASK;
+        val |= 1 << DB_MCCQ_NUM_POSTED_SHIFT;
+        iowrite32(val, phba->db_va + DB_MCCQ_OFFSET);
+}
+
+unsigned int alloc_mcc_tag(struct beiscsi_hba *phba)
+{
+        unsigned int tag = 0;
+
+        if (phba->ctrl.mcc_tag_available) {
+                tag = phba->ctrl.mcc_tag[phba->ctrl.mcc_alloc_index];
+                phba->ctrl.mcc_tag[phba->ctrl.mcc_alloc_index] = 0;
+                phba->ctrl.mcc_numtag[tag] = 0;
+        }
+        if (tag) {
+                phba->ctrl.mcc_tag_available--;
+                if (phba->ctrl.mcc_alloc_index == (MAX_MCC_CMD - 1))
+                        phba->ctrl.mcc_alloc_index = 0;
+                else
+                        phba->ctrl.mcc_alloc_index++;
+        }
+        return tag;
+}
+
+void free_mcc_tag(struct be_ctrl_info *ctrl, unsigned int tag)
+{
+        spin_lock(&ctrl->mbox_lock);
+        tag = tag & 0x000000FF;
+        ctrl->mcc_tag[ctrl->mcc_free_index] = tag;
+        if (ctrl->mcc_free_index == (MAX_MCC_CMD - 1))
+                ctrl->mcc_free_index = 0;
+        else
+                ctrl->mcc_free_index++;
+        ctrl->mcc_tag_available++;
+        spin_unlock(&ctrl->mbox_lock);
+}
+
+bool is_link_state_evt(u32 trailer)
+{
+        return (((trailer >> ASYNC_TRAILER_EVENT_CODE_SHIFT) &
+                  ASYNC_TRAILER_EVENT_CODE_MASK) ==
+                  ASYNC_EVENT_CODE_LINK_STATE);
+}
+
 static inline bool be_mcc_compl_is_new(struct be_mcc_compl *compl)
 {
         if (compl->flags != 0) {
@@ -54,13 +103,74 @@ static int be_mcc_compl_process(struct be_ctrl_info *ctrl,
         return 0;
 }
 
-static inline bool is_link_state_evt(u32 trailer)
+int be_mcc_compl_process_isr(struct be_ctrl_info *ctrl,
+                                    struct be_mcc_compl *compl)
 {
-        return (((trailer >> ASYNC_TRAILER_EVENT_CODE_SHIFT) &
-                ASYNC_TRAILER_EVENT_CODE_MASK) == ASYNC_EVENT_CODE_LINK_STATE);
+        u16 compl_status, extd_status;
+        unsigned short tag;
+
+        be_dws_le_to_cpu(compl, 4);
+
+        compl_status = (compl->status >> CQE_STATUS_COMPL_SHIFT) &
+                                        CQE_STATUS_COMPL_MASK;
+        /* The ctrl.mcc_numtag[tag] is filled with
+         * [31] = valid, [30:24] = Rsvd, [23:16] = wrb, [15:8] = extd_status,
+         * [7:0] = compl_status
+         */
+        tag = (compl->tag0 & 0x000000FF);
+        extd_status = (compl->status >> CQE_STATUS_EXTD_SHIFT) &
+                                        CQE_STATUS_EXTD_MASK;
+
+        ctrl->mcc_numtag[tag]  = 0x80000000;
+        ctrl->mcc_numtag[tag] |= (compl->tag0 & 0x00FF0000);
+        ctrl->mcc_numtag[tag] |= (extd_status & 0x000000FF) << 8;
+        ctrl->mcc_numtag[tag] |= (compl_status & 0x000000FF);
+        wake_up_interruptible(&ctrl->mcc_wait[tag]);
+        return 0;
+}
+
+static struct be_mcc_compl *be_mcc_compl_get(struct beiscsi_hba *phba)
+{
+        struct be_queue_info *mcc_cq = &phba->ctrl.mcc_obj.cq;
+        struct be_mcc_compl *compl = queue_tail_node(mcc_cq);
+
+        if (be_mcc_compl_is_new(compl)) {
+                queue_tail_inc(mcc_cq);
+                return compl;
+        }
+        return NULL;
+}
+
+static void be2iscsi_fail_session(struct iscsi_cls_session *cls_session)
+{
+        iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_CONN_FAILED);
 }
 
-void beiscsi_cq_notify(struct be_ctrl_info *ctrl, u16 qid, bool arm,
+void beiscsi_async_link_state_process(struct beiscsi_hba *phba,
+                struct be_async_event_link_state *evt)
+{
+        switch (evt->port_link_status) {
+        case ASYNC_EVENT_LINK_DOWN:
+                SE_DEBUG(DBG_LVL_1, "Link Down on Physical Port %d \n",
+                                                evt->physical_port);
+                phba->state |= BE_ADAPTER_LINK_DOWN;
+                iscsi_host_for_each_session(phba->shost,
+                                            be2iscsi_fail_session);
+                break;
+        case ASYNC_EVENT_LINK_UP:
+                phba->state = BE_ADAPTER_UP;
+                SE_DEBUG(DBG_LVL_1, "Link UP on Physical Port %d \n",
+                                                evt->physical_port);
+                break;
+        default:
+                SE_DEBUG(DBG_LVL_1, "Unexpected Async Notification %d on"
+                                    "Physical Port %d \n",
+                                     evt->port_link_status,
+                                     evt->physical_port);
+        }
+}
+
+static void beiscsi_cq_notify(struct beiscsi_hba *phba, u16 qid, bool arm,
                        u16 num_popped)
 {
         u32 val = 0;
@@ -68,7 +178,69 @@ void beiscsi_cq_notify(struct be_ctrl_info *ctrl, u16 qid, bool arm,
         if (arm)
                 val |= 1 << DB_CQ_REARM_SHIFT;
         val |= num_popped << DB_CQ_NUM_POPPED_SHIFT;
-        iowrite32(val, ctrl->db + DB_CQ_OFFSET);
+        iowrite32(val, phba->db_va + DB_CQ_OFFSET);
+}
+
+
+int beiscsi_process_mcc(struct beiscsi_hba *phba)
+{
+        struct be_mcc_compl *compl;
+        int num = 0, status = 0;
+        struct be_ctrl_info *ctrl = &phba->ctrl;
+
+        spin_lock_bh(&phba->ctrl.mcc_cq_lock);
+        while ((compl = be_mcc_compl_get(phba))) {
+                if (compl->flags & CQE_FLAGS_ASYNC_MASK) {
+                        /* Interpret flags as an async trailer */
+                        if (is_link_state_evt(compl->flags))
+                                /* Interpret compl as a async link evt */
+                                beiscsi_async_link_state_process(phba,
+                                   (struct be_async_event_link_state *) compl);
+                        else
+                                SE_DEBUG(DBG_LVL_1,
+                                         " Unsupported Async Event, flags"
+                                         " = 0x%08x \n", compl->flags);
+
+                } else if (compl->flags & CQE_FLAGS_COMPLETED_MASK) {
+                                status = be_mcc_compl_process(ctrl, compl);
+                                atomic_dec(&phba->ctrl.mcc_obj.q.used);
+                }
+                be_mcc_compl_use(compl);
+                num++;
+        }
+
+        if (num)
+                beiscsi_cq_notify(phba, phba->ctrl.mcc_obj.cq.id, true, num);
+
+        spin_unlock_bh(&phba->ctrl.mcc_cq_lock);
+        return status;
+}
+
+/* Wait till no more pending mcc requests are present */
+static int be_mcc_wait_compl(struct beiscsi_hba *phba)
+{
+        int i, status;
+        for (i = 0; i < mcc_timeout; i++) {
+                status = beiscsi_process_mcc(phba);
+                if (status)
+                        return status;
+
+                if (atomic_read(&phba->ctrl.mcc_obj.q.used) == 0)
+                        break;
+                udelay(100);
+        }
+        if (i == mcc_timeout) {
+                dev_err(&phba->pcidev->dev, "mccq poll timed out\n");
+                return -1;
+        }
+        return 0;
+}
+
+/* Notify MCC requests and wait for completion */
+int be_mcc_notify_wait(struct beiscsi_hba *phba)
+{
+        be_mcc_notify(phba);
+        return be_mcc_wait_compl(phba);
 }
 
 static int be_mbox_db_ready_wait(struct be_ctrl_info *ctrl)
@@ -142,6 +314,52 @@ int be_mbox_notify(struct be_ctrl_info *ctrl)
         return 0;
 }
 
+/*
+ * Insert the mailbox address into the doorbell in two steps
+ * Polls on the mbox doorbell till a command completion (or a timeout) occurs
+ */
+static int be_mbox_notify_wait(struct beiscsi_hba *phba)
+{
+        int status;
+        u32 val = 0;
+        void __iomem *db = phba->ctrl.db + MPU_MAILBOX_DB_OFFSET;
+        struct be_dma_mem *mbox_mem = &phba->ctrl.mbox_mem;
+        struct be_mcc_mailbox *mbox = mbox_mem->va;
+        struct be_mcc_compl *compl = &mbox->compl;
+        struct be_ctrl_info *ctrl = &phba->ctrl;
+
+        val |= MPU_MAILBOX_DB_HI_MASK;
+        /* at bits 2 - 31 place mbox dma addr msb bits 34 - 63 */
+        val |= (upper_32_bits(mbox_mem->dma) >> 2) << 2;
+        iowrite32(val, db);
+
+        /* wait for ready to be set */
+        status = be_mbox_db_ready_wait(ctrl);
+        if (status != 0)
+                return status;
+
+        val = 0;
+        /* at bits 2 - 31 place mbox dma addr lsb bits 4 - 33 */
+        val |= (u32)(mbox_mem->dma >> 4) << 2;
+        iowrite32(val, db);
+
+        status = be_mbox_db_ready_wait(ctrl);
+        if (status != 0)
+                return status;
+
+        /* A cq entry has been made now */
+        if (be_mcc_compl_is_new(compl)) {
+                status = be_mcc_compl_process(ctrl, &mbox->compl);
+                be_mcc_compl_use(compl);
+                if (status)
+                        return status;
+        } else {
+                dev_err(&phba->pcidev->dev, "invalid mailbox completion\n");
+                return -1;
+        }
+        return 0;
+}
+
 void be_wrb_hdr_prepare(struct be_mcc_wrb *wrb, int payload_len,
                                 bool embedded, u8 sge_cnt)
 {
@@ -203,6 +421,21 @@ struct be_mcc_wrb *wrb_from_mbox(struct be_dma_mem *mbox_mem)
         return &((struct be_mcc_mailbox *)(mbox_mem->va))->wrb;
 }
 
+struct be_mcc_wrb *wrb_from_mccq(struct beiscsi_hba *phba)
+{
+        struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
+        struct be_mcc_wrb *wrb;
+
+        BUG_ON(atomic_read(&mccq->used) >= mccq->len);
+        wrb = queue_head_node(mccq);
+        memset(wrb, 0, sizeof(*wrb));
+        wrb->tag0 = (mccq->head & 0x000000FF) << 16;
+        queue_head_inc(mccq);
+        atomic_inc(&mccq->used);
+        return wrb;
+}
+
+
 int beiscsi_cmd_eq_create(struct be_ctrl_info *ctrl,
                           struct be_queue_info *eq, int eq_delay)
 {
@@ -212,6 +445,7 @@ int beiscsi_cmd_eq_create(struct be_ctrl_info *ctrl,
         struct be_dma_mem *q_mem = &eq->dma_mem;
         int status;
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_cmd_eq_create\n");
         spin_lock(&ctrl->mbox_lock);
         memset(wrb, 0, sizeof(*wrb));
 
@@ -249,6 +483,7 @@ int be_cmd_fw_initialize(struct be_ctrl_info *ctrl)
         int status;
         u8 *endian_check;
 
+        SE_DEBUG(DBG_LVL_8, "In be_cmd_fw_initialize\n");
         spin_lock(&ctrl->mbox_lock);
         memset(wrb, 0, sizeof(*wrb));
 
@@ -282,6 +517,7 @@ int beiscsi_cmd_cq_create(struct be_ctrl_info *ctrl,
         void *ctxt = &req->context;
         int status;
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_cmd_cq_create \n");
         spin_lock(&ctrl->mbox_lock);
         memset(wrb, 0, sizeof(*wrb));
 
@@ -289,7 +525,6 @@ int beiscsi_cmd_cq_create(struct be_ctrl_info *ctrl,
 
         be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
                         OPCODE_COMMON_CQ_CREATE, sizeof(*req));
-
         if (!q_mem->va)
                 SE_DEBUG(DBG_LVL_1, "uninitialized q_mem->va\n");
 
@@ -329,6 +564,53 @@ static u32 be_encoded_q_len(int q_len)
                 len_encoded = 0;
         return len_encoded;
 }
+
+int beiscsi_cmd_mccq_create(struct beiscsi_hba *phba,
+                        struct be_queue_info *mccq,
+                        struct be_queue_info *cq)
+{
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_req_mcc_create *req;
+        struct be_dma_mem *q_mem = &mccq->dma_mem;
+        struct be_ctrl_info *ctrl;
+        void *ctxt;
+        int status;
+
+        spin_lock(&phba->ctrl.mbox_lock);
+        ctrl = &phba->ctrl;
+        wrb = wrb_from_mbox(&ctrl->mbox_mem);
+        req = embedded_payload(wrb);
+        ctxt = &req->context;
+
+        be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
+
+        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
+                        OPCODE_COMMON_MCC_CREATE, sizeof(*req));
+
+        req->num_pages = PAGES_4K_SPANNED(q_mem->va, q_mem->size);
+
+        AMAP_SET_BITS(struct amap_mcc_context, fid, ctxt,
+                      PCI_FUNC(phba->pcidev->devfn));
+        AMAP_SET_BITS(struct amap_mcc_context, valid, ctxt, 1);
+        AMAP_SET_BITS(struct amap_mcc_context, ring_size, ctxt,
+                be_encoded_q_len(mccq->len));
+        AMAP_SET_BITS(struct amap_mcc_context, cq_id, ctxt, cq->id);
+
+        be_dws_cpu_to_le(ctxt, sizeof(req->context));
+
+        be_cmd_page_addrs_prepare(req->pages, ARRAY_SIZE(req->pages), q_mem);
+
+        status = be_mbox_notify_wait(phba);
+        if (!status) {
+                struct be_cmd_resp_mcc_create *resp = embedded_payload(wrb);
+                mccq->id = le16_to_cpu(resp->id);
+                mccq->created = true;
+        }
+        spin_unlock(&phba->ctrl.mbox_lock);
+
+        return status;
+}
+
 int beiscsi_cmd_q_destroy(struct be_ctrl_info *ctrl, struct be_queue_info *q,
                           int queue_type)
 {
@@ -337,6 +619,7 @@ int beiscsi_cmd_q_destroy(struct be_ctrl_info *ctrl, struct be_queue_info *q,
         u8 subsys = 0, opcode = 0;
         int status;
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_cmd_q_destroy \n");
         spin_lock(&ctrl->mbox_lock);
         memset(wrb, 0, sizeof(*wrb));
         be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
@@ -350,6 +633,10 @@ int beiscsi_cmd_q_destroy(struct be_ctrl_info *ctrl, struct be_queue_info *q,
                 subsys = CMD_SUBSYSTEM_COMMON;
                 opcode = OPCODE_COMMON_CQ_DESTROY;
                 break;
+        case QTYPE_MCCQ:
+                subsys = CMD_SUBSYSTEM_COMMON;
+                opcode = OPCODE_COMMON_MCC_DESTROY;
+                break;
         case QTYPE_WRBQ:
                 subsys = CMD_SUBSYSTEM_ISCSI;
                 opcode = OPCODE_COMMON_ISCSI_WRBQ_DESTROY;
@@ -377,30 +664,6 @@ int beiscsi_cmd_q_destroy(struct be_ctrl_info *ctrl, struct be_queue_info *q,
         return status;
 }
 
-int be_cmd_get_mac_addr(struct be_ctrl_info *ctrl, u8 *mac_addr)
-{
-        struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
-        struct be_cmd_req_get_mac_addr *req = embedded_payload(wrb);
-        int status;
-
-        spin_lock(&ctrl->mbox_lock);
-        memset(wrb, 0, sizeof(*wrb));
-        be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
-        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
-                           OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG,
-                           sizeof(*req));
-
-        status = be_mbox_notify(ctrl);
-        if (!status) {
-                struct be_cmd_resp_get_mac_addr *resp = embedded_payload(wrb);
-
-                memcpy(mac_addr, resp->mac_address, ETH_ALEN);
-        }
-
-        spin_unlock(&ctrl->mbox_lock);
-        return status;
-}
-
 int be_cmd_create_default_pdu_queue(struct be_ctrl_info *ctrl,
                                     struct be_queue_info *cq,
                                     struct be_queue_info *dq, int length,
@@ -412,6 +675,7 @@ int be_cmd_create_default_pdu_queue(struct be_ctrl_info *ctrl,
         void *ctxt = &req->context;
         int status;
 
+        SE_DEBUG(DBG_LVL_8, "In be_cmd_create_default_pdu_queue\n");
         spin_lock(&ctrl->mbox_lock);
         memset(wrb, 0, sizeof(*wrb));
 
@@ -468,8 +732,10 @@ int be_cmd_wrbq_create(struct be_ctrl_info *ctrl, struct be_dma_mem *q_mem,
         be_cmd_page_addrs_prepare(req->pages, ARRAY_SIZE(req->pages), q_mem);
 
         status = be_mbox_notify(ctrl);
-        if (!status)
+        if (!status) {
                 wrbq->id = le16_to_cpu(resp->cid);
+                wrbq->created = true;
+        }
         spin_unlock(&ctrl->mbox_lock);
         return status;
 }
diff --git a/drivers/scsi/be2iscsi/be_cmds.h b/drivers/scsi/be2iscsi/be_cmds.h
index c20d686cbb43..49fcc787ee8b 100644
--- a/drivers/scsi/be2iscsi/be_cmds.h
+++ b/drivers/scsi/be2iscsi/be_cmds.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -47,6 +47,8 @@ struct be_mcc_wrb {
 
 #define CQE_FLAGS_VALID_MASK (1 << 31)
 #define CQE_FLAGS_ASYNC_MASK (1 << 30)
+#define CQE_FLAGS_COMPLETED_MASK        (1 << 28)
+#define CQE_FLAGS_CONSUMED_MASK         (1 << 27)
 
 /* Completion Status */
 #define MCC_STATUS_SUCCESS 0x0
@@ -173,7 +175,7 @@ struct be_cmd_req_hdr {
         u8 domain;              /* dword 0 */
         u32 timeout;            /* dword 1 */
         u32 request_length;     /* dword 2 */
-        u32 rsvd;               /* dword 3 */
+        u32 rsvd0;              /* dword 3 */
 };
 
 struct be_cmd_resp_hdr {
@@ -382,7 +384,6 @@ struct be_cmd_req_modify_eq_delay {
 
 #define ETH_ALEN        6
 
-
 struct be_cmd_req_get_mac_addr {
         struct be_cmd_req_hdr hdr;
         u32 nic_port_count;
@@ -417,14 +418,27 @@ int beiscsi_cmd_cq_create(struct be_ctrl_info *ctrl,
 
 int beiscsi_cmd_q_destroy(struct be_ctrl_info *ctrl, struct be_queue_info *q,
                           int type);
-int be_poll_mcc(struct be_ctrl_info *ctrl);
-unsigned char mgmt_check_supported_fw(struct be_ctrl_info *ctrl);
-int be_cmd_get_mac_addr(struct be_ctrl_info *ctrl, u8 *mac_addr);
+int beiscsi_cmd_mccq_create(struct beiscsi_hba *phba,
+                        struct be_queue_info *mccq,
+                        struct be_queue_info *cq);
 
+int be_poll_mcc(struct be_ctrl_info *ctrl);
+unsigned char mgmt_check_supported_fw(struct be_ctrl_info *ctrl,
+                                      struct beiscsi_hba *phba);
+unsigned int be_cmd_get_mac_addr(struct beiscsi_hba *phba);
+void free_mcc_tag(struct be_ctrl_info *ctrl, unsigned int tag);
 /*ISCSI Functuions */
 int be_cmd_fw_initialize(struct be_ctrl_info *ctrl);
 
 struct be_mcc_wrb *wrb_from_mbox(struct be_dma_mem *mbox_mem);
+struct be_mcc_wrb *wrb_from_mccq(struct beiscsi_hba *phba);
+int be_mcc_notify_wait(struct beiscsi_hba *phba);
+void be_mcc_notify(struct beiscsi_hba *phba);
+unsigned int alloc_mcc_tag(struct beiscsi_hba *phba);
+void beiscsi_async_link_state_process(struct beiscsi_hba *phba,
+                struct be_async_event_link_state *evt);
+int be_mcc_compl_process_isr(struct be_ctrl_info *ctrl,
+                                    struct be_mcc_compl *compl);
 
 int be_mbox_notify(struct be_ctrl_info *ctrl);
 
@@ -440,6 +454,8 @@ int be_cmd_iscsi_post_sgl_pages(struct be_ctrl_info *ctrl,
 int be_cmd_wrbq_create(struct be_ctrl_info *ctrl, struct be_dma_mem *q_mem,
                        struct be_queue_info *wrbq);
 
+bool is_link_state_evt(u32 trailer);
+
 struct be_default_pdu_context {
         u32 dw[4];
 } __packed;
@@ -531,6 +547,23 @@ struct amap_sol_cqe {
         u8 valid;               /* dword 3 */
 } __packed;
 
+#define SOL_ICD_INDEX_MASK      0x0003FFC0
+struct amap_sol_cqe_ring {
+        u8 hw_sts[8];           /* dword 0 */
+        u8 i_sts[8];            /* dword 0 */
+        u8 i_resp[8];           /* dword 0 */
+        u8 i_flags[7];          /* dword 0 */
+        u8 s;                   /* dword 0 */
+        u8 i_exp_cmd_sn[32];    /* dword 1 */
+        u8 code[6];             /* dword 2 */
+        u8 icd_index[12];       /* dword 2 */
+        u8 rsvd[6];             /* dword 2 */
+        u8 i_cmd_wnd[8];        /* dword 2 */
+        u8 i_res_cnt[31];       /* dword 3 */
+        u8 valid;               /* dword 3 */
+} __packed;
+
+
 
 /**
  * Post WRB Queue Doorbell Register used by the host Storage
@@ -664,8 +697,8 @@ struct be_fw_cfg {
 #define OPCODE_COMMON_TCP_UPLOAD        56
 #define OPCODE_COMMON_ISCSI_ERROR_RECOVERY_INVALIDATE_COMMANDS 1
 /* --- CMD_ISCSI_INVALIDATE_CONNECTION_TYPE --- */
-#define CMD_ISCSI_CONNECTION_INVALIDATE 1
-#define CMD_ISCSI_CONNECTION_ISSUE_TCP_RST 2
+#define CMD_ISCSI_CONNECTION_INVALIDATE 0x8001
+#define CMD_ISCSI_CONNECTION_ISSUE_TCP_RST 0x8002
 #define OPCODE_ISCSI_INI_DRIVER_INVALIDATE_CONNECTION 42
 
 #define INI_WR_CMD                      1       /* Initiator write command */
diff --git a/drivers/scsi/be2iscsi/be_iscsi.c b/drivers/scsi/be2iscsi/be_iscsi.c
index 2fd25442cfaf..c3928cb8b042 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.c
+++ b/drivers/scsi/be2iscsi/be_iscsi.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -67,11 +67,11 @@ struct iscsi_cls_session *beiscsi_session_create(struct iscsi_endpoint *ep,
                 cmds_max = beiscsi_ep->phba->params.wrbs_per_cxn;
         }
 
-         cls_session = iscsi_session_setup(&beiscsi_iscsi_transport,
-                                           shost, cmds_max,
-                                           sizeof(*beiscsi_sess),
-                                           sizeof(*io_task),
-                                           initial_cmdsn, ISCSI_MAX_TARGET);
+        cls_session = iscsi_session_setup(&beiscsi_iscsi_transport,
+                                          shost, cmds_max,
+                                          sizeof(*beiscsi_sess),
+                                          sizeof(*io_task),
+                                          initial_cmdsn, ISCSI_MAX_TARGET);
         if (!cls_session)
                 return NULL;
         sess = cls_session->dd_data;
@@ -101,6 +101,7 @@ void beiscsi_session_destroy(struct iscsi_cls_session *cls_session)
         struct iscsi_session *sess = cls_session->dd_data;
         struct beiscsi_session *beiscsi_sess = sess->dd_data;
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_session_destroy\n");
         pci_pool_destroy(beiscsi_sess->bhs_pool);
         iscsi_session_teardown(cls_session);
 }
@@ -224,6 +225,7 @@ int beiscsi_conn_get_param(struct iscsi_cls_conn *cls_conn,
         struct beiscsi_conn *beiscsi_conn = conn->dd_data;
         int len = 0;
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_conn_get_param, param= %d\n", param);
         beiscsi_ep = beiscsi_conn->ep;
         if (!beiscsi_ep) {
                 SE_DEBUG(DBG_LVL_1,
@@ -254,6 +256,7 @@ int beiscsi_set_param(struct iscsi_cls_conn *cls_conn,
         struct iscsi_session *session = conn->session;
         int ret;
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_conn_set_param, param= %d\n", param);
         ret = iscsi_set_param(cls_conn, param, buf, buflen);
         if (ret)
                 return ret;
@@ -271,8 +274,8 @@ int beiscsi_set_param(struct iscsi_cls_conn *cls_conn,
                         conn->max_recv_dlength = 65536;
                 break;
         case ISCSI_PARAM_MAX_BURST:
-                if (session->first_burst > 262144)
-                        session->first_burst = 262144;
+                if (session->max_burst > 262144)
+                        session->max_burst = 262144;
                 break;
         default:
                 return 0;
@@ -293,12 +296,41 @@ int beiscsi_get_host_param(struct Scsi_Host *shost,
                            enum iscsi_host_param param, char *buf)
 {
         struct beiscsi_hba *phba = (struct beiscsi_hba *)iscsi_host_priv(shost);
+        struct be_cmd_resp_get_mac_addr *resp;
+        struct be_mcc_wrb *wrb;
+        unsigned int tag, wrb_num;
         int len = 0;
+        unsigned short status, extd_status;
+        struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_get_host_param, param= %d\n", param);
         switch (param) {
         case ISCSI_HOST_PARAM_HWADDRESS:
-                be_cmd_get_mac_addr(&phba->ctrl, phba->mac_address);
-                len = sysfs_format_mac(buf, phba->mac_address, ETH_ALEN);
+                tag = be_cmd_get_mac_addr(phba);
+                if (!tag) {
+                        SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed \n");
+                        return -1;
+                } else
+                        wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                                 phba->ctrl.mcc_numtag[tag]);
+
+                wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
+                extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
+                status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
+                if (status || extd_status) {
+                        SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed"
+                                            " status = %d extd_status = %d \n",
+                                            status, extd_status);
+                        free_mcc_tag(&phba->ctrl, tag);
+                        return -1;
+                } else {
+                        wrb = queue_get_wrb(mccq, wrb_num);
+                        free_mcc_tag(&phba->ctrl, tag);
+                        resp = embedded_payload(wrb);
+                        memcpy(phba->mac_address, resp->mac_address, ETH_ALEN);
+                        len = sysfs_format_mac(buf, phba->mac_address,
+                                               ETH_ALEN);
+                }
                 break;
         default:
                 return iscsi_host_get_param(shost, param, buf);
@@ -377,16 +409,13 @@ int beiscsi_conn_start(struct iscsi_cls_conn *cls_conn)
         struct beiscsi_conn *beiscsi_conn = conn->dd_data;
         struct beiscsi_endpoint *beiscsi_ep;
         struct beiscsi_offload_params params;
-        struct iscsi_session *session = conn->session;
-        struct Scsi_Host *shost = iscsi_session_to_shost(session->cls_session);
-        struct beiscsi_hba *phba = iscsi_host_priv(shost);
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_conn_start\n");
         memset(&params, 0, sizeof(struct beiscsi_offload_params));
         beiscsi_ep = beiscsi_conn->ep;
         if (!beiscsi_ep)
                 SE_DEBUG(DBG_LVL_1, "In beiscsi_conn_start , no beiscsi_ep\n");
 
-        free_mgmt_sgl_handle(phba, beiscsi_conn->plogin_sgl_handle);
         beiscsi_conn->login_in_progress = 0;
         beiscsi_set_params_for_offld(beiscsi_conn, &params);
         beiscsi_offload_connection(beiscsi_conn, &params);
@@ -426,8 +455,14 @@ static int beiscsi_open_conn(struct iscsi_endpoint *ep,
 {
         struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
         struct beiscsi_hba *phba = beiscsi_ep->phba;
+        struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
+        struct be_mcc_wrb *wrb;
+        struct tcp_connect_and_offload_out *ptcpcnct_out;
+        unsigned short status, extd_status;
+        unsigned int tag, wrb_num;
         int ret = -1;
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_open_conn\n");
         beiscsi_ep->ep_cid = beiscsi_get_cid(phba);
         if (beiscsi_ep->ep_cid == 0xFFFF) {
                 SE_DEBUG(DBG_LVL_1, "No free cid available\n");
@@ -435,15 +470,44 @@ static int beiscsi_open_conn(struct iscsi_endpoint *ep,
         }
         SE_DEBUG(DBG_LVL_8, "In beiscsi_open_conn, ep_cid=%d ",
                  beiscsi_ep->ep_cid);
-        phba->ep_array[beiscsi_ep->ep_cid] = ep;
-        if (beiscsi_ep->ep_cid >
-            (phba->fw_config.iscsi_cid_start + phba->params.cxns_per_ctrl)) {
+        phba->ep_array[beiscsi_ep->ep_cid -
+                       phba->fw_config.iscsi_cid_start] = ep;
+        if (beiscsi_ep->ep_cid > (phba->fw_config.iscsi_cid_start +
+                                  phba->params.cxns_per_ctrl * 2)) {
                 SE_DEBUG(DBG_LVL_1, "Failed in allocate iscsi cid\n");
                 return ret;
         }
 
         beiscsi_ep->cid_vld = 0;
-        return mgmt_open_connection(phba, dst_addr, beiscsi_ep);
+        tag = mgmt_open_connection(phba, dst_addr, beiscsi_ep);
+        if (!tag) {
+                SE_DEBUG(DBG_LVL_1,
+                         "mgmt_open_connection Failed for cid=%d \n",
+                         beiscsi_ep->ep_cid);
+        } else {
+                wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                         phba->ctrl.mcc_numtag[tag]);
+        }
+        wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
+        extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
+        status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
+        if (status || extd_status) {
+                SE_DEBUG(DBG_LVL_1, "mgmt_open_connection Failed"
+                                    " status = %d extd_status = %d \n",
+                                    status, extd_status);
+                free_mcc_tag(&phba->ctrl, tag);
+                return -1;
+        } else {
+                wrb = queue_get_wrb(mccq, wrb_num);
+                free_mcc_tag(&phba->ctrl, tag);
+
+                ptcpcnct_out =  embedded_payload(wrb);
+                beiscsi_ep = ep->dd_data;
+                beiscsi_ep->fw_handle = ptcpcnct_out->connection_handle;
+                beiscsi_ep->cid_vld = 1;
+                SE_DEBUG(DBG_LVL_8, "mgmt_open_connection Success\n");
+        }
+        return 0;
 }
 
 /**
@@ -463,14 +527,12 @@ static void beiscsi_put_cid(struct beiscsi_hba *phba, unsigned short cid)
  * beiscsi_free_ep - free endpoint
  * @ep: pointer to iscsi endpoint structure
  */
-static void beiscsi_free_ep(struct iscsi_endpoint *ep)
+static void beiscsi_free_ep(struct beiscsi_endpoint *beiscsi_ep)
 {
-        struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
         struct beiscsi_hba *phba = beiscsi_ep->phba;
 
         beiscsi_put_cid(phba, beiscsi_ep->ep_cid);
         beiscsi_ep->phba = NULL;
-        iscsi_destroy_endpoint(ep);
 }
 
 /**
@@ -498,6 +560,13 @@ beiscsi_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
                 SE_DEBUG(DBG_LVL_1, "shost is NULL \n");
                 return ERR_PTR(ret);
         }
+
+        if (phba->state != BE_ADAPTER_UP) {
+                ret = -EBUSY;
+                SE_DEBUG(DBG_LVL_1, "The Adapter state is Not UP \n");
+                return ERR_PTR(ret);
+        }
+
         ep = iscsi_create_endpoint(sizeof(struct beiscsi_endpoint));
         if (!ep) {
                 ret = -ENOMEM;
@@ -506,9 +575,9 @@ beiscsi_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
 
         beiscsi_ep = ep->dd_data;
         beiscsi_ep->phba = phba;
-
+        beiscsi_ep->openiscsi_ep = ep;
         if (beiscsi_open_conn(ep, NULL, dst_addr, non_blocking)) {
-                SE_DEBUG(DBG_LVL_1, "Failed in allocate iscsi cid\n");
+                SE_DEBUG(DBG_LVL_1, "Failed in beiscsi_open_conn \n");
                 ret = -ENOMEM;
                 goto free_ep;
         }
@@ -516,7 +585,7 @@ beiscsi_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
         return ep;
 
 free_ep:
-        beiscsi_free_ep(ep);
+        beiscsi_free_ep(beiscsi_ep);
         return ERR_PTR(ret);
 }
 
@@ -543,20 +612,22 @@ int beiscsi_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
  * @ep: The iscsi endpoint
  * @flag: The type of connection closure
  */
-static int beiscsi_close_conn(struct iscsi_endpoint *ep, int flag)
+static int beiscsi_close_conn(struct  beiscsi_endpoint *beiscsi_ep, int flag)
 {
         int ret = 0;
-        struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
+        unsigned int tag;
         struct beiscsi_hba *phba = beiscsi_ep->phba;
 
-        if (MGMT_STATUS_SUCCESS !=
-            mgmt_upload_connection(phba, beiscsi_ep->ep_cid,
-                CONNECTION_UPLOAD_GRACEFUL)) {
+        tag = mgmt_upload_connection(phba, beiscsi_ep->ep_cid, flag);
+        if (!tag) {
                 SE_DEBUG(DBG_LVL_8, "upload failed for cid 0x%x",
                          beiscsi_ep->ep_cid);
                 ret = -1;
+        } else {
+                wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                         phba->ctrl.mcc_numtag[tag]);
+                free_mcc_tag(&phba->ctrl, tag);
         }
-
         return ret;
 }
 
@@ -571,19 +642,17 @@ void beiscsi_ep_disconnect(struct iscsi_endpoint *ep)
         struct beiscsi_conn *beiscsi_conn;
         struct beiscsi_endpoint *beiscsi_ep;
         struct beiscsi_hba *phba;
-        int flag = 0;
 
         beiscsi_ep = ep->dd_data;
         phba = beiscsi_ep->phba;
-        SE_DEBUG(DBG_LVL_8, "In beiscsi_ep_disconnect\n");
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_ep_disconnect for ep_cid = %d\n",
+                             beiscsi_ep->ep_cid);
 
         if (beiscsi_ep->conn) {
                 beiscsi_conn = beiscsi_ep->conn;
                 iscsi_suspend_queue(beiscsi_conn->conn);
-                beiscsi_close_conn(ep, flag);
         }
 
-        beiscsi_free_ep(ep);
 }
 
 /**
@@ -616,23 +685,31 @@ void beiscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
         struct iscsi_session *session = conn->session;
         struct Scsi_Host *shost = iscsi_session_to_shost(session->cls_session);
         struct beiscsi_hba *phba = iscsi_host_priv(shost);
-        unsigned int status;
+        unsigned int tag;
         unsigned short savecfg_flag = CMD_ISCSI_SESSION_SAVE_CFG_ON_FLASH;
 
-        SE_DEBUG(DBG_LVL_8, "In beiscsi_conn_stop\n");
         beiscsi_ep = beiscsi_conn->ep;
         if (!beiscsi_ep) {
                 SE_DEBUG(DBG_LVL_8, "In beiscsi_conn_stop , no beiscsi_ep\n");
                 return;
         }
-        status = mgmt_invalidate_connection(phba, beiscsi_ep,
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_conn_stop  ep_cid = %d\n",
+                             beiscsi_ep->ep_cid);
+        tag = mgmt_invalidate_connection(phba, beiscsi_ep,
                                             beiscsi_ep->ep_cid, 1,
                                             savecfg_flag);
-        if (status != MGMT_STATUS_SUCCESS) {
+        if (!tag) {
                 SE_DEBUG(DBG_LVL_1,
                          "mgmt_invalidate_connection Failed for cid=%d \n",
-                         beiscsi_ep->ep_cid);
+                          beiscsi_ep->ep_cid);
+        } else {
+                wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                         phba->ctrl.mcc_numtag[tag]);
+                free_mcc_tag(&phba->ctrl, tag);
         }
+        beiscsi_close_conn(beiscsi_ep, CONNECTION_UPLOAD_GRACEFUL);
+        beiscsi_free_ep(beiscsi_ep);
+        iscsi_destroy_endpoint(beiscsi_ep->openiscsi_ep);
         beiscsi_unbind_conn_to_cid(phba, beiscsi_ep->ep_cid);
         iscsi_conn_stop(cls_conn, flag);
 }
diff --git a/drivers/scsi/be2iscsi/be_iscsi.h b/drivers/scsi/be2iscsi/be_iscsi.h
index f92ffc5349fb..1f512c28cbf9 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.h
+++ b/drivers/scsi/be2iscsi/be_iscsi.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 4f1aca346e38..dd5b105f8f47 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -19,6 +19,7 @@
  */
 #include <linux/reboot.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/blkdev.h>
 #include <linux/pci.h>
@@ -39,7 +40,7 @@
 
 static unsigned int be_iopoll_budget = 10;
 static unsigned int be_max_phys_size = 64;
-static unsigned int enable_msix;
+static unsigned int enable_msix = 1;
 
 MODULE_DEVICE_TABLE(pci, beiscsi_pci_id_table);
 MODULE_DESCRIPTION(DRV_DESC " " BUILD_STR);
@@ -58,17 +59,145 @@ static int beiscsi_slave_configure(struct scsi_device *sdev)
         return 0;
 }
 
+static int beiscsi_eh_abort(struct scsi_cmnd *sc)
+{
+        struct iscsi_cls_session *cls_session;
+        struct iscsi_task *aborted_task = (struct iscsi_task *)sc->SCp.ptr;
+        struct beiscsi_io_task *aborted_io_task;
+        struct iscsi_conn *conn;
+        struct beiscsi_conn *beiscsi_conn;
+        struct beiscsi_hba *phba;
+        struct iscsi_session *session;
+        struct invalidate_command_table *inv_tbl;
+        unsigned int cid, tag, num_invalidate;
+
+        cls_session = starget_to_session(scsi_target(sc->device));
+        session = cls_session->dd_data;
+
+        spin_lock_bh(&session->lock);
+        if (!aborted_task || !aborted_task->sc) {
+                /* we raced */
+                spin_unlock_bh(&session->lock);
+                return SUCCESS;
+        }
+
+        aborted_io_task = aborted_task->dd_data;
+        if (!aborted_io_task->scsi_cmnd) {
+                /* raced or invalid command */
+                spin_unlock_bh(&session->lock);
+                return SUCCESS;
+        }
+        spin_unlock_bh(&session->lock);
+        conn = aborted_task->conn;
+        beiscsi_conn = conn->dd_data;
+        phba = beiscsi_conn->phba;
+
+        /* invalidate iocb */
+        cid = beiscsi_conn->beiscsi_conn_cid;
+        inv_tbl = phba->inv_tbl;
+        memset(inv_tbl, 0x0, sizeof(*inv_tbl));
+        inv_tbl->cid = cid;
+        inv_tbl->icd = aborted_io_task->psgl_handle->sgl_index;
+        num_invalidate = 1;
+        tag = mgmt_invalidate_icds(phba, inv_tbl, num_invalidate, cid);
+        if (!tag) {
+                shost_printk(KERN_WARNING, phba->shost,
+                             "mgmt_invalidate_icds could not be"
+                             " submitted\n");
+                return FAILED;
+        } else {
+                wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                         phba->ctrl.mcc_numtag[tag]);
+                free_mcc_tag(&phba->ctrl, tag);
+        }
+
+        return iscsi_eh_abort(sc);
+}
+
+static int beiscsi_eh_device_reset(struct scsi_cmnd *sc)
+{
+        struct iscsi_task *abrt_task;
+        struct beiscsi_io_task *abrt_io_task;
+        struct iscsi_conn *conn;
+        struct beiscsi_conn *beiscsi_conn;
+        struct beiscsi_hba *phba;
+        struct iscsi_session *session;
+        struct iscsi_cls_session *cls_session;
+        struct invalidate_command_table *inv_tbl;
+        unsigned int cid, tag, i, num_invalidate;
+        int rc = FAILED;
+
+        /* invalidate iocbs */
+        cls_session = starget_to_session(scsi_target(sc->device));
+        session = cls_session->dd_data;
+        spin_lock_bh(&session->lock);
+        if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN)
+                goto unlock;
+
+        conn = session->leadconn;
+        beiscsi_conn = conn->dd_data;
+        phba = beiscsi_conn->phba;
+        cid = beiscsi_conn->beiscsi_conn_cid;
+        inv_tbl = phba->inv_tbl;
+        memset(inv_tbl, 0x0, sizeof(*inv_tbl) * BE2_CMDS_PER_CXN);
+        num_invalidate = 0;
+        for (i = 0; i < conn->session->cmds_max; i++) {
+                abrt_task = conn->session->cmds[i];
+                abrt_io_task = abrt_task->dd_data;
+                if (!abrt_task->sc || abrt_task->state == ISCSI_TASK_FREE)
+                        continue;
+
+                if (abrt_task->sc->device->lun != abrt_task->sc->device->lun)
+                        continue;
+
+                inv_tbl->cid = cid;
+                inv_tbl->icd = abrt_io_task->psgl_handle->sgl_index;
+                num_invalidate++;
+                inv_tbl++;
+        }
+        spin_unlock_bh(&session->lock);
+        inv_tbl = phba->inv_tbl;
+
+        tag = mgmt_invalidate_icds(phba, inv_tbl, num_invalidate, cid);
+        if (!tag) {
+                shost_printk(KERN_WARNING, phba->shost,
+                             "mgmt_invalidate_icds could not be"
+                             " submitted\n");
+                return FAILED;
+        } else {
+                wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                         phba->ctrl.mcc_numtag[tag]);
+                free_mcc_tag(&phba->ctrl, tag);
+        }
+
+        return iscsi_eh_device_reset(sc);
+unlock:
+        spin_unlock_bh(&session->lock);
+        return rc;
+}
+
+/*------------------- PCI Driver operations and data ----------------- */
+static DEFINE_PCI_DEVICE_TABLE(beiscsi_pci_id_table) = {
+        { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
+        { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
+        { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
+        { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
+        { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID3) },
+        { 0 }
+};
+MODULE_DEVICE_TABLE(pci, beiscsi_pci_id_table);
+
 static struct scsi_host_template beiscsi_sht = {
         .module = THIS_MODULE,
         .name = "ServerEngines 10Gbe open-iscsi Initiator Driver",
         .proc_name = DRV_NAME,
         .queuecommand = iscsi_queuecommand,
-        .eh_abort_handler = iscsi_eh_abort,
         .change_queue_depth = iscsi_change_queue_depth,
         .slave_configure = beiscsi_slave_configure,
         .target_alloc = iscsi_target_alloc,
-        .eh_device_reset_handler = iscsi_eh_device_reset,
-        .eh_target_reset_handler = iscsi_eh_target_reset,
+        .eh_abort_handler = beiscsi_eh_abort,
+        .eh_device_reset_handler = beiscsi_eh_device_reset,
+        .eh_target_reset_handler = iscsi_eh_session_reset,
         .sg_tablesize = BEISCSI_SGLIST_ELEMENTS,
         .can_queue = BE2_IO_DEPTH,
         .this_id = -1,
@@ -76,16 +205,8 @@ static struct scsi_host_template beiscsi_sht = {
         .cmd_per_lun = BEISCSI_CMD_PER_LUN,
         .use_clustering = ENABLE_CLUSTERING,
 };
-static struct scsi_transport_template *beiscsi_scsi_transport;
 
-/*------------------- PCI Driver operations and data ----------------- */
-static DEFINE_PCI_DEVICE_TABLE(beiscsi_pci_id_table) = {
-        { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
-        { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
-        { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
-        { 0 }
-};
-MODULE_DEVICE_TABLE(pci, beiscsi_pci_id_table);
+static struct scsi_transport_template *beiscsi_scsi_transport;
 
 static struct beiscsi_hba *beiscsi_hba_alloc(struct pci_dev *pcidev)
 {
@@ -104,11 +225,11 @@ static struct beiscsi_hba *beiscsi_hba_alloc(struct pci_dev *pcidev)
         shost->max_cmd_len = BEISCSI_MAX_CMD_LEN;
         shost->max_lun = BEISCSI_NUM_MAX_LUN;
         shost->transportt = beiscsi_scsi_transport;
-
         phba = iscsi_host_priv(shost);
         memset(phba, 0, sizeof(*phba));
         phba->shost = shost;
         phba->pcidev = pci_dev_get(pcidev);
+        pci_set_drvdata(pcidev, phba);
 
         if (iscsi_host_add(shost, &phba->pcidev->dev))
                 goto free_devices;
@@ -140,6 +261,7 @@ static int beiscsi_map_pci_bars(struct beiscsi_hba *phba,
                                 struct pci_dev *pcidev)
 {
         u8 __iomem *addr;
+        int pcicfg_reg;
 
         addr = ioremap_nocache(pci_resource_start(pcidev, 2),
                                pci_resource_len(pcidev, 2));
@@ -156,13 +278,19 @@ static int beiscsi_map_pci_bars(struct beiscsi_hba *phba,
         phba->db_va = addr;
         phba->db_pa.u.a64.address =  pci_resource_start(pcidev, 4);
 
-        addr = ioremap_nocache(pci_resource_start(pcidev, 1),
-                               pci_resource_len(pcidev, 1));
+        if (phba->generation == BE_GEN2)
+                pcicfg_reg = 1;
+        else
+                pcicfg_reg = 0;
+
+        addr = ioremap_nocache(pci_resource_start(pcidev, pcicfg_reg),
+                               pci_resource_len(pcidev, pcicfg_reg));
+
         if (addr == NULL)
                 goto pci_map_err;
         phba->ctrl.pcicfg = addr;
         phba->pci_va = addr;
-        phba->pci_pa.u.a64.address = pci_resource_start(pcidev, 1);
+        phba->pci_pa.u.a64.address = pci_resource_start(pcidev, pcicfg_reg);
         return 0;
 
 pci_map_err:
@@ -181,6 +309,7 @@ static int beiscsi_enable_pci(struct pci_dev *pcidev)
                 return ret;
         }
 
+        pci_set_master(pcidev);
         if (pci_set_consistent_dma_mask(pcidev, DMA_BIT_MASK(64))) {
                 ret = pci_set_consistent_dma_mask(pcidev, DMA_BIT_MASK(32));
                 if (ret) {
@@ -203,7 +332,6 @@ static int be_ctrl_init(struct beiscsi_hba *phba, struct pci_dev *pdev)
         status = beiscsi_map_pci_bars(phba, pdev);
         if (status)
                 return status;
-
         mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
         mbox_mem_alloc->va = pci_alloc_consistent(pdev,
                                                   mbox_mem_alloc->size,
@@ -219,34 +347,35 @@ static int be_ctrl_init(struct beiscsi_hba *phba, struct pci_dev *pdev)
         mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
         memset(mbox_mem_align->va, 0, sizeof(struct be_mcc_mailbox));
         spin_lock_init(&ctrl->mbox_lock);
+        spin_lock_init(&phba->ctrl.mcc_lock);
+        spin_lock_init(&phba->ctrl.mcc_cq_lock);
+
         return status;
 }
 
 static void beiscsi_get_params(struct beiscsi_hba *phba)
 {
-        phba->params.ios_per_ctrl = BE2_IO_DEPTH;
-        phba->params.cxns_per_ctrl = BE2_MAX_SESSIONS;
-        phba->params.asyncpdus_per_ctrl = BE2_ASYNCPDUS;
-        phba->params.icds_per_ctrl = BE2_MAX_ICDS / 2;
+        phba->params.ios_per_ctrl = (phba->fw_config.iscsi_icd_count
+                                    - (phba->fw_config.iscsi_cid_count
+                                    + BE2_TMFS
+                                    + BE2_NOPOUT_REQ));
+        phba->params.cxns_per_ctrl = phba->fw_config.iscsi_cid_count;
+        phba->params.asyncpdus_per_ctrl = phba->fw_config.iscsi_cid_count * 2;
+        phba->params.icds_per_ctrl = phba->fw_config.iscsi_icd_count;;
         phba->params.num_sge_per_io = BE2_SGE;
         phba->params.defpdu_hdr_sz = BE2_DEFPDU_HDR_SZ;
         phba->params.defpdu_data_sz = BE2_DEFPDU_DATA_SZ;
         phba->params.eq_timer = 64;
         phba->params.num_eq_entries =
-            (((BE2_CMDS_PER_CXN * 2 + BE2_LOGOUTS + BE2_TMFS + BE2_ASYNCPDUS) /
-                                                                512) + 1) * 512;
+            (((BE2_CMDS_PER_CXN * 2 + phba->fw_config.iscsi_cid_count * 2
+                                    + BE2_TMFS) / 512) + 1) * 512;
         phba->params.num_eq_entries = (phba->params.num_eq_entries < 1024)
                                 ? 1024 : phba->params.num_eq_entries;
         SE_DEBUG(DBG_LVL_8, "phba->params.num_eq_entries=%d \n",
-                 phba->params.num_eq_entries);
+                             phba->params.num_eq_entries);
         phba->params.num_cq_entries =
-            (((BE2_CMDS_PER_CXN * 2 + BE2_LOGOUTS + BE2_TMFS + BE2_ASYNCPDUS) /
-                                                                512) + 1) * 512;
-        SE_DEBUG(DBG_LVL_8,
-                "phba->params.num_cq_entries=%d BE2_CMDS_PER_CXN=%d"
-                "BE2_LOGOUTS=%d BE2_TMFS=%d BE2_ASYNCPDUS=%d \n",
-                phba->params.num_cq_entries, BE2_CMDS_PER_CXN,
-                BE2_LOGOUTS, BE2_TMFS, BE2_ASYNCPDUS);
+            (((BE2_CMDS_PER_CXN * 2 +  phba->fw_config.iscsi_cid_count * 2
+                                    + BE2_TMFS) / 512) + 1) * 512;
         phba->params.wrbs_per_cxn = 256;
 }
 
@@ -268,6 +397,113 @@ static void hwi_ring_eq_db(struct beiscsi_hba *phba,
 }
 
 /**
+ * be_isr_mcc - The isr routine of the driver.
+ * @irq: Not used
+ * @dev_id: Pointer to host adapter structure
+ */
+static irqreturn_t be_isr_mcc(int irq, void *dev_id)
+{
+        struct beiscsi_hba *phba;
+        struct be_eq_entry *eqe = NULL;
+        struct be_queue_info *eq;
+        struct be_queue_info *mcc;
+        unsigned int num_eq_processed;
+        struct be_eq_obj *pbe_eq;
+        unsigned long flags;
+
+        pbe_eq = dev_id;
+        eq = &pbe_eq->q;
+        phba =  pbe_eq->phba;
+        mcc = &phba->ctrl.mcc_obj.cq;
+        eqe = queue_tail_node(eq);
+        if (!eqe)
+                SE_DEBUG(DBG_LVL_1, "eqe is NULL\n");
+
+        num_eq_processed = 0;
+
+        while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
+                                & EQE_VALID_MASK) {
+                if (((eqe->dw[offsetof(struct amap_eq_entry,
+                     resource_id) / 32] &
+                     EQE_RESID_MASK) >> 16) == mcc->id) {
+                        spin_lock_irqsave(&phba->isr_lock, flags);
+                        phba->todo_mcc_cq = 1;
+                        spin_unlock_irqrestore(&phba->isr_lock, flags);
+                }
+                AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
+                queue_tail_inc(eq);
+                eqe = queue_tail_node(eq);
+                num_eq_processed++;
+        }
+        if (phba->todo_mcc_cq)
+                queue_work(phba->wq, &phba->work_cqs);
+        if (num_eq_processed)
+                hwi_ring_eq_db(phba, eq->id, 1, num_eq_processed, 1, 1);
+
+        return IRQ_HANDLED;
+}
+
+/**
+ * be_isr_msix - The isr routine of the driver.
+ * @irq: Not used
+ * @dev_id: Pointer to host adapter structure
+ */
+static irqreturn_t be_isr_msix(int irq, void *dev_id)
+{
+        struct beiscsi_hba *phba;
+        struct be_eq_entry *eqe = NULL;
+        struct be_queue_info *eq;
+        struct be_queue_info *cq;
+        unsigned int num_eq_processed;
+        struct be_eq_obj *pbe_eq;
+        unsigned long flags;
+
+        pbe_eq = dev_id;
+        eq = &pbe_eq->q;
+        cq = pbe_eq->cq;
+        eqe = queue_tail_node(eq);
+        if (!eqe)
+                SE_DEBUG(DBG_LVL_1, "eqe is NULL\n");
+
+        phba = pbe_eq->phba;
+        num_eq_processed = 0;
+        if (blk_iopoll_enabled) {
+                while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
+                                        & EQE_VALID_MASK) {
+                        if (!blk_iopoll_sched_prep(&pbe_eq->iopoll))
+                                blk_iopoll_sched(&pbe_eq->iopoll);
+
+                        AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
+                        queue_tail_inc(eq);
+                        eqe = queue_tail_node(eq);
+                        num_eq_processed++;
+                }
+                if (num_eq_processed)
+                        hwi_ring_eq_db(phba, eq->id, 1, num_eq_processed, 0, 1);
+
+                return IRQ_HANDLED;
+        } else {
+                while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
+                                                & EQE_VALID_MASK) {
+                        spin_lock_irqsave(&phba->isr_lock, flags);
+                        phba->todo_cq = 1;
+                        spin_unlock_irqrestore(&phba->isr_lock, flags);
+                        AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
+                        queue_tail_inc(eq);
+                        eqe = queue_tail_node(eq);
+                        num_eq_processed++;
+                }
+                if (phba->todo_cq)
+                        queue_work(phba->wq, &phba->work_cqs);
+
+                if (num_eq_processed)
+                        hwi_ring_eq_db(phba, eq->id, 1, num_eq_processed, 1, 1);
+
+                return IRQ_HANDLED;
+        }
+}
+
+/**
  * be_isr - The isr routine of the driver.
  * @irq: Not used
  * @dev_id: Pointer to host adapter structure
@@ -280,48 +516,70 @@ static irqreturn_t be_isr(int irq, void *dev_id)
         struct be_eq_entry *eqe = NULL;
         struct be_queue_info *eq;
         struct be_queue_info *cq;
+        struct be_queue_info *mcc;
         unsigned long flags, index;
-        unsigned int num_eq_processed;
+        unsigned int num_mcceq_processed, num_ioeq_processed;
         struct be_ctrl_info *ctrl;
+        struct be_eq_obj *pbe_eq;
         int isr;
 
         phba = dev_id;
-        if (!enable_msix) {
-                ctrl = &phba->ctrl;;
-                isr = ioread32(ctrl->csr + CEV_ISR0_OFFSET +
-                               (PCI_FUNC(ctrl->pdev->devfn) * CEV_ISR_SIZE));
-                if (!isr)
-                        return IRQ_NONE;
-        }
+        ctrl = &phba->ctrl;;
+        isr = ioread32(ctrl->csr + CEV_ISR0_OFFSET +
+                       (PCI_FUNC(ctrl->pdev->devfn) * CEV_ISR_SIZE));
+        if (!isr)
+                return IRQ_NONE;
 
         phwi_ctrlr = phba->phwi_ctrlr;
         phwi_context = phwi_ctrlr->phwi_ctxt;
-        eq = &phwi_context->be_eq.q;
-        cq = &phwi_context->be_cq;
+        pbe_eq = &phwi_context->be_eq[0];
+
+        eq = &phwi_context->be_eq[0].q;
+        mcc = &phba->ctrl.mcc_obj.cq;
         index = 0;
         eqe = queue_tail_node(eq);
         if (!eqe)
                 SE_DEBUG(DBG_LVL_1, "eqe is NULL\n");
 
-        num_eq_processed = 0;
+        num_ioeq_processed = 0;
+        num_mcceq_processed = 0;
         if (blk_iopoll_enabled) {
                 while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
                                         & EQE_VALID_MASK) {
-                        if (!blk_iopoll_sched_prep(&phba->iopoll))
-                                blk_iopoll_sched(&phba->iopoll);
-
+                        if (((eqe->dw[offsetof(struct amap_eq_entry,
+                             resource_id) / 32] &
+                             EQE_RESID_MASK) >> 16) == mcc->id) {
+                                spin_lock_irqsave(&phba->isr_lock, flags);
+                                phba->todo_mcc_cq = 1;
+                                spin_unlock_irqrestore(&phba->isr_lock, flags);
+                                num_mcceq_processed++;
+                        } else {
+                                if (!blk_iopoll_sched_prep(&pbe_eq->iopoll))
+                                        blk_iopoll_sched(&pbe_eq->iopoll);
+                                num_ioeq_processed++;
+                        }
                         AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
                         queue_tail_inc(eq);
                         eqe = queue_tail_node(eq);
-                        num_eq_processed++;
-                        SE_DEBUG(DBG_LVL_8, "Valid EQE\n");
                 }
-                if (num_eq_processed) {
-                        hwi_ring_eq_db(phba, eq->id, 0, num_eq_processed, 0, 1);
+                if (num_ioeq_processed || num_mcceq_processed) {
+                        if (phba->todo_mcc_cq)
+                                queue_work(phba->wq, &phba->work_cqs);
+
+                        if ((num_mcceq_processed) && (!num_ioeq_processed))
+                                hwi_ring_eq_db(phba, eq->id, 0,
+                                              (num_ioeq_processed +
+                                               num_mcceq_processed) , 1, 1);
+                        else
+                                hwi_ring_eq_db(phba, eq->id, 0,
+                                               (num_ioeq_processed +
+                                                num_mcceq_processed), 0, 1);
+
                         return IRQ_HANDLED;
                 } else
                         return IRQ_NONE;
         } else {
+                cq = &phwi_context->be_cq[0];
                 while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
                                                 & EQE_VALID_MASK) {
 
@@ -339,13 +597,14 @@ static irqreturn_t be_isr(int irq, void *dev_id)
                         AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
                         queue_tail_inc(eq);
                         eqe = queue_tail_node(eq);
-                        num_eq_processed++;
+                        num_ioeq_processed++;
                 }
                 if (phba->todo_cq || phba->todo_mcc_cq)
                         queue_work(phba->wq, &phba->work_cqs);
 
-                if (num_eq_processed) {
-                        hwi_ring_eq_db(phba, eq->id, 0, num_eq_processed, 1, 1);
+                if (num_ioeq_processed) {
+                        hwi_ring_eq_db(phba, eq->id, 0,
+                                       num_ioeq_processed, 1, 1);
                         return IRQ_HANDLED;
                 } else
                         return IRQ_NONE;
@@ -355,13 +614,32 @@ static irqreturn_t be_isr(int irq, void *dev_id)
 static int beiscsi_init_irqs(struct beiscsi_hba *phba)
 {
         struct pci_dev *pcidev = phba->pcidev;
-        int ret;
+        struct hwi_controller *phwi_ctrlr;
+        struct hwi_context_memory *phwi_context;
+        int ret, msix_vec, i = 0;
+        char desc[32];
 
-        ret = request_irq(pcidev->irq, be_isr, IRQF_SHARED, "beiscsi", phba);
-        if (ret) {
-                shost_printk(KERN_ERR, phba->shost, "beiscsi_init_irqs-"
-                             "Failed to register irq\\n");
-                return ret;
+        phwi_ctrlr = phba->phwi_ctrlr;
+        phwi_context = phwi_ctrlr->phwi_ctxt;
+
+        if (phba->msix_enabled) {
+                for (i = 0; i < phba->num_cpus; i++) {
+                        sprintf(desc, "beiscsi_msix_%04x", i);
+                        msix_vec = phba->msix_entries[i].vector;
+                        ret = request_irq(msix_vec, be_isr_msix, 0, desc,
+                                          &phwi_context->be_eq[i]);
+                }
+                msix_vec = phba->msix_entries[i].vector;
+                ret = request_irq(msix_vec, be_isr_mcc, 0, "beiscsi_msix_mcc",
+                                  &phwi_context->be_eq[i]);
+        } else {
+                ret = request_irq(pcidev->irq, be_isr, IRQF_SHARED,
+                                  "beiscsi", phba);
+                if (ret) {
+                        shost_printk(KERN_ERR, phba->shost, "beiscsi_init_irqs-"
+                                     "Failed to register irq\\n");
+                        return ret;
+                }
         }
         return 0;
 }
@@ -378,15 +656,6 @@ static void hwi_ring_cq_db(struct beiscsi_hba *phba,
         iowrite32(val, phba->db_va + DB_CQ_OFFSET);
 }
 
-/*
- * async pdus include
- * a. unsolicited NOP-In (target initiated NOP-In)
- * b. Async Messages
- * c. Reject PDU
- * d. Login response
- * These headers arrive unprocessed by the EP firmware and iSCSI layer
- * process them
- */
 static unsigned int
 beiscsi_process_async_pdu(struct beiscsi_conn *beiscsi_conn,
                           struct beiscsi_hba *phba,
@@ -397,6 +666,9 @@ beiscsi_process_async_pdu(struct beiscsi_conn *beiscsi_conn,
 {
         struct iscsi_conn *conn = beiscsi_conn->conn;
         struct iscsi_session *session = conn->session;
+        struct iscsi_task *task;
+        struct beiscsi_io_task *io_task;
+        struct iscsi_hdr *login_hdr;
 
         switch (ppdu->dw[offsetof(struct amap_pdu_base, opcode) / 32] &
                                                 PDUBASE_OPCODE_MASK) {
@@ -412,6 +684,11 @@ beiscsi_process_async_pdu(struct beiscsi_conn *beiscsi_conn,
                 SE_DEBUG(DBG_LVL_1, "In ISCSI_OP_REJECT\n");
                 break;
         case ISCSI_OP_LOGIN_RSP:
+        case ISCSI_OP_TEXT_RSP:
+                task = conn->login_task;
+                io_task = task->dd_data;
+                login_hdr = (struct iscsi_hdr *)ppdu;
+                login_hdr->itt = io_task->libiscsi_itt;
                 break;
         default:
                 shost_printk(KERN_WARNING, phba->shost,
@@ -440,7 +717,8 @@ static struct sgl_handle *alloc_io_sgl_handle(struct beiscsi_hba *phba)
                                                 io_sgl_alloc_index];
                 phba->io_sgl_hndl_base[phba->io_sgl_alloc_index] = NULL;
                 phba->io_sgl_hndl_avbl--;
-                if (phba->io_sgl_alloc_index == (phba->params.ios_per_ctrl - 1))
+                if (phba->io_sgl_alloc_index == (phba->params.
+                                                 ios_per_ctrl - 1))
                         phba->io_sgl_alloc_index = 0;
                 else
                         phba->io_sgl_alloc_index++;
@@ -477,22 +755,31 @@ free_io_sgl_handle(struct beiscsi_hba *phba, struct sgl_handle *psgl_handle)
  * alloc_wrb_handle - To allocate a wrb handle
  * @phba: The hba pointer
  * @cid: The cid to use for allocation
- * @index: index allocation and wrb index
  *
  * This happens under session_lock until submission to chip
  */
-struct wrb_handle *alloc_wrb_handle(struct beiscsi_hba *phba, unsigned int cid,
-                                    int index)
+struct wrb_handle *alloc_wrb_handle(struct beiscsi_hba *phba, unsigned int cid)
 {
         struct hwi_wrb_context *pwrb_context;
         struct hwi_controller *phwi_ctrlr;
-        struct wrb_handle *pwrb_handle;
+        struct wrb_handle *pwrb_handle, *pwrb_handle_tmp;
 
         phwi_ctrlr = phba->phwi_ctrlr;
         pwrb_context = &phwi_ctrlr->wrb_context[cid];
-        pwrb_handle = pwrb_context->pwrb_handle_base[index];
-        pwrb_handle->wrb_index = index;
-        pwrb_handle->nxt_wrb_index = index;
+        if (pwrb_context->wrb_handles_available >= 2) {
+                pwrb_handle = pwrb_context->pwrb_handle_base[
+                                            pwrb_context->alloc_index];
+                pwrb_context->wrb_handles_available--;
+                if (pwrb_context->alloc_index ==
+                                                (phba->params.wrbs_per_cxn - 1))
+                        pwrb_context->alloc_index = 0;
+                else
+                        pwrb_context->alloc_index++;
+                pwrb_handle_tmp = pwrb_context->pwrb_handle_base[
+                                                pwrb_context->alloc_index];
+                pwrb_handle->nxt_wrb_index = pwrb_handle_tmp->wrb_index;
+        } else
+                pwrb_handle = NULL;
         return pwrb_handle;
 }
 
@@ -508,11 +795,18 @@ static void
 free_wrb_handle(struct beiscsi_hba *phba, struct hwi_wrb_context *pwrb_context,
                 struct wrb_handle *pwrb_handle)
 {
+        pwrb_context->pwrb_handle_base[pwrb_context->free_index] = pwrb_handle;
+        pwrb_context->wrb_handles_available++;
+        if (pwrb_context->free_index == (phba->params.wrbs_per_cxn - 1))
+                pwrb_context->free_index = 0;
+        else
+                pwrb_context->free_index++;
+
         SE_DEBUG(DBG_LVL_8,
-                 "FREE WRB: pwrb_handle=%p free_index=%d=0x%x"
+                 "FREE WRB: pwrb_handle=%p free_index=0x%x"
                  "wrb_handles_available=%d \n",
                  pwrb_handle, pwrb_context->free_index,
-                 pwrb_context->free_index, pwrb_context->wrb_handles_available);
+                 pwrb_context->wrb_handles_available);
 }
 
 static struct sgl_handle *alloc_mgmt_sgl_handle(struct beiscsi_hba *phba)
@@ -540,6 +834,8 @@ void
 free_mgmt_sgl_handle(struct beiscsi_hba *phba, struct sgl_handle *psgl_handle)
 {
 
+        SE_DEBUG(DBG_LVL_8, "In  free_mgmt_sgl_handle,eh_sgl_free_index=%d \n",
+                             phba->eh_sgl_free_index);
         if (phba->eh_sgl_hndl_base[phba->eh_sgl_free_index]) {
                 /*
                  * this can happen if clean_task is called on a task that
@@ -572,10 +868,10 @@ be_complete_io(struct beiscsi_conn *beiscsi_conn,
         u32 resid = 0, exp_cmdsn, max_cmdsn;
         u8 rsp, status, flags;
 
-        exp_cmdsn = be32_to_cpu(psol->
+        exp_cmdsn = (psol->
                         dw[offsetof(struct amap_sol_cqe, i_exp_cmd_sn) / 32]
                         & SOL_EXP_CMD_SN_MASK);
-        max_cmdsn = be32_to_cpu((psol->
+        max_cmdsn = ((psol->
                         dw[offsetof(struct amap_sol_cqe, i_exp_cmd_sn) / 32]
                         & SOL_EXP_CMD_SN_MASK) +
                         ((psol->dw[offsetof(struct amap_sol_cqe, i_cmd_wnd)
@@ -610,18 +906,19 @@ be_complete_io(struct beiscsi_conn *beiscsi_conn,
         }
 
         if (status == SAM_STAT_CHECK_CONDITION) {
+                unsigned short *slen = (unsigned short *)sts_bhs->sense_info;
                 sense = sts_bhs->sense_info + sizeof(unsigned short);
-                sense_len =
-                    cpu_to_be16((unsigned short)(sts_bhs->sense_info[0]));
+                sense_len =  cpu_to_be16(*slen);
                 memcpy(task->sc->sense_buffer, sense,
                        min_t(u16, sense_len, SCSI_SENSE_BUFFERSIZE));
         }
+
         if (io_task->cmd_bhs->iscsi_hdr.flags & ISCSI_FLAG_CMD_READ) {
                 if (psol->dw[offsetof(struct amap_sol_cqe, i_res_cnt) / 32]
                                                         & SOL_RES_CNT_MASK)
                          conn->rxdata_octets += (psol->
-                              dw[offsetof(struct amap_sol_cqe, i_res_cnt) / 32]
-                                                        & SOL_RES_CNT_MASK);
+                             dw[offsetof(struct amap_sol_cqe, i_res_cnt) / 32]
+                             & SOL_RES_CNT_MASK);
         }
 unmap:
         scsi_dma_unmap(io_task->scsi_cmnd);
@@ -633,9 +930,11 @@ be_complete_logout(struct beiscsi_conn *beiscsi_conn,
                    struct iscsi_task *task, struct sol_cqe *psol)
 {
         struct iscsi_logout_rsp *hdr;
+        struct beiscsi_io_task *io_task = task->dd_data;
         struct iscsi_conn *conn = beiscsi_conn->conn;
 
         hdr = (struct iscsi_logout_rsp *)task->hdr;
+        hdr->opcode = ISCSI_OP_LOGOUT_RSP;
         hdr->t2wait = 5;
         hdr->t2retain = 0;
         hdr->flags = ((psol->dw[offsetof(struct amap_sol_cqe, i_flags) / 32]
@@ -650,8 +949,11 @@ be_complete_logout(struct beiscsi_conn *beiscsi_conn,
                                         & SOL_EXP_CMD_SN_MASK) +
                         ((psol->dw[offsetof(struct amap_sol_cqe, i_cmd_wnd)
                                         / 32] & SOL_CMD_WND_MASK) >> 24) - 1);
+        hdr->dlength[0] = 0;
+        hdr->dlength[1] = 0;
+        hdr->dlength[2] = 0;
         hdr->hlength = 0;
-
+        hdr->itt = io_task->libiscsi_itt;
         __iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, NULL, 0);
 }
 
@@ -661,18 +963,21 @@ be_complete_tmf(struct beiscsi_conn *beiscsi_conn,
 {
         struct iscsi_tm_rsp *hdr;
         struct iscsi_conn *conn = beiscsi_conn->conn;
+        struct beiscsi_io_task *io_task = task->dd_data;
 
         hdr = (struct iscsi_tm_rsp *)task->hdr;
+        hdr->opcode = ISCSI_OP_SCSI_TMFUNC_RSP;
         hdr->flags = ((psol->dw[offsetof(struct amap_sol_cqe, i_flags) / 32]
                                         & SOL_FLAGS_MASK) >> 24) | 0x80;
         hdr->response = (psol->dw[offsetof(struct amap_sol_cqe, i_resp) /
                                         32] & SOL_RESP_MASK);
         hdr->exp_cmdsn = cpu_to_be32(psol->dw[offsetof(struct amap_sol_cqe,
-                                     i_exp_cmd_sn) / 32] & SOL_EXP_CMD_SN_MASK);
+                                    i_exp_cmd_sn) / 32] & SOL_EXP_CMD_SN_MASK);
         hdr->max_cmdsn = be32_to_cpu((psol->dw[offsetof(struct amap_sol_cqe,
                         i_exp_cmd_sn) / 32] & SOL_EXP_CMD_SN_MASK) +
                         ((psol->dw[offsetof(struct amap_sol_cqe, i_cmd_wnd)
                         / 32] & SOL_CMD_WND_MASK) >> 24) - 1);
+        hdr->itt = io_task->libiscsi_itt;
         __iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, NULL, 0);
 }
 
@@ -681,18 +986,27 @@ hwi_complete_drvr_msgs(struct beiscsi_conn *beiscsi_conn,
                        struct beiscsi_hba *phba, struct sol_cqe *psol)
 {
         struct hwi_wrb_context *pwrb_context;
-        struct wrb_handle *pwrb_handle;
+        struct wrb_handle *pwrb_handle = NULL;
         struct hwi_controller *phwi_ctrlr;
+        struct iscsi_task *task;
+        struct beiscsi_io_task *io_task;
         struct iscsi_conn *conn = beiscsi_conn->conn;
         struct iscsi_session *session = conn->session;
 
         phwi_ctrlr = phba->phwi_ctrlr;
         pwrb_context = &phwi_ctrlr->wrb_context[((psol->
                                 dw[offsetof(struct amap_sol_cqe, cid) / 32] &
-                                SOL_CID_MASK) >> 6)];
+                                SOL_CID_MASK) >> 6) -
+                                phba->fw_config.iscsi_cid_start];
         pwrb_handle = pwrb_context->pwrb_handle_basestd[((psol->
                                 dw[offsetof(struct amap_sol_cqe, wrb_index) /
                                 32] & SOL_WRB_INDEX_MASK) >> 16)];
+        task = pwrb_handle->pio_handle;
+
+        io_task = task->dd_data;
+        spin_lock(&phba->mgmt_sgl_lock);
+        free_mgmt_sgl_handle(phba, io_task->psgl_handle);
+        spin_unlock(&phba->mgmt_sgl_lock);
         spin_lock_bh(&session->lock);
         free_wrb_handle(phba, pwrb_context, pwrb_handle);
         spin_unlock_bh(&session->lock);
@@ -704,6 +1018,7 @@ be_complete_nopin_resp(struct beiscsi_conn *beiscsi_conn,
 {
         struct iscsi_nopin *hdr;
         struct iscsi_conn *conn = beiscsi_conn->conn;
+        struct beiscsi_io_task *io_task = task->dd_data;
 
         hdr = (struct iscsi_nopin *)task->hdr;
         hdr->flags = ((psol->dw[offsetof(struct amap_sol_cqe, i_flags) / 32]
@@ -715,6 +1030,7 @@ be_complete_nopin_resp(struct beiscsi_conn *beiscsi_conn,
                         ((psol->dw[offsetof(struct amap_sol_cqe, i_cmd_wnd)
                         / 32] & SOL_CMD_WND_MASK) >> 24) - 1);
         hdr->opcode = ISCSI_OP_NOOP_IN;
+        hdr->itt = io_task->libiscsi_itt;
         __iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, NULL, 0);
 }
 
@@ -726,36 +1042,40 @@ static void hwi_complete_cmd(struct beiscsi_conn *beiscsi_conn,
         struct iscsi_wrb *pwrb = NULL;
         struct hwi_controller *phwi_ctrlr;
         struct iscsi_task *task;
-        struct beiscsi_io_task *io_task;
+        unsigned int type;
         struct iscsi_conn *conn = beiscsi_conn->conn;
         struct iscsi_session *session = conn->session;
 
         phwi_ctrlr = phba->phwi_ctrlr;
-
-        pwrb_context = &phwi_ctrlr->
-                wrb_context[((psol->dw[offsetof(struct amap_sol_cqe, cid) / 32]
-                & SOL_CID_MASK) >> 6)];
+        pwrb_context = &phwi_ctrlr->wrb_context[((psol->dw[offsetof
+                                (struct amap_sol_cqe, cid) / 32]
+                                & SOL_CID_MASK) >> 6) -
+                                phba->fw_config.iscsi_cid_start];
         pwrb_handle = pwrb_context->pwrb_handle_basestd[((psol->
                                 dw[offsetof(struct amap_sol_cqe, wrb_index) /
                                 32] & SOL_WRB_INDEX_MASK) >> 16)];
-
         task = pwrb_handle->pio_handle;
-        io_task = task->dd_data;
-        spin_lock_bh(&session->lock);
         pwrb = pwrb_handle->pwrb;
-        switch ((pwrb->dw[offsetof(struct amap_iscsi_wrb, type) / 32] &
-                 WRB_TYPE_MASK) >> 28) {
+        type = (pwrb->dw[offsetof(struct amap_iscsi_wrb, type) / 32] &
+                                 WRB_TYPE_MASK) >> 28;
+
+        spin_lock_bh(&session->lock);
+        switch (type) {
         case HWH_TYPE_IO:
         case HWH_TYPE_IO_RD:
                 if ((task->hdr->opcode & ISCSI_OPCODE_MASK) ==
-                    ISCSI_OP_NOOP_OUT) {
+                     ISCSI_OP_NOOP_OUT)
                         be_complete_nopin_resp(beiscsi_conn, task, psol);
-                } else
+                else
                         be_complete_io(beiscsi_conn, task, psol);
                 break;
 
         case HWH_TYPE_LOGOUT:
-                be_complete_logout(beiscsi_conn, task, psol);
+                if ((task->hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT)
+                        be_complete_logout(beiscsi_conn, task, psol);
+                else
+                        be_complete_tmf(beiscsi_conn, task, psol);
+
                 break;
 
         case HWH_TYPE_LOGIN:
@@ -764,21 +1084,18 @@ static void hwi_complete_cmd(struct beiscsi_conn *beiscsi_conn,
                          "- Solicited path \n");
                 break;
 
-        case HWH_TYPE_TMF:
-                be_complete_tmf(beiscsi_conn, task, psol);
-                break;
-
         case HWH_TYPE_NOP:
                 be_complete_nopin_resp(beiscsi_conn, task, psol);
                 break;
 
         default:
                 shost_printk(KERN_WARNING, phba->shost,
-                            "wrb_index 0x%x CID 0x%x\n",
-                            ((psol->dw[offsetof(struct amap_iscsi_wrb, type) /
-                                        32] & SOL_WRB_INDEX_MASK) >> 16),
-                            ((psol->dw[offsetof(struct amap_sol_cqe, cid) / 32]
-                                        & SOL_CID_MASK) >> 6));
+                                "In hwi_complete_cmd, unknown type = %d"
+                                "wrb_index 0x%x CID 0x%x\n", type,
+                                ((psol->dw[offsetof(struct amap_iscsi_wrb,
+                                type) / 32] & SOL_WRB_INDEX_MASK) >> 16),
+                                ((psol->dw[offsetof(struct amap_sol_cqe,
+                                cid) / 32] & SOL_CID_MASK) >> 6));
                 break;
         }
 
@@ -863,7 +1180,8 @@ hwi_get_async_handle(struct beiscsi_hba *phba,
 
         WARN_ON(!pasync_handle);
 
-        pasync_handle->cri = (unsigned short)beiscsi_conn->beiscsi_conn_cid;
+        pasync_handle->cri = (unsigned short)beiscsi_conn->beiscsi_conn_cid -
+                                             phba->fw_config.iscsi_cid_start;
         pasync_handle->is_header = is_header;
         pasync_handle->buffer_len = ((pdpdu_cqe->
                         dw[offsetof(struct amap_i_t_dpdu_cqe, dpl) / 32]
@@ -1113,9 +1431,10 @@ hwi_fwd_async_msg(struct beiscsi_conn *beiscsi_conn,
         }
 
         status = beiscsi_process_async_pdu(beiscsi_conn, phba,
-                                           beiscsi_conn->beiscsi_conn_cid,
-                                           phdr, hdr_len, pfirst_buffer,
-                                           buf_len);
+                                           (beiscsi_conn->beiscsi_conn_cid -
+                                            phba->fw_config.iscsi_cid_start),
+                                            phdr, hdr_len, pfirst_buffer,
+                                            buf_len);
 
         if (status == 0)
                 hwi_free_async_msg(phba, cri);
@@ -1208,40 +1527,79 @@ static void hwi_process_default_pdu_ring(struct beiscsi_conn *beiscsi_conn,
         hwi_post_async_buffers(phba, pasync_handle->is_header);
 }
 
-static unsigned int beiscsi_process_cq(struct beiscsi_hba *phba)
+static void  beiscsi_process_mcc_isr(struct beiscsi_hba *phba)
+{
+        struct be_queue_info *mcc_cq;
+        struct  be_mcc_compl *mcc_compl;
+        unsigned int num_processed = 0;
+
+        mcc_cq = &phba->ctrl.mcc_obj.cq;
+        mcc_compl = queue_tail_node(mcc_cq);
+        mcc_compl->flags = le32_to_cpu(mcc_compl->flags);
+        while (mcc_compl->flags & CQE_FLAGS_VALID_MASK) {
+
+                if (num_processed >= 32) {
+                        hwi_ring_cq_db(phba, mcc_cq->id,
+                                        num_processed, 0, 0);
+                        num_processed = 0;
+                }
+                if (mcc_compl->flags & CQE_FLAGS_ASYNC_MASK) {
+                        /* Interpret flags as an async trailer */
+                        if (is_link_state_evt(mcc_compl->flags))
+                                /* Interpret compl as a async link evt */
+                                beiscsi_async_link_state_process(phba,
+                                (struct be_async_event_link_state *) mcc_compl);
+                        else
+                                SE_DEBUG(DBG_LVL_1,
+                                        " Unsupported Async Event, flags"
+                                        " = 0x%08x \n", mcc_compl->flags);
+                } else if (mcc_compl->flags & CQE_FLAGS_COMPLETED_MASK) {
+                        be_mcc_compl_process_isr(&phba->ctrl, mcc_compl);
+                        atomic_dec(&phba->ctrl.mcc_obj.q.used);
+                }
+
+                mcc_compl->flags = 0;
+                queue_tail_inc(mcc_cq);
+                mcc_compl = queue_tail_node(mcc_cq);
+                mcc_compl->flags = le32_to_cpu(mcc_compl->flags);
+                num_processed++;
+        }
+
+        if (num_processed > 0)
+                hwi_ring_cq_db(phba, mcc_cq->id, num_processed, 1, 0);
+
+}
+
+static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
 {
-        struct hwi_controller *phwi_ctrlr;
-        struct hwi_context_memory *phwi_context;
         struct be_queue_info *cq;
         struct sol_cqe *sol;
         struct dmsg_cqe *dmsg;
         unsigned int num_processed = 0;
         unsigned int tot_nump = 0;
         struct beiscsi_conn *beiscsi_conn;
+        struct beiscsi_endpoint *beiscsi_ep;
+        struct iscsi_endpoint *ep;
+        struct beiscsi_hba *phba;
 
-        phwi_ctrlr = phba->phwi_ctrlr;
-        phwi_context = phwi_ctrlr->phwi_ctxt;
-        cq = &phwi_context->be_cq;
+        cq = pbe_eq->cq;
         sol = queue_tail_node(cq);
+        phba = pbe_eq->phba;
 
         while (sol->dw[offsetof(struct amap_sol_cqe, valid) / 32] &
                CQE_VALID_MASK) {
                 be_dws_le_to_cpu(sol, sizeof(struct sol_cqe));
 
-                beiscsi_conn = phba->conn_table[(u32) (sol->
-                                 dw[offsetof(struct amap_sol_cqe, cid) / 32] &
-                                 SOL_CID_MASK) >> 6];
+                ep = phba->ep_array[(u32) ((sol->
+                                   dw[offsetof(struct amap_sol_cqe, cid) / 32] &
+                                   SOL_CID_MASK) >> 6) -
+                                   phba->fw_config.iscsi_cid_start];
 
-                if (!beiscsi_conn || !beiscsi_conn->ep) {
-                        shost_printk(KERN_WARNING, phba->shost,
-                                     "Connection table empty for cid = %d\n",
-                                     (u32)(sol->dw[offsetof(struct amap_sol_cqe,
-                                     cid) / 32] & SOL_CID_MASK) >> 6);
-                        return 0;
-                }
+                beiscsi_ep = ep->dd_data;
+                beiscsi_conn = beiscsi_ep->conn;
 
                 if (num_processed >= 32) {
-                        hwi_ring_cq_db(phba, phwi_context->be_cq.id,
+                        hwi_ring_cq_db(phba, cq->id,
                                         num_processed, 0, 0);
                         tot_nump += num_processed;
                         num_processed = 0;
@@ -1258,8 +1616,12 @@ static unsigned int beiscsi_process_cq(struct beiscsi_hba *phba)
                         hwi_complete_drvr_msgs(beiscsi_conn, phba, sol);
                         break;
                 case UNSOL_HDR_NOTIFY:
+                        SE_DEBUG(DBG_LVL_8, "Received UNSOL_HDR_ NOTIFY\n");
+                        hwi_process_default_pdu_ring(beiscsi_conn, phba,
+                                             (struct i_t_dpdu_cqe *)sol);
+                        break;
                 case UNSOL_DATA_NOTIFY:
-                        SE_DEBUG(DBG_LVL_8, "Received UNSOL_HDR/DATA_NOTIFY\n");
+                        SE_DEBUG(DBG_LVL_8, "Received UNSOL_DATA_NOTIFY\n");
                         hwi_process_default_pdu_ring(beiscsi_conn, phba,
                                              (struct i_t_dpdu_cqe *)sol);
                         break;
@@ -1306,23 +1668,23 @@ static unsigned int beiscsi_process_cq(struct beiscsi_hba *phba)
                 case CXN_KILLED_OVER_RUN_RESIDUAL:
                 case CXN_KILLED_UNDER_RUN_RESIDUAL:
                 case CXN_KILLED_CMND_DATA_NOT_ON_SAME_CONN:
-                        SE_DEBUG(DBG_LVL_1, "CQ Error %d, resetting CID "
+                        SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset CID "
                                  "0x%x...\n",
                                  sol->dw[offsetof(struct amap_sol_cqe, code) /
                                  32] & CQE_CODE_MASK,
-                                 sol->dw[offsetof(struct amap_sol_cqe, cid) /
-                                 32] & CQE_CID_MASK);
+                                 (sol->dw[offsetof(struct amap_sol_cqe, cid) /
+                                 32] & CQE_CID_MASK));
                         iscsi_conn_failure(beiscsi_conn->conn,
                                            ISCSI_ERR_CONN_FAILED);
                         break;
                 case CXN_KILLED_RST_SENT:
                 case CXN_KILLED_RST_RCVD:
-                        SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset received/sent "
-                                 "on CID 0x%x...\n",
+                        SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset"
+                                "received/sent on CID 0x%x...\n",
                                  sol->dw[offsetof(struct amap_sol_cqe, code) /
                                  32] & CQE_CODE_MASK,
-                                 sol->dw[offsetof(struct amap_sol_cqe, cid) /
-                                 32] & CQE_CID_MASK);
+                                 (sol->dw[offsetof(struct amap_sol_cqe, cid) /
+                                 32] & CQE_CID_MASK));
                         iscsi_conn_failure(beiscsi_conn->conn,
                                            ISCSI_ERR_CONN_FAILED);
                         break;
@@ -1331,8 +1693,8 @@ static unsigned int beiscsi_process_cq(struct beiscsi_hba *phba)
                                  "received on CID 0x%x...\n",
                                  sol->dw[offsetof(struct amap_sol_cqe, code) /
                                  32] & CQE_CODE_MASK,
-                                 sol->dw[offsetof(struct amap_sol_cqe, cid) /
-                                 32] & CQE_CID_MASK);
+                                 (sol->dw[offsetof(struct amap_sol_cqe, cid) /
+                                 32] & CQE_CID_MASK));
                         break;
                 }
 
@@ -1344,30 +1706,39 @@ static unsigned int beiscsi_process_cq(struct beiscsi_hba *phba)
 
         if (num_processed > 0) {
                 tot_nump += num_processed;
-                hwi_ring_cq_db(phba, phwi_context->be_cq.id, num_processed,
-                               1, 0);
+                hwi_ring_cq_db(phba, cq->id, num_processed, 1, 0);
         }
         return tot_nump;
 }
 
-static void beiscsi_process_all_cqs(struct work_struct *work)
+void beiscsi_process_all_cqs(struct work_struct *work)
 {
         unsigned long flags;
+        struct hwi_controller *phwi_ctrlr;
+        struct hwi_context_memory *phwi_context;
+        struct be_eq_obj *pbe_eq;
         struct beiscsi_hba *phba =
             container_of(work, struct beiscsi_hba, work_cqs);
 
+        phwi_ctrlr = phba->phwi_ctrlr;
+        phwi_context = phwi_ctrlr->phwi_ctxt;
+        if (phba->msix_enabled)
+                pbe_eq = &phwi_context->be_eq[phba->num_cpus];
+        else
+                pbe_eq = &phwi_context->be_eq[0];
+
         if (phba->todo_mcc_cq) {
                 spin_lock_irqsave(&phba->isr_lock, flags);
                 phba->todo_mcc_cq = 0;
                 spin_unlock_irqrestore(&phba->isr_lock, flags);
-                SE_DEBUG(DBG_LVL_1, "MCC Interrupt Not expected \n");
+                beiscsi_process_mcc_isr(phba);
         }
 
         if (phba->todo_cq) {
                 spin_lock_irqsave(&phba->isr_lock, flags);
                 phba->todo_cq = 0;
                 spin_unlock_irqrestore(&phba->isr_lock, flags);
-                beiscsi_process_cq(phba);
+                beiscsi_process_cq(pbe_eq);
         }
 }
 
@@ -1375,19 +1746,15 @@ static int be_iopoll(struct blk_iopoll *iop, int budget)
 {
         static unsigned int ret;
         struct beiscsi_hba *phba;
+        struct be_eq_obj *pbe_eq;
 
-        phba = container_of(iop, struct beiscsi_hba, iopoll);
-
-        ret = beiscsi_process_cq(phba);
+        pbe_eq = container_of(iop, struct be_eq_obj, iopoll);
+        ret = beiscsi_process_cq(pbe_eq);
         if (ret < budget) {
-                struct hwi_controller *phwi_ctrlr;
-                struct hwi_context_memory *phwi_context;
-
-                phwi_ctrlr = phba->phwi_ctrlr;
-                phwi_context = phwi_ctrlr->phwi_ctxt;
+                phba = pbe_eq->phba;
                 blk_iopoll_complete(iop);
-                hwi_ring_eq_db(phba, phwi_context->be_eq.q.id, 0,
-                                                        0, 1, 1);
+                SE_DEBUG(DBG_LVL_8, "rearm pbe_eq->q.id =%d\n", pbe_eq->q.id);
+                hwi_ring_eq_db(phba, pbe_eq->q.id, 0, 0, 1, 1);
         }
         return ret;
 }
@@ -1409,7 +1776,8 @@ hwi_write_sgl(struct iscsi_wrb *pwrb, struct scatterlist *sg,
                                       io_task->bhs_pa.u.a32.address_hi);
 
         l_sg = sg;
-        for (index = 0; (index < num_sg) && (index < 2); index++, sg_next(sg)) {
+        for (index = 0; (index < num_sg) && (index < 2); index++,
+                                                         sg = sg_next(sg)) {
                 if (index == 0) {
                         sg_len = sg_dma_len(sg);
                         addr = (u64) sg_dma_address(sg);
@@ -1420,11 +1788,7 @@ hwi_write_sgl(struct iscsi_wrb *pwrb, struct scatterlist *sg,
                         AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_len, pwrb,
                                                         sg_len);
                         sge_len = sg_len;
-                        AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
-                                                        1);
                 } else {
-                        AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
-                                                        0);
                         AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_r2t_offset,
                                                         pwrb, sge_len);
                         sg_len = sg_dma_len(sg);
@@ -1447,13 +1811,27 @@ hwi_write_sgl(struct iscsi_wrb *pwrb, struct scatterlist *sg,
         AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,
                         io_task->bhs_pa.u.a32.address_lo);
 
-        if (num_sg == 2)
-                AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb, 1);
+        if (num_sg == 1) {
+                AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
+                                                                1);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb,
+                                                                0);
+        } else if (num_sg == 2) {
+                AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
+                                                                0);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb,
+                                                                1);
+        } else {
+                AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
+                                                                0);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb,
+                                                                0);
+        }
         sg = l_sg;
         psgl++;
         psgl++;
         offset = 0;
-        for (index = 0; index < num_sg; index++, sg_next(sg), psgl++) {
+        for (index = 0; index < num_sg; index++, sg = sg_next(sg), psgl++) {
                 sg_len = sg_dma_len(sg);
                 addr = (u64) sg_dma_address(sg);
                 AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,
@@ -1537,14 +1915,12 @@ static void hwi_write_buffer(struct iscsi_wrb *pwrb, struct iscsi_task *task)
 
 static void beiscsi_find_mem_req(struct beiscsi_hba *phba)
 {
-        unsigned int num_cq_pages, num_eq_pages, num_async_pdu_buf_pages;
+        unsigned int num_cq_pages, num_async_pdu_buf_pages;
         unsigned int num_async_pdu_data_pages, wrb_sz_per_cxn;
         unsigned int num_async_pdu_buf_sgl_pages, num_async_pdu_data_sgl_pages;
 
         num_cq_pages = PAGES_REQUIRED(phba->params.num_cq_entries * \
                                       sizeof(struct sol_cqe));
-        num_eq_pages = PAGES_REQUIRED(phba->params.num_eq_entries * \
-                                      sizeof(struct be_eq_entry));
         num_async_pdu_buf_pages =
                         PAGES_REQUIRED(phba->params.asyncpdus_per_ctrl * \
                                        phba->params.defpdu_hdr_sz);
@@ -1565,8 +1941,6 @@ static void beiscsi_find_mem_req(struct beiscsi_hba *phba)
         phba->mem_req[HWI_MEM_ADDN_CONTEXT] =
                                             sizeof(struct hwi_context_memory);
 
-        phba->mem_req[HWI_MEM_CQ] = num_cq_pages * PAGE_SIZE;
-        phba->mem_req[HWI_MEM_EQ] = num_eq_pages * PAGE_SIZE;
 
         phba->mem_req[HWI_MEM_WRB] = sizeof(struct iscsi_wrb)
             * (phba->params.wrbs_per_cxn)
@@ -1751,8 +2125,6 @@ static void beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
 
         for (index = 0; index < phba->params.cxns_per_ctrl * 2; index += 2) {
                 pwrb_context = &phwi_ctrlr->wrb_context[index];
-                SE_DEBUG(DBG_LVL_8, "cid=%d pwrb_context=%p \n", index,
-                                                pwrb_context);
                 pwrb_context->pwrb_handle_base =
                                 kzalloc(sizeof(struct wrb_handle *) *
                                         phba->params.wrbs_per_cxn, GFP_KERNEL);
@@ -1767,6 +2139,7 @@ static void beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
                                 pwrb_context->pwrb_handle_basestd[j] =
                                                                 pwrb_handle;
                                 pwrb_context->wrb_handles_available++;
+                                pwrb_handle->wrb_index = j;
                                 pwrb_handle++;
                         }
                         pwrb_context->free_index = 0;
@@ -1785,6 +2158,7 @@ static void beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
                                 pwrb_context->pwrb_handle_basestd[j] =
                                     pwrb_handle;
                                 pwrb_context->wrb_handles_available++;
+                                pwrb_handle->wrb_index = j;
                                 pwrb_handle++;
                         }
                         pwrb_context->free_index = 0;
@@ -1793,11 +2167,10 @@ static void beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
         }
         idx = 0;
         pwrb = mem_descr_wrb->mem_array[idx].virtual_address;
-        num_cxn_wrb =
-            ((mem_descr_wrb->mem_array[idx].size) / (sizeof(struct iscsi_wrb)) *
-             phba->params.wrbs_per_cxn);
-
-        for (index = 0; index < phba->params.cxns_per_ctrl; index += 2) {
+        num_cxn_wrb = (mem_descr_wrb->mem_array[idx].size) /
+                      ((sizeof(struct iscsi_wrb) *
+                        phba->params.wrbs_per_cxn));
+        for (index = 0; index < phba->params.cxns_per_ctrl * 2; index += 2) {
                 pwrb_context = &phwi_ctrlr->wrb_context[index];
                 if (num_cxn_wrb) {
                         for (j = 0; j < phba->params.wrbs_per_cxn; j++) {
@@ -1809,9 +2182,9 @@ static void beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
                 } else {
                         idx++;
                         pwrb = mem_descr_wrb->mem_array[idx].virtual_address;
-                        num_cxn_wrb = ((mem_descr_wrb->mem_array[idx].size) /
-                                        (sizeof(struct iscsi_wrb)) *
-                                        phba->params.wrbs_per_cxn);
+                        num_cxn_wrb = (mem_descr_wrb->mem_array[idx].size) /
+                                      ((sizeof(struct iscsi_wrb) *
+                                        phba->params.wrbs_per_cxn));
                         for (j = 0; j < phba->params.wrbs_per_cxn; j++) {
                                 pwrb_handle = pwrb_context->pwrb_handle_base[j];
                                 pwrb_handle->pwrb = pwrb;
@@ -2042,79 +2415,126 @@ static int be_fill_queue(struct be_queue_info *q,
         return 0;
 }
 
-static int beiscsi_create_eq(struct beiscsi_hba *phba,
+static int beiscsi_create_eqs(struct beiscsi_hba *phba,
                              struct hwi_context_memory *phwi_context)
 {
-        unsigned int idx;
-        int ret;
+        unsigned int i, num_eq_pages;
+        int ret, eq_for_mcc;
         struct be_queue_info *eq;
         struct be_dma_mem *mem;
-        struct be_mem_descriptor *mem_descr;
         void *eq_vaddress;
+        dma_addr_t paddr;
 
-        idx = 0;
-        eq = &phwi_context->be_eq.q;
-        mem = &eq->dma_mem;
-        mem_descr = phba->init_mem;
-        mem_descr += HWI_MEM_EQ;
-        eq_vaddress = mem_descr->mem_array[idx].virtual_address;
-
-        ret = be_fill_queue(eq, phba->params.num_eq_entries,
-                            sizeof(struct be_eq_entry), eq_vaddress);
-        if (ret) {
-                shost_printk(KERN_ERR, phba->shost,
-                             "be_fill_queue Failed for EQ \n");
-                return ret;
-        }
+        num_eq_pages = PAGES_REQUIRED(phba->params.num_eq_entries * \
+                                      sizeof(struct be_eq_entry));
 
-        mem->dma = mem_descr->mem_array[idx].bus_address.u.a64.address;
+        if (phba->msix_enabled)
+                eq_for_mcc = 1;
+        else
+                eq_for_mcc = 0;
+        for (i = 0; i < (phba->num_cpus + eq_for_mcc); i++) {
+                eq = &phwi_context->be_eq[i].q;
+                mem = &eq->dma_mem;
+                phwi_context->be_eq[i].phba = phba;
+                eq_vaddress = pci_alloc_consistent(phba->pcidev,
+                                                     num_eq_pages * PAGE_SIZE,
+                                                     &paddr);
+                if (!eq_vaddress)
+                        goto create_eq_error;
+
+                mem->va = eq_vaddress;
+                ret = be_fill_queue(eq, phba->params.num_eq_entries,
+                                    sizeof(struct be_eq_entry), eq_vaddress);
+                if (ret) {
+                        shost_printk(KERN_ERR, phba->shost,
+                                     "be_fill_queue Failed for EQ \n");
+                        goto create_eq_error;
+                }
 
-        ret = beiscsi_cmd_eq_create(&phba->ctrl, eq,
-                                    phwi_context->be_eq.cur_eqd);
-        if (ret) {
-                shost_printk(KERN_ERR, phba->shost, "beiscsi_cmd_eq_create"
-                             "Failedfor EQ \n");
-                return ret;
+                mem->dma = paddr;
+                ret = beiscsi_cmd_eq_create(&phba->ctrl, eq,
+                                            phwi_context->cur_eqd);
+                if (ret) {
+                        shost_printk(KERN_ERR, phba->shost,
+                                     "beiscsi_cmd_eq_create"
+                                     "Failedfor EQ \n");
+                        goto create_eq_error;
+                }
+                SE_DEBUG(DBG_LVL_8, "eqid = %d\n", phwi_context->be_eq[i].q.id);
         }
-        SE_DEBUG(DBG_LVL_8, "eq id is %d\n", phwi_context->be_eq.q.id);
         return 0;
+create_eq_error:
+        for (i = 0; i < (phba->num_cpus + 1); i++) {
+                eq = &phwi_context->be_eq[i].q;
+                mem = &eq->dma_mem;
+                if (mem->va)
+                        pci_free_consistent(phba->pcidev, num_eq_pages
+                                            * PAGE_SIZE,
+                                            mem->va, mem->dma);
+        }
+        return ret;
 }
 
-static int beiscsi_create_cq(struct beiscsi_hba *phba,
+static int beiscsi_create_cqs(struct beiscsi_hba *phba,
                              struct hwi_context_memory *phwi_context)
 {
-        unsigned int idx;
+        unsigned int i, num_cq_pages;
         int ret;
         struct be_queue_info *cq, *eq;
         struct be_dma_mem *mem;
-        struct be_mem_descriptor *mem_descr;
+        struct be_eq_obj *pbe_eq;
         void *cq_vaddress;
+        dma_addr_t paddr;
 
-        idx = 0;
-        cq = &phwi_context->be_cq;
-        eq = &phwi_context->be_eq.q;
-        mem = &cq->dma_mem;
-        mem_descr = phba->init_mem;
-        mem_descr += HWI_MEM_CQ;
-        cq_vaddress = mem_descr->mem_array[idx].virtual_address;
-        ret = be_fill_queue(cq, phba->params.icds_per_ctrl / 2,
-                            sizeof(struct sol_cqe), cq_vaddress);
-        if (ret) {
-                shost_printk(KERN_ERR, phba->shost,
-                             "be_fill_queue Failed for ISCSI CQ \n");
-                return ret;
-        }
+        num_cq_pages = PAGES_REQUIRED(phba->params.num_cq_entries * \
+                                      sizeof(struct sol_cqe));
 
-        mem->dma = mem_descr->mem_array[idx].bus_address.u.a64.address;
-        ret = beiscsi_cmd_cq_create(&phba->ctrl, cq, eq, false, false, 0);
-        if (ret) {
-                shost_printk(KERN_ERR, phba->shost,
-                             "beiscsi_cmd_eq_create Failed for ISCSI CQ \n");
-                return ret;
+        for (i = 0; i < phba->num_cpus; i++) {
+                cq = &phwi_context->be_cq[i];
+                eq = &phwi_context->be_eq[i].q;
+                pbe_eq = &phwi_context->be_eq[i];
+                pbe_eq->cq = cq;
+                pbe_eq->phba = phba;
+                mem = &cq->dma_mem;
+                cq_vaddress = pci_alloc_consistent(phba->pcidev,
+                                                     num_cq_pages * PAGE_SIZE,
+                                                     &paddr);
+                if (!cq_vaddress)
+                        goto create_cq_error;
+                ret = be_fill_queue(cq, phba->params.num_cq_entries,
+                                    sizeof(struct sol_cqe), cq_vaddress);
+                if (ret) {
+                        shost_printk(KERN_ERR, phba->shost,
+                                     "be_fill_queue Failed for ISCSI CQ \n");
+                        goto create_cq_error;
+                }
+
+                mem->dma = paddr;
+                ret = beiscsi_cmd_cq_create(&phba->ctrl, cq, eq, false,
+                                            false, 0);
+                if (ret) {
+                        shost_printk(KERN_ERR, phba->shost,
+                                     "beiscsi_cmd_eq_create"
+                                     "Failed for ISCSI CQ \n");
+                        goto create_cq_error;
+                }
+                SE_DEBUG(DBG_LVL_8, "iscsi cq_id is %d for eq_id %d\n",
+                                                 cq->id, eq->id);
+                SE_DEBUG(DBG_LVL_8, "ISCSI CQ CREATED\n");
         }
-        SE_DEBUG(DBG_LVL_8, "iscsi cq id is %d\n", phwi_context->be_cq.id);
-        SE_DEBUG(DBG_LVL_8, "ISCSI CQ CREATED\n");
         return 0;
+
+create_cq_error:
+        for (i = 0; i < phba->num_cpus; i++) {
+                cq = &phwi_context->be_cq[i];
+                mem = &cq->dma_mem;
+                if (mem->va)
+                        pci_free_consistent(phba->pcidev, num_cq_pages
+                                            * PAGE_SIZE,
+                                            mem->va, mem->dma);
+        }
+        return ret;
+
 }
 
 static int
@@ -2132,7 +2552,7 @@ beiscsi_create_def_hdr(struct beiscsi_hba *phba,
 
         idx = 0;
         dq = &phwi_context->be_def_hdrq;
-        cq = &phwi_context->be_cq;
+        cq = &phwi_context->be_cq[0];
         mem = &dq->dma_mem;
         mem_descr = phba->init_mem;
         mem_descr += HWI_MEM_ASYNC_HEADER_RING;
@@ -2176,7 +2596,7 @@ beiscsi_create_def_data(struct beiscsi_hba *phba,
 
         idx = 0;
         dataq = &phwi_context->be_def_dataq;
-        cq = &phwi_context->be_cq;
+        cq = &phwi_context->be_cq[0];
         mem = &dataq->dma_mem;
         mem_descr = phba->init_mem;
         mem_descr += HWI_MEM_ASYNC_DATA_RING;
@@ -2239,6 +2659,30 @@ beiscsi_post_pages(struct beiscsi_hba *phba)
         return 0;
 }
 
+static void be_queue_free(struct beiscsi_hba *phba, struct be_queue_info *q)
+{
+        struct be_dma_mem *mem = &q->dma_mem;
+        if (mem->va)
+                pci_free_consistent(phba->pcidev, mem->size,
+                        mem->va, mem->dma);
+}
+
+static int be_queue_alloc(struct beiscsi_hba *phba, struct be_queue_info *q,
+                u16 len, u16 entry_size)
+{
+        struct be_dma_mem *mem = &q->dma_mem;
+
+        memset(q, 0, sizeof(*q));
+        q->len = len;
+        q->entry_size = entry_size;
+        mem->size = len * entry_size;
+        mem->va = pci_alloc_consistent(phba->pcidev, mem->size, &mem->dma);
+        if (!mem->va)
+                return -1;
+        memset(mem->va, 0, mem->size);
+        return 0;
+}
+
 static int
 beiscsi_create_wrb_rings(struct beiscsi_hba *phba,
                          struct hwi_context_memory *phwi_context,
@@ -2308,7 +2752,8 @@ beiscsi_create_wrb_rings(struct beiscsi_hba *phba,
                                      "wrbq create failed.");
                         return status;
                 }
-                phwi_ctrlr->wrb_context[i].cid = phwi_context->be_wrbq[i].id;
+                phwi_ctrlr->wrb_context[i * 2].cid = phwi_context->be_wrbq[i].
+                                                                   id;
         }
         kfree(pwrb_arr);
         return 0;
@@ -2328,13 +2773,29 @@ static void free_wrb_handles(struct beiscsi_hba *phba)
         }
 }
 
+static void be_mcc_queues_destroy(struct beiscsi_hba *phba)
+{
+        struct be_queue_info *q;
+        struct be_ctrl_info *ctrl = &phba->ctrl;
+
+        q = &phba->ctrl.mcc_obj.q;
+        if (q->created)
+                beiscsi_cmd_q_destroy(ctrl, q, QTYPE_MCCQ);
+        be_queue_free(phba, q);
+
+        q = &phba->ctrl.mcc_obj.cq;
+        if (q->created)
+                beiscsi_cmd_q_destroy(ctrl, q, QTYPE_CQ);
+        be_queue_free(phba, q);
+}
+
 static void hwi_cleanup(struct beiscsi_hba *phba)
 {
         struct be_queue_info *q;
         struct be_ctrl_info *ctrl = &phba->ctrl;
         struct hwi_controller *phwi_ctrlr;
         struct hwi_context_memory *phwi_context;
-        int i;
+        int i, eq_num;
 
         phwi_ctrlr = phba->phwi_ctrlr;
         phwi_context = phwi_ctrlr->phwi_ctxt;
@@ -2343,7 +2804,6 @@ static void hwi_cleanup(struct beiscsi_hba *phba)
                 if (q->created)
                         beiscsi_cmd_q_destroy(ctrl, q, QTYPE_WRBQ);
         }
-
         free_wrb_handles(phba);
 
         q = &phwi_context->be_def_hdrq;
@@ -2356,13 +2816,76 @@ static void hwi_cleanup(struct beiscsi_hba *phba)
 
         beiscsi_cmd_q_destroy(ctrl, NULL, QTYPE_SGL);
 
-        q = &phwi_context->be_cq;
-        if (q->created)
-                beiscsi_cmd_q_destroy(ctrl, q, QTYPE_CQ);
+        for (i = 0; i < (phba->num_cpus); i++) {
+                q = &phwi_context->be_cq[i];
+                if (q->created)
+                        beiscsi_cmd_q_destroy(ctrl, q, QTYPE_CQ);
+        }
+        if (phba->msix_enabled)
+                eq_num = 1;
+        else
+                eq_num = 0;
+        for (i = 0; i < (phba->num_cpus + eq_num); i++) {
+                q = &phwi_context->be_eq[i].q;
+                if (q->created)
+                        beiscsi_cmd_q_destroy(ctrl, q, QTYPE_EQ);
+        }
+        be_mcc_queues_destroy(phba);
+}
 
-        q = &phwi_context->be_eq.q;
-        if (q->created)
-                beiscsi_cmd_q_destroy(ctrl, q, QTYPE_EQ);
+static int be_mcc_queues_create(struct beiscsi_hba *phba,
+                                struct hwi_context_memory *phwi_context)
+{
+        struct be_queue_info *q, *cq;
+        struct be_ctrl_info *ctrl = &phba->ctrl;
+
+        /* Alloc MCC compl queue */
+        cq = &phba->ctrl.mcc_obj.cq;
+        if (be_queue_alloc(phba, cq, MCC_CQ_LEN,
+                        sizeof(struct be_mcc_compl)))
+                goto err;
+        /* Ask BE to create MCC compl queue; */
+        if (phba->msix_enabled) {
+                if (beiscsi_cmd_cq_create(ctrl, cq, &phwi_context->be_eq
+                                         [phba->num_cpus].q, false, true, 0))
+                goto mcc_cq_free;
+        } else {
+                if (beiscsi_cmd_cq_create(ctrl, cq, &phwi_context->be_eq[0].q,
+                                          false, true, 0))
+                goto mcc_cq_free;
+        }
+
+        /* Alloc MCC queue */
+        q = &phba->ctrl.mcc_obj.q;
+        if (be_queue_alloc(phba, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb)))
+                goto mcc_cq_destroy;
+
+        /* Ask BE to create MCC queue */
+        if (beiscsi_cmd_mccq_create(phba, q, cq))
+                goto mcc_q_free;
+
+        return 0;
+
+mcc_q_free:
+        be_queue_free(phba, q);
+mcc_cq_destroy:
+        beiscsi_cmd_q_destroy(ctrl, cq, QTYPE_CQ);
+mcc_cq_free:
+        be_queue_free(phba, cq);
+err:
+        return -1;
+}
+
+static int find_num_cpus(void)
+{
+        int  num_cpus = 0;
+
+        num_cpus = num_online_cpus();
+        if (num_cpus >= MAX_CPUS)
+                num_cpus = MAX_CPUS - 1;
+
+        SE_DEBUG(DBG_LVL_8, "num_cpus = %d \n", num_cpus);
+        return num_cpus;
 }
 
 static int hwi_init_port(struct beiscsi_hba *phba)
@@ -2376,34 +2899,30 @@ static int hwi_init_port(struct beiscsi_hba *phba)
         def_pdu_ring_sz =
                 phba->params.asyncpdus_per_ctrl * sizeof(struct phys_addr);
         phwi_ctrlr = phba->phwi_ctrlr;
-
         phwi_context = phwi_ctrlr->phwi_ctxt;
-        phwi_context->be_eq.max_eqd = 0;
-        phwi_context->be_eq.min_eqd = 0;
-        phwi_context->be_eq.cur_eqd = 64;
-        phwi_context->be_eq.enable_aic = false;
+        phwi_context->max_eqd = 0;
+        phwi_context->min_eqd = 0;
+        phwi_context->cur_eqd = 64;
         be_cmd_fw_initialize(&phba->ctrl);
-        status = beiscsi_create_eq(phba, phwi_context);
+
+        status = beiscsi_create_eqs(phba, phwi_context);
         if (status != 0) {
                 shost_printk(KERN_ERR, phba->shost, "EQ not created \n");
                 goto error;
         }
 
-        status = mgmt_check_supported_fw(ctrl);
-        if (status != 0) {
-                shost_printk(KERN_ERR, phba->shost,
-                             "Unsupported fw version \n");
+        status = be_mcc_queues_create(phba, phwi_context);
+        if (status != 0)
                 goto error;
-        }
 
-        status = mgmt_get_fw_config(ctrl, phba);
+        status = mgmt_check_supported_fw(ctrl, phba);
         if (status != 0) {
                 shost_printk(KERN_ERR, phba->shost,
-                             "Error getting fw config\n");
+                             "Unsupported fw version \n");
                 goto error;
         }
 
-        status = beiscsi_create_cq(phba, phwi_context);
+        status = beiscsi_create_cqs(phba, phwi_context);
         if (status != 0) {
                 shost_printk(KERN_ERR, phba->shost, "CQ not created\n");
                 goto error;
@@ -2447,7 +2966,6 @@ error:
         return -ENOMEM;
 }
 
-
 static int hwi_init_controller(struct beiscsi_hba *phba)
 {
         struct hwi_controller *phwi_ctrlr;
@@ -2530,6 +3048,7 @@ static int beiscsi_init_sgl_handle(struct beiscsi_hba *phba)
 
         phba->io_sgl_hndl_avbl = 0;
         phba->eh_sgl_hndl_avbl = 0;
+
         mem_descr_sglh = phba->init_mem;
         mem_descr_sglh += HWI_MEM_SGLH;
         if (1 == mem_descr_sglh->num_elements) {
@@ -2608,7 +3127,7 @@ static int beiscsi_init_sgl_handle(struct beiscsi_hba *phba)
                         AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, pfrag, 0);
                         pfrag += phba->params.num_sge_per_io;
                         psgl_handle->sgl_index =
-                                phba->fw_config.iscsi_cid_start + arr_index++;
+                                phba->fw_config.iscsi_icd_start + arr_index++;
                 }
                 idx++;
         }
@@ -2623,7 +3142,7 @@ static int hba_setup_cid_tbls(struct beiscsi_hba *phba)
 {
         int i, new_cid;
 
-        phba->cid_array = kmalloc(sizeof(void *) * phba->params.cxns_per_ctrl,
+        phba->cid_array = kzalloc(sizeof(void *) * phba->params.cxns_per_ctrl,
                                   GFP_KERNEL);
         if (!phba->cid_array) {
                 shost_printk(KERN_ERR, phba->shost,
@@ -2631,7 +3150,7 @@ static int hba_setup_cid_tbls(struct beiscsi_hba *phba)
                              "hba_setup_cid_tbls\n");
                 return -ENOMEM;
         }
-        phba->ep_array = kmalloc(sizeof(struct iscsi_endpoint *) *
+        phba->ep_array = kzalloc(sizeof(struct iscsi_endpoint *) *
                                  phba->params.cxns_per_ctrl * 2, GFP_KERNEL);
         if (!phba->ep_array) {
                 shost_printk(KERN_ERR, phba->shost,
@@ -2640,7 +3159,7 @@ static int hba_setup_cid_tbls(struct beiscsi_hba *phba)
                 kfree(phba->cid_array);
                 return -ENOMEM;
         }
-        new_cid = phba->fw_config.iscsi_icd_start;
+        new_cid = phba->fw_config.iscsi_cid_start;
         for (i = 0; i < phba->params.cxns_per_ctrl; i++) {
                 phba->cid_array[i] = new_cid;
                 new_cid += 2;
@@ -2656,13 +3175,12 @@ static unsigned char hwi_enable_intr(struct beiscsi_hba *phba)
         struct hwi_context_memory *phwi_context;
         struct be_queue_info *eq;
         u8 __iomem *addr;
-        u32 reg;
+        u32 reg, i;
         u32 enabled;
 
         phwi_ctrlr = phba->phwi_ctrlr;
         phwi_context = phwi_ctrlr->phwi_ctxt;
 
-        eq = &phwi_context->be_eq.q;
         addr = (u8 __iomem *) ((u8 __iomem *) ctrl->pcicfg +
                         PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET);
         reg = ioread32(addr);
@@ -2673,12 +3191,18 @@ static unsigned char hwi_enable_intr(struct beiscsi_hba *phba)
                 reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
                 SE_DEBUG(DBG_LVL_8, "reg =x%08x addr=%p \n", reg, addr);
                 iowrite32(reg, addr);
-                SE_DEBUG(DBG_LVL_8, "eq->id=%d \n", eq->id);
-
-                hwi_ring_eq_db(phba, eq->id, 0, 0, 1, 1);
-        } else
-                shost_printk(KERN_WARNING, phba->shost,
-                             "In hwi_enable_intr, Not Enabled \n");
+                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);
+                        }
+                }
+        }
         return true;
 }
 
@@ -2738,17 +3262,30 @@ static void hwi_purge_eq(struct beiscsi_hba *phba)
         struct hwi_context_memory *phwi_context;
         struct be_queue_info *eq;
         struct be_eq_entry *eqe = NULL;
+        int i, eq_msix;
+        unsigned int num_processed;
 
         phwi_ctrlr = phba->phwi_ctrlr;
         phwi_context = phwi_ctrlr->phwi_ctxt;
-        eq = &phwi_context->be_eq.q;
-        eqe = queue_tail_node(eq);
+        if (phba->msix_enabled)
+                eq_msix = 1;
+        else
+                eq_msix = 0;
 
-        while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
-                                                & EQE_VALID_MASK) {
-                AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
-                queue_tail_inc(eq);
+        for (i = 0; i < (phba->num_cpus + eq_msix); i++) {
+                eq = &phwi_context->be_eq[i].q;
                 eqe = queue_tail_node(eq);
+                num_processed = 0;
+                while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
+                                        & EQE_VALID_MASK) {
+                        AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
+                        queue_tail_inc(eq);
+                        eqe = queue_tail_node(eq);
+                        num_processed++;
+                }
+
+                if (num_processed)
+                        hwi_ring_eq_db(phba, eq->id, 1, num_processed, 1, 1);
         }
 }
 
@@ -2760,8 +3297,9 @@ static void beiscsi_clean_port(struct beiscsi_hba *phba)
         if (mgmt_status)
                 shost_printk(KERN_WARNING, phba->shost,
                              "mgmt_epfw_cleanup FAILED \n");
-        hwi_cleanup(phba);
+
         hwi_purge_eq(phba);
+        hwi_cleanup(phba);
         kfree(phba->io_sgl_hndl_base);
         kfree(phba->eh_sgl_hndl_base);
         kfree(phba->cid_array);
@@ -2782,7 +3320,8 @@ beiscsi_offload_connection(struct beiscsi_conn *beiscsi_conn,
          * We can always use 0 here because it is reserved by libiscsi for
          * login/startup related tasks.
          */
-        pwrb_handle = alloc_wrb_handle(phba, beiscsi_conn->beiscsi_conn_cid, 0);
+        pwrb_handle = alloc_wrb_handle(phba, (beiscsi_conn->beiscsi_conn_cid -
+                                       phba->fw_config.iscsi_cid_start));
         pwrb = (struct iscsi_target_context_update_wrb *)pwrb_handle->pwrb;
         memset(pwrb, 0, sizeof(*pwrb));
         AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
@@ -2846,8 +3385,8 @@ beiscsi_offload_connection(struct beiscsi_conn *beiscsi_conn,
         be_dws_le_to_cpu(pwrb, sizeof(struct iscsi_target_context_update_wrb));
 
         doorbell |= beiscsi_conn->beiscsi_conn_cid & DB_WRB_POST_CID_MASK;
-        doorbell |= (pwrb_handle->wrb_index & DB_DEF_PDU_WRB_INDEX_MASK) <<
-                                        DB_DEF_PDU_WRB_INDEX_SHIFT;
+        doorbell |= (pwrb_handle->wrb_index & DB_DEF_PDU_WRB_INDEX_MASK)
+                             << DB_DEF_PDU_WRB_INDEX_SHIFT;
         doorbell |= 1 << DB_DEF_PDU_NUM_POSTED_SHIFT;
 
         iowrite32(doorbell, phba->db_va + DB_TXULP0_OFFSET);
@@ -2856,7 +3395,7 @@ beiscsi_offload_connection(struct beiscsi_conn *beiscsi_conn,
 static void beiscsi_parse_pdu(struct iscsi_conn *conn, itt_t itt,
                               int *index, int *age)
 {
-        *index = be32_to_cpu(itt) >> 16;
+        *index = (int)itt;
         if (age)
                 *age = conn->session->age;
 }
@@ -2885,15 +3424,14 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
 
         io_task->cmd_bhs = pci_pool_alloc(beiscsi_sess->bhs_pool,
                                           GFP_KERNEL, &paddr);
-
         if (!io_task->cmd_bhs)
                 return -ENOMEM;
-
         io_task->bhs_pa.u.a64.address = paddr;
+        io_task->libiscsi_itt = (itt_t)task->itt;
         io_task->pwrb_handle = alloc_wrb_handle(phba,
-                                                beiscsi_conn->beiscsi_conn_cid,
-                                                task->itt);
-        io_task->pwrb_handle->pio_handle = task;
+                                                beiscsi_conn->beiscsi_conn_cid -
+                                                phba->fw_config.iscsi_cid_start
+                                                );
         io_task->conn = beiscsi_conn;
 
         task->hdr = (struct iscsi_hdr *)&io_task->cmd_bhs->iscsi_hdr;
@@ -2905,10 +3443,9 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
                 spin_unlock(&phba->io_sgl_lock);
                 if (!io_task->psgl_handle)
                         goto free_hndls;
-
         } else {
                 io_task->scsi_cmnd = NULL;
-                if ((task->hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGIN) {
+                if ((opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGIN) {
                         if (!beiscsi_conn->login_in_progress) {
                                 spin_lock(&phba->mgmt_sgl_lock);
                                 io_task->psgl_handle = (struct sgl_handle *)
@@ -2932,14 +3469,19 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
                                 goto free_hndls;
                 }
         }
-        itt = (itt_t) cpu_to_be32(((unsigned int)task->itt << 16) |
-                        (unsigned int)(io_task->psgl_handle->sgl_index));
+        itt = (itt_t) cpu_to_be32(((unsigned int)io_task->pwrb_handle->
+                                 wrb_index << 16) | (unsigned int)
+                                (io_task->psgl_handle->sgl_index));
+        io_task->pwrb_handle->pio_handle = task;
+
         io_task->cmd_bhs->iscsi_hdr.itt = itt;
         return 0;
 
 free_hndls:
         phwi_ctrlr = phba->phwi_ctrlr;
-        pwrb_context = &phwi_ctrlr->wrb_context[beiscsi_conn->beiscsi_conn_cid];
+        pwrb_context = &phwi_ctrlr->wrb_context[
+                        beiscsi_conn->beiscsi_conn_cid -
+                        phba->fw_config.iscsi_cid_start];
         free_wrb_handle(phba, pwrb_context, io_task->pwrb_handle);
         io_task->pwrb_handle = NULL;
         pci_pool_free(beiscsi_sess->bhs_pool, io_task->cmd_bhs,
@@ -2959,7 +3501,8 @@ static void beiscsi_cleanup_task(struct iscsi_task *task)
         struct hwi_controller *phwi_ctrlr;
 
         phwi_ctrlr = phba->phwi_ctrlr;
-        pwrb_context = &phwi_ctrlr->wrb_context[beiscsi_conn->beiscsi_conn_cid];
+        pwrb_context = &phwi_ctrlr->wrb_context[beiscsi_conn->beiscsi_conn_cid
+                        - phba->fw_config.iscsi_cid_start];
         if (io_task->pwrb_handle) {
                 free_wrb_handle(phba, pwrb_context, io_task->pwrb_handle);
                 io_task->pwrb_handle = NULL;
@@ -3006,7 +3549,6 @@ static int beiscsi_iotask(struct iscsi_task *task, struct scatterlist *sg,
         io_task->bhs_len = sizeof(struct be_cmd_bhs);
 
         if (writedir) {
-                SE_DEBUG(DBG_LVL_4, " WRITE Command \t");
                 memset(&io_task->cmd_bhs->iscsi_data_pdu, 0, 48);
                 AMAP_SET_BITS(struct amap_pdu_data_out, itt,
                               &io_task->cmd_bhs->iscsi_data_pdu,
@@ -3016,11 +3558,12 @@ static int beiscsi_iotask(struct iscsi_task *task, struct scatterlist *sg,
                               ISCSI_OPCODE_SCSI_DATA_OUT);
                 AMAP_SET_BITS(struct amap_pdu_data_out, final_bit,
                               &io_task->cmd_bhs->iscsi_data_pdu, 1);
-                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb, INI_WR_CMD);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                              INI_WR_CMD);
                 AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 1);
         } else {
-                SE_DEBUG(DBG_LVL_4, "READ Command \t");
-                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb, INI_RD_CMD);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                              INI_RD_CMD);
                 AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 0);
         }
         memcpy(&io_task->cmd_bhs->iscsi_data_pdu.
@@ -3055,15 +3598,17 @@ static int beiscsi_iotask(struct iscsi_task *task, struct scatterlist *sg,
 
 static int beiscsi_mtask(struct iscsi_task *task)
 {
-        struct beiscsi_io_task *aborted_io_task, *io_task = task->dd_data;
+        struct beiscsi_io_task *io_task = task->dd_data;
         struct iscsi_conn *conn = task->conn;
         struct beiscsi_conn *beiscsi_conn = conn->dd_data;
         struct beiscsi_hba *phba = beiscsi_conn->phba;
         struct iscsi_wrb *pwrb = NULL;
         unsigned int doorbell = 0;
-        struct iscsi_task *aborted_task;
+        unsigned int cid;
 
+        cid = beiscsi_conn->beiscsi_conn_cid;
         pwrb = io_task->pwrb_handle->pwrb;
+        memset(pwrb, 0, sizeof(*pwrb));
         AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt, pwrb,
                       be32_to_cpu(task->cmdsn));
         AMAP_SET_BITS(struct amap_iscsi_wrb, wrb_idx, pwrb,
@@ -3073,40 +3618,37 @@ static int beiscsi_mtask(struct iscsi_task *task)
 
         switch (task->hdr->opcode & ISCSI_OPCODE_MASK) {
         case ISCSI_OP_LOGIN:
-                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb, TGT_DM_CMD);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                              TGT_DM_CMD);
                 AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
                 AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt, pwrb, 1);
                 hwi_write_buffer(pwrb, task);
                 break;
         case ISCSI_OP_NOOP_OUT:
-                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb, INI_RD_CMD);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                              INI_RD_CMD);
+                if (task->hdr->ttt == ISCSI_RESERVED_TAG)
+                        AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
+                else
+                        AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 1);
                 hwi_write_buffer(pwrb, task);
                 break;
         case ISCSI_OP_TEXT:
-                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb, INI_WR_CMD);
-                AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 1);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                              TGT_DM_CMD);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
                 hwi_write_buffer(pwrb, task);
                 break;
         case ISCSI_OP_SCSI_TMFUNC:
-                aborted_task = iscsi_itt_to_task(conn,
-                                        ((struct iscsi_tm *)task->hdr)->rtt);
-                 if (!aborted_task)
-                        return 0;
-                aborted_io_task = aborted_task->dd_data;
-                if (!aborted_io_task->scsi_cmnd)
-                        return 0;
-
-                mgmt_invalidate_icds(phba,
-                                     aborted_io_task->psgl_handle->sgl_index,
-                                     beiscsi_conn->beiscsi_conn_cid);
-                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb, INI_TMF_CMD);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                              INI_TMF_CMD);
                 AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
                 hwi_write_buffer(pwrb, task);
                 break;
         case ISCSI_OP_LOGOUT:
                 AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
                 AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                                HWH_TYPE_LOGOUT);
+                              HWH_TYPE_LOGOUT);
                 hwi_write_buffer(pwrb, task);
                 break;
 
@@ -3117,12 +3659,12 @@ static int beiscsi_mtask(struct iscsi_task *task)
         }
 
         AMAP_SET_BITS(struct amap_iscsi_wrb, r2t_exp_dtl, pwrb,
-                      be32_to_cpu(task->data_count));
+                      task->data_count);
         AMAP_SET_BITS(struct amap_iscsi_wrb, ptr2nextwrb, pwrb,
                       io_task->pwrb_handle->nxt_wrb_index);
         be_dws_le_to_cpu(pwrb, sizeof(struct iscsi_wrb));
 
-        doorbell |= beiscsi_conn->beiscsi_conn_cid & DB_WRB_POST_CID_MASK;
+        doorbell |= cid & DB_WRB_POST_CID_MASK;
         doorbell |= (io_task->pwrb_handle->wrb_index &
                      DB_DEF_PDU_WRB_INDEX_MASK) << DB_DEF_PDU_WRB_INDEX_SHIFT;
         doorbell |= 1 << DB_DEF_PDU_NUM_POSTED_SHIFT;
@@ -3132,17 +3674,12 @@ static int beiscsi_mtask(struct iscsi_task *task)
 
 static int beiscsi_task_xmit(struct iscsi_task *task)
 {
-        struct iscsi_conn *conn = task->conn;
         struct beiscsi_io_task *io_task = task->dd_data;
         struct scsi_cmnd *sc = task->sc;
-        struct beiscsi_conn *beiscsi_conn = conn->dd_data;
         struct scatterlist *sg;
         int num_sg;
         unsigned int  writedir = 0, xferlen = 0;
 
-        SE_DEBUG(DBG_LVL_4, "\n cid=%d In beiscsi_task_xmit task=%p conn=%p \t"
-                 "beiscsi_conn=%p \n", beiscsi_conn->beiscsi_conn_cid,
-                 task, conn, beiscsi_conn);
         if (!sc)
                 return beiscsi_mtask(task);
 
@@ -3168,6 +3705,10 @@ static int beiscsi_task_xmit(struct iscsi_task *task)
 static void beiscsi_remove(struct pci_dev *pcidev)
 {
         struct beiscsi_hba *phba = NULL;
+        struct hwi_controller *phwi_ctrlr;
+        struct hwi_context_memory *phwi_context;
+        struct be_eq_obj *pbe_eq;
+        unsigned int i, msix_vec;
 
         phba = (struct beiscsi_hba *)pci_get_drvdata(pcidev);
         if (!phba) {
@@ -3175,12 +3716,24 @@ static void beiscsi_remove(struct pci_dev *pcidev)
                 return;
         }
 
+        phwi_ctrlr = phba->phwi_ctrlr;
+        phwi_context = phwi_ctrlr->phwi_ctxt;
         hwi_disable_intr(phba);
-        if (phba->pcidev->irq)
-                free_irq(phba->pcidev->irq, phba);
+        if (phba->msix_enabled) {
+                for (i = 0; i <= phba->num_cpus; i++) {
+                        msix_vec = phba->msix_entries[i].vector;
+                        free_irq(msix_vec, &phwi_context->be_eq[i]);
+                }
+        } else
+                if (phba->pcidev->irq)
+                        free_irq(phba->pcidev->irq, phba);
+        pci_disable_msix(phba->pcidev);
         destroy_workqueue(phba->wq);
         if (blk_iopoll_enabled)
-                blk_iopoll_disable(&phba->iopoll);
+                for (i = 0; i < phba->num_cpus; i++) {
+                        pbe_eq = &phwi_context->be_eq[i];
+                        blk_iopoll_disable(&pbe_eq->iopoll);
+                }
 
         beiscsi_clean_port(phba);
         beiscsi_free_mem(phba);
@@ -3194,11 +3747,29 @@ static void beiscsi_remove(struct pci_dev *pcidev)
         iscsi_host_free(phba->shost);
 }
 
+static void beiscsi_msix_enable(struct beiscsi_hba *phba)
+{
+        int i, status;
+
+        for (i = 0; i <= phba->num_cpus; i++)
+                phba->msix_entries[i].entry = i;
+
+        status = pci_enable_msix(phba->pcidev, phba->msix_entries,
+                                 (phba->num_cpus + 1));
+        if (!status)
+                phba->msix_enabled = true;
+
+        return;
+}
+
 static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
                                 const struct pci_device_id *id)
 {
         struct beiscsi_hba *phba = NULL;
-        int ret;
+        struct hwi_controller *phwi_ctrlr;
+        struct hwi_context_memory *phwi_context;
+        struct be_eq_obj *pbe_eq;
+        int ret, msix_vec, num_cpus, i;
 
         ret = beiscsi_enable_pci(pcidev);
         if (ret < 0) {
@@ -3214,7 +3785,29 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
                 goto disable_pci;
         }
 
-        pci_set_drvdata(pcidev, phba);
+        switch (pcidev->device) {
+        case BE_DEVICE_ID1:
+        case OC_DEVICE_ID1:
+        case OC_DEVICE_ID2:
+                phba->generation = BE_GEN2;
+                break;
+        case BE_DEVICE_ID2:
+        case OC_DEVICE_ID3:
+                phba->generation = BE_GEN3;
+                break;
+        default:
+                phba->generation = 0;
+        }
+
+        if (enable_msix)
+                num_cpus = find_num_cpus();
+        else
+                num_cpus = 1;
+        phba->num_cpus = num_cpus;
+        SE_DEBUG(DBG_LVL_8, "num_cpus = %d \n", phba->num_cpus);
+
+        if (enable_msix)
+                beiscsi_msix_enable(phba);
         ret = be_ctrl_init(phba, pcidev);
         if (ret) {
                 shost_printk(KERN_ERR, phba->shost, "beiscsi_dev_probe-"
@@ -3225,7 +3818,15 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
         spin_lock_init(&phba->io_sgl_lock);
         spin_lock_init(&phba->mgmt_sgl_lock);
         spin_lock_init(&phba->isr_lock);
+        ret = mgmt_get_fw_config(&phba->ctrl, phba);
+        if (ret != 0) {
+                shost_printk(KERN_ERR, phba->shost,
+                             "Error getting fw config\n");
+                goto free_port;
+        }
+        phba->shost->max_id = phba->fw_config.iscsi_cid_count;
         beiscsi_get_params(phba);
+        phba->shost->can_queue = phba->params.ios_per_ctrl;
         ret = beiscsi_init_port(phba);
         if (ret < 0) {
                 shost_printk(KERN_ERR, phba->shost, "beiscsi_dev_probe-"
@@ -3233,9 +3834,18 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
                 goto free_port;
         }
 
+        for (i = 0; i < MAX_MCC_CMD ; i++) {
+                init_waitqueue_head(&phba->ctrl.mcc_wait[i + 1]);
+                phba->ctrl.mcc_tag[i] = i + 1;
+                phba->ctrl.mcc_numtag[i + 1] = 0;
+                phba->ctrl.mcc_tag_available++;
+        }
+
+        phba->ctrl.mcc_alloc_index = phba->ctrl.mcc_free_index = 0;
+
         snprintf(phba->wq_name, sizeof(phba->wq_name), "beiscsi_q_irq%u",
                  phba->shost->host_no);
-        phba->wq = create_singlethread_workqueue(phba->wq_name);
+        phba->wq = create_workqueue(phba->wq_name);
         if (!phba->wq) {
                 shost_printk(KERN_ERR, phba->shost, "beiscsi_dev_probe-"
                                 "Failed to allocate work queue\n");
@@ -3244,11 +3854,16 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
 
         INIT_WORK(&phba->work_cqs, beiscsi_process_all_cqs);
 
+        phwi_ctrlr = phba->phwi_ctrlr;
+        phwi_context = phwi_ctrlr->phwi_ctxt;
         if (blk_iopoll_enabled) {
-                blk_iopoll_init(&phba->iopoll, be_iopoll_budget, be_iopoll);
-                blk_iopoll_enable(&phba->iopoll);
+                for (i = 0; i < phba->num_cpus; i++) {
+                        pbe_eq = &phwi_context->be_eq[i];
+                        blk_iopoll_init(&pbe_eq->iopoll, be_iopoll_budget,
+                                        be_iopoll);
+                        blk_iopoll_enable(&pbe_eq->iopoll);
+                }
         }
-
         ret = beiscsi_init_irqs(phba);
         if (ret < 0) {
                 shost_printk(KERN_ERR, phba->shost, "beiscsi_dev_probe-"
@@ -3261,17 +3876,26 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
                              "Failed to hwi_enable_intr\n");
                 goto free_ctrlr;
         }
-
         SE_DEBUG(DBG_LVL_8, "\n\n\n SUCCESS - DRIVER LOADED \n\n\n");
         return 0;
 
 free_ctrlr:
-        if (phba->pcidev->irq)
-                free_irq(phba->pcidev->irq, phba);
+        if (phba->msix_enabled) {
+                for (i = 0; i <= phba->num_cpus; i++) {
+                        msix_vec = phba->msix_entries[i].vector;
+                        free_irq(msix_vec, &phwi_context->be_eq[i]);
+                }
+        } else
+                if (phba->pcidev->irq)
+                        free_irq(phba->pcidev->irq, phba);
+        pci_disable_msix(phba->pcidev);
 free_blkenbld:
         destroy_workqueue(phba->wq);
         if (blk_iopoll_enabled)
-                blk_iopoll_disable(&phba->iopoll);
+                for (i = 0; i < phba->num_cpus; i++) {
+                        pbe_eq = &phwi_context->be_eq[i];
+                        blk_iopoll_disable(&pbe_eq->iopoll);
+                }
 free_twq:
         beiscsi_clean_port(phba);
         beiscsi_free_mem(phba);
@@ -3293,7 +3917,7 @@ disable_pci:
 struct iscsi_transport beiscsi_iscsi_transport = {
         .owner = THIS_MODULE,
         .name = DRV_NAME,
-        .caps = CAP_RECOVERY_L0 | CAP_HDRDGST |
+        .caps = CAP_RECOVERY_L0 | CAP_HDRDGST | CAP_TEXT_NEGO |
                 CAP_MULTI_R2T | CAP_DATADGST | CAP_DATA_PATH_OFFLOAD,
         .param_mask = ISCSI_MAX_RECV_DLENGTH |
                 ISCSI_MAX_XMIT_DLENGTH |
@@ -3351,6 +3975,7 @@ static struct pci_driver beiscsi_pci_driver = {
         .id_table = beiscsi_pci_id_table
 };
 
+
 static int __init beiscsi_module_init(void)
 {
         int ret;
@@ -3361,7 +3986,7 @@ static int __init beiscsi_module_init(void)
                 SE_DEBUG(DBG_LVL_1,
                          "beiscsi_module_init - Unable to  register beiscsi"
                          "transport.\n");
-                ret = -ENOMEM;
+                return -ENOMEM;
         }
         SE_DEBUG(DBG_LVL_8, "In beiscsi_module_init, tt=%p \n",
                  &beiscsi_iscsi_transport);
diff --git a/drivers/scsi/be2iscsi/be_main.h b/drivers/scsi/be2iscsi/be_main.h
index 53c9b70ac7ac..87ec21280a37 100644
--- a/drivers/scsi/be2iscsi/be_main.h
+++ b/drivers/scsi/be2iscsi/be_main.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -21,11 +21,9 @@
 #ifndef _BEISCSI_MAIN_
 #define _BEISCSI_MAIN_
 
-
 #include <linux/kernel.h>
 #include <linux/pci.h>
 #include <linux/in.h>
-#include <linux/blk-iopoll.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
@@ -35,39 +33,36 @@
 #include <scsi/scsi_transport_iscsi.h>
 
 #include "be.h"
-
-
-
 #define DRV_NAME                "be2iscsi"
 #define BUILD_STR               "2.0.527.0"
-
 #define BE_NAME                 "ServerEngines BladeEngine2" \
                                 "Linux iSCSI Driver version" BUILD_STR
 #define DRV_DESC                BE_NAME " " "Driver"
 
 #define BE_VENDOR_ID            0x19A2
+/* DEVICE ID's for BE2 */
 #define BE_DEVICE_ID1           0x212
 #define OC_DEVICE_ID1           0x702
 #define OC_DEVICE_ID2           0x703
 
-#define BE2_MAX_SESSIONS        64
+/* DEVICE ID's for BE3 */
+#define BE_DEVICE_ID2           0x222
+#define OC_DEVICE_ID3           0x712
+
+#define BE2_IO_DEPTH            1024
+#define BE2_MAX_SESSIONS        256
 #define BE2_CMDS_PER_CXN        128
-#define BE2_LOGOUTS             BE2_MAX_SESSIONS
 #define BE2_TMFS                16
 #define BE2_NOPOUT_REQ          16
-#define BE2_ASYNCPDUS           BE2_MAX_SESSIONS
-#define BE2_MAX_ICDS            2048
 #define BE2_SGE                 32
 #define BE2_DEFPDU_HDR_SZ       64
 #define BE2_DEFPDU_DATA_SZ      8192
-#define BE2_IO_DEPTH \
-        (BE2_MAX_ICDS / 2 - (BE2_LOGOUTS + BE2_TMFS + BE2_NOPOUT_REQ))
 
-#define BEISCSI_SGLIST_ELEMENTS BE2_SGE
+#define MAX_CPUS                31
+#define BEISCSI_SGLIST_ELEMENTS 30
 
-#define BEISCSI_MAX_CMNDS       1024    /* Max IO's per Ctrlr sht->can_queue */
 #define BEISCSI_CMD_PER_LUN     128     /* scsi_host->cmd_per_lun */
-#define BEISCSI_MAX_SECTORS     2048    /* scsi_host->max_sectors */
+#define BEISCSI_MAX_SECTORS     256     /* scsi_host->max_sectors */
 
 #define BEISCSI_MAX_CMD_LEN     16      /* scsi_host->max_cmd_len */
 #define BEISCSI_NUM_MAX_LUN     256     /* scsi_host->max_lun */
@@ -79,7 +74,7 @@
 #define BE_SENSE_INFO_SIZE              258
 #define BE_ISCSI_PDU_HEADER_SIZE        64
 #define BE_MIN_MEM_SIZE                 16384
-
+#define MAX_CMD_SZ                      65536
 #define IIOC_SCSI_DATA                  0x05    /* Write Operation */
 
 #define DBG_LVL                         0x00000001
@@ -100,6 +95,8 @@ do {							\
         }                                               \
 } while (0);
 
+#define BE_ADAPTER_UP           0x00000000
+#define BE_ADAPTER_LINK_DOWN    0x00000001
 /**
  * hardware needs the async PDU buffers to be posted in multiples of 8
  * So have atleast 8 of them by default
@@ -160,21 +157,19 @@ do {							\
 
 enum be_mem_enum {
         HWI_MEM_ADDN_CONTEXT,
-        HWI_MEM_CQ,
-        HWI_MEM_EQ,
         HWI_MEM_WRB,
         HWI_MEM_WRBH,
-        HWI_MEM_SGLH,   /* 5 */
+        HWI_MEM_SGLH,
         HWI_MEM_SGE,
-        HWI_MEM_ASYNC_HEADER_BUF,
+        HWI_MEM_ASYNC_HEADER_BUF,       /* 5 */
         HWI_MEM_ASYNC_DATA_BUF,
         HWI_MEM_ASYNC_HEADER_RING,
-        HWI_MEM_ASYNC_DATA_RING,        /* 10 */
+        HWI_MEM_ASYNC_DATA_RING,
         HWI_MEM_ASYNC_HEADER_HANDLE,
-        HWI_MEM_ASYNC_DATA_HANDLE,
+        HWI_MEM_ASYNC_DATA_HANDLE,      /* 10 */
         HWI_MEM_ASYNC_PDU_CONTEXT,
         ISCSI_MEM_GLOBAL_HEADER,
-        SE_MEM_MAX      /* 15 */
+        SE_MEM_MAX
 };
 
 struct be_bus_address32 {
@@ -212,6 +207,9 @@ struct be_mem_descriptor {
 
 struct sgl_handle {
         unsigned int sgl_index;
+        unsigned int type;
+        unsigned int cid;
+        struct iscsi_task *task;
         struct iscsi_sge *pfrag;
 };
 
@@ -259,6 +257,11 @@ struct hba_parameters {
         unsigned int num_sge;
 };
 
+struct invalidate_command_table {
+        unsigned short icd;
+        unsigned short cid;
+} __packed;
+
 struct beiscsi_hba {
         struct hba_parameters params;
         struct hwi_controller *phwi_ctrlr;
@@ -274,13 +277,17 @@ struct beiscsi_hba {
         struct pci_dev *pcidev;
         unsigned int state;
         unsigned short asic_revision;
-        struct blk_iopoll       iopoll;
+        unsigned int num_cpus;
+        unsigned int nxt_cqid;
+        struct msix_entry msix_entries[MAX_CPUS + 1];
+        bool msix_enabled;
         struct be_mem_descriptor *init_mem;
 
         unsigned short io_sgl_alloc_index;
         unsigned short io_sgl_free_index;
         unsigned short io_sgl_hndl_avbl;
         struct sgl_handle **io_sgl_hndl_base;
+        struct sgl_handle **sgl_hndl_array;
 
         unsigned short eh_sgl_alloc_index;
         unsigned short eh_sgl_free_index;
@@ -315,6 +322,7 @@ struct beiscsi_hba {
                 unsigned short cid_alloc;
                 unsigned short cid_free;
                 unsigned short avlbl_cids;
+                unsigned short iscsi_features;
                 spinlock_t cid_lock;
         } fw_config;
 
@@ -325,6 +333,9 @@ struct beiscsi_hba {
         struct workqueue_struct *wq;    /* The actuak work queue */
         struct work_struct work_cqs;    /* The work being queued */
         struct be_ctrl_info ctrl;
+        unsigned int generation;
+        struct invalidate_command_table inv_tbl[128];
+
 };
 
 struct beiscsi_session {
@@ -343,6 +354,7 @@ struct beiscsi_conn {
         unsigned short login_in_progress;
         struct sgl_handle *plogin_sgl_handle;
         struct beiscsi_session *beiscsi_sess;
+        struct iscsi_task *task;
 };
 
 /* This structure is used by the chip */
@@ -390,7 +402,7 @@ struct beiscsi_io_task {
         unsigned int flags;
         unsigned short cid;
         unsigned short header_len;
-
+        itt_t libiscsi_itt;
         struct be_cmd_bhs *cmd_bhs;
         struct be_bus_address bhs_pa;
         unsigned short bhs_len;
@@ -486,8 +498,6 @@ struct hwi_async_entry {
         struct list_head data_busy_list;
 };
 
-#define BE_MIN_ASYNC_ENTRIES 128
-
 struct hwi_async_pdu_context {
         struct {
                 struct be_bus_address pa_base;
@@ -528,7 +538,7 @@ struct hwi_async_pdu_context {
          * This is a varying size list! Do not add anything
          * after this entry!!
          */
-        struct hwi_async_entry async_entry[BE_MIN_ASYNC_ENTRIES];
+        struct hwi_async_entry async_entry[BE2_MAX_SESSIONS * 2];
 };
 
 #define PDUCQE_CODE_MASK        0x0000003F
@@ -599,7 +609,6 @@ struct amap_cq_db {
 
 void beiscsi_process_eq(struct beiscsi_hba *phba);
 
-
 struct iscsi_wrb {
         u32 dw[16];
 } __packed;
@@ -651,11 +660,12 @@ struct amap_iscsi_wrb {
 
 } __packed;
 
-struct wrb_handle *alloc_wrb_handle(struct beiscsi_hba *phba, unsigned int cid,
-                                    int index);
+struct wrb_handle *alloc_wrb_handle(struct beiscsi_hba *phba, unsigned int cid);
 void
 free_mgmt_sgl_handle(struct beiscsi_hba *phba, struct sgl_handle *psgl_handle);
 
+void beiscsi_process_all_cqs(struct work_struct *work);
+
 struct pdu_nop_out {
         u32 dw[12];
 };
@@ -797,7 +807,6 @@ struct hwi_controller {
         struct be_ring default_pdu_hdr;
         struct be_ring default_pdu_data;
         struct hwi_context_memory *phwi_ctxt;
-        unsigned short cq_errors[CXN_KILLED_CMND_DATA_NOT_ON_SAME_CONN];
 };
 
 enum hwh_type_enum {
@@ -820,10 +829,12 @@ struct wrb_handle {
 };
 
 struct hwi_context_memory {
-        struct be_eq_obj be_eq;
-        struct be_queue_info be_cq;
-        struct be_queue_info be_mcc_cq;
-        struct be_queue_info be_mcc;
+        /* Adaptive interrupt coalescing (AIC) info */
+        u16 min_eqd;            /* in usecs */
+        u16 max_eqd;            /* in usecs */
+        u16 cur_eqd;            /* in usecs */
+        struct be_eq_obj be_eq[MAX_CPUS];
+        struct be_queue_info be_cq[MAX_CPUS];
 
         struct be_queue_info be_def_hdrq;
         struct be_queue_info be_def_dataq;
diff --git a/drivers/scsi/be2iscsi/be_mgmt.c b/drivers/scsi/be2iscsi/be_mgmt.c
index 12e644fc746e..e641922f20bc 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.c
+++ b/drivers/scsi/be2iscsi/be_mgmt.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -35,7 +35,6 @@ unsigned char mgmt_get_fw_config(struct be_ctrl_info *ctrl,
 
         be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
                            OPCODE_COMMON_QUERY_FIRMWARE_CONFIG, sizeof(*req));
-
         status = be_mbox_notify(ctrl);
         if (!status) {
                 struct be_fw_cfg *pfw_cfg;
@@ -49,6 +48,14 @@ unsigned char mgmt_get_fw_config(struct be_ctrl_info *ctrl,
                                         pfw_cfg->ulp[0].sq_base;
                 phba->fw_config.iscsi_cid_count =
                                         pfw_cfg->ulp[0].sq_count;
+                if (phba->fw_config.iscsi_cid_count > (BE2_MAX_SESSIONS / 2)) {
+                        SE_DEBUG(DBG_LVL_8,
+                                "FW reported MAX CXNS as %d \t"
+                                "Max Supported = %d.\n",
+                                phba->fw_config.iscsi_cid_count,
+                                BE2_MAX_SESSIONS);
+                        phba->fw_config.iscsi_cid_count = BE2_MAX_SESSIONS / 2;
+                }
         } else {
                 shost_printk(KERN_WARNING, phba->shost,
                              "Failed in mgmt_get_fw_config \n");
@@ -58,7 +65,8 @@ unsigned char mgmt_get_fw_config(struct be_ctrl_info *ctrl,
         return status;
 }
 
-unsigned char mgmt_check_supported_fw(struct be_ctrl_info *ctrl)
+unsigned char mgmt_check_supported_fw(struct be_ctrl_info *ctrl,
+                                      struct beiscsi_hba *phba)
 {
         struct be_dma_mem nonemb_cmd;
         struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
@@ -77,6 +85,7 @@ unsigned char mgmt_check_supported_fw(struct be_ctrl_info *ctrl)
         }
         nonemb_cmd.size = sizeof(struct be_mgmt_controller_attributes);
         req = nonemb_cmd.va;
+        memset(req, 0, sizeof(*req));
         spin_lock(&ctrl->mbox_lock);
         memset(wrb, 0, sizeof(*wrb));
         be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
@@ -85,7 +94,6 @@ unsigned char mgmt_check_supported_fw(struct be_ctrl_info *ctrl)
         sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd.dma));
         sge->pa_lo = cpu_to_le32(nonemb_cmd.dma & 0xFFFFFFFF);
         sge->len = cpu_to_le32(nonemb_cmd.size);
-
         status = be_mbox_notify(ctrl);
         if (!status) {
                 struct be_mgmt_controller_attributes_resp *resp = nonemb_cmd.va;
@@ -95,21 +103,25 @@ unsigned char mgmt_check_supported_fw(struct be_ctrl_info *ctrl)
                         resp->params.hba_attribs.firmware_version_string);
                 SE_DEBUG(DBG_LVL_8,
                         "Developer Build, not performing version check...\n");
-
+                phba->fw_config.iscsi_features =
+                                resp->params.hba_attribs.iscsi_features;
+                SE_DEBUG(DBG_LVL_8, " phba->fw_config.iscsi_features = %d\n",
+                                      phba->fw_config.iscsi_features);
         } else
                 SE_DEBUG(DBG_LVL_1, " Failed in mgmt_check_supported_fw\n");
+        spin_unlock(&ctrl->mbox_lock);
         if (nonemb_cmd.va)
                 pci_free_consistent(ctrl->pdev, nonemb_cmd.size,
                                     nonemb_cmd.va, nonemb_cmd.dma);
 
-        spin_unlock(&ctrl->mbox_lock);
         return status;
 }
 
+
 unsigned char mgmt_epfw_cleanup(struct beiscsi_hba *phba, unsigned short chute)
 {
         struct be_ctrl_info *ctrl = &phba->ctrl;
-        struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
+        struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
         struct iscsi_cleanup_req *req = embedded_payload(wrb);
         int status = 0;
 
@@ -124,7 +136,7 @@ unsigned char mgmt_epfw_cleanup(struct beiscsi_hba *phba, unsigned short chute)
         req->hdr_ring_id = 0;
         req->data_ring_id = 0;
 
-        status = be_mbox_notify(ctrl);
+        status =  be_mcc_notify_wait(phba);
         if (status)
                 shost_printk(KERN_WARNING, phba->shost,
                              " mgmt_epfw_cleanup , FAILED\n");
@@ -133,14 +145,22 @@ unsigned char mgmt_epfw_cleanup(struct beiscsi_hba *phba, unsigned short chute)
 }
 
 unsigned char mgmt_invalidate_icds(struct beiscsi_hba *phba,
-                                   unsigned int icd, unsigned int cid)
+                                struct invalidate_command_table *inv_tbl,
+                                unsigned int num_invalidate, unsigned int cid)
 {
         struct be_dma_mem nonemb_cmd;
         struct be_ctrl_info *ctrl = &phba->ctrl;
-        struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
-        struct be_sge *sge = nonembedded_sgl(wrb);
+        struct be_mcc_wrb *wrb;
+        struct be_sge *sge;
         struct invalidate_commands_params_in *req;
-        int status = 0;
+        unsigned int i, tag = 0;
+
+        spin_lock(&ctrl->mbox_lock);
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                return tag;
+        }
 
         nonemb_cmd.va = pci_alloc_consistent(ctrl->pdev,
                                 sizeof(struct invalidate_commands_params_in),
@@ -149,12 +169,15 @@ unsigned char mgmt_invalidate_icds(struct beiscsi_hba *phba,
                 SE_DEBUG(DBG_LVL_1,
                          "Failed to allocate memory for"
                          "mgmt_invalidate_icds \n");
+                spin_unlock(&ctrl->mbox_lock);
                 return -1;
         }
         nonemb_cmd.size = sizeof(struct invalidate_commands_params_in);
         req = nonemb_cmd.va;
-        spin_lock(&ctrl->mbox_lock);
-        memset(wrb, 0, sizeof(*wrb));
+        memset(req, 0, sizeof(*req));
+        wrb = wrb_from_mccq(phba);
+        sge = nonembedded_sgl(wrb);
+        wrb->tag0 |= tag;
 
         be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
         be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
@@ -162,21 +185,22 @@ unsigned char mgmt_invalidate_icds(struct beiscsi_hba *phba,
                         sizeof(*req));
         req->ref_handle = 0;
         req->cleanup_type = CMD_ISCSI_COMMAND_INVALIDATE;
-        req->icd_count = 0;
-        req->table[req->icd_count].icd = icd;
-        req->table[req->icd_count].cid = cid;
+        for (i = 0; i < num_invalidate; i++) {
+                req->table[i].icd = inv_tbl->icd;
+                req->table[i].cid = inv_tbl->cid;
+                req->icd_count++;
+                inv_tbl++;
+        }
         sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd.dma));
         sge->pa_lo = cpu_to_le32(nonemb_cmd.dma & 0xFFFFFFFF);
         sge->len = cpu_to_le32(nonemb_cmd.size);
 
-        status = be_mbox_notify(ctrl);
-        if (status)
-                SE_DEBUG(DBG_LVL_1, "ICDS Invalidation Failed\n");
+        be_mcc_notify(phba);
         spin_unlock(&ctrl->mbox_lock);
         if (nonemb_cmd.va)
                 pci_free_consistent(ctrl->pdev, nonemb_cmd.size,
                                     nonemb_cmd.va, nonemb_cmd.dma);
-        return status;
+        return tag;
 }
 
 unsigned char mgmt_invalidate_connection(struct beiscsi_hba *phba,
@@ -186,13 +210,19 @@ unsigned char mgmt_invalidate_connection(struct beiscsi_hba *phba,
                                          unsigned short savecfg_flag)
 {
         struct be_ctrl_info *ctrl = &phba->ctrl;
-        struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
-        struct iscsi_invalidate_connection_params_in *req =
-                                                embedded_payload(wrb);
-        int status = 0;
+        struct be_mcc_wrb *wrb;
+        struct iscsi_invalidate_connection_params_in *req;
+        unsigned int tag = 0;
 
         spin_lock(&ctrl->mbox_lock);
-        memset(wrb, 0, sizeof(*wrb));
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                return tag;
+        }
+        wrb = wrb_from_mccq(phba);
+        wrb->tag0 |= tag;
+        req = embedded_payload(wrb);
 
         be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
         be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
@@ -205,35 +235,37 @@ unsigned char mgmt_invalidate_connection(struct beiscsi_hba *phba,
         else
                 req->cleanup_type = CMD_ISCSI_CONNECTION_INVALIDATE;
         req->save_cfg = savecfg_flag;
-        status = be_mbox_notify(ctrl);
-        if (status)
-                SE_DEBUG(DBG_LVL_1, "Invalidation Failed\n");
-
+        be_mcc_notify(phba);
         spin_unlock(&ctrl->mbox_lock);
-        return status;
+        return tag;
 }
 
 unsigned char mgmt_upload_connection(struct beiscsi_hba *phba,
                                 unsigned short cid, unsigned int upload_flag)
 {
         struct be_ctrl_info *ctrl = &phba->ctrl;
-        struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
-        struct tcp_upload_params_in *req = embedded_payload(wrb);
-        int status = 0;
+        struct be_mcc_wrb *wrb;
+        struct tcp_upload_params_in *req;
+        unsigned int tag = 0;
 
         spin_lock(&ctrl->mbox_lock);
-        memset(wrb, 0, sizeof(*wrb));
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                return tag;
+        }
+        wrb = wrb_from_mccq(phba);
+        req = embedded_payload(wrb);
+        wrb->tag0 |= tag;
 
         be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
         be_cmd_hdr_prepare(&req->hdr, CMD_COMMON_TCP_UPLOAD,
                            OPCODE_COMMON_TCP_UPLOAD, sizeof(*req));
         req->id = (unsigned short)cid;
         req->upload_type = (unsigned char)upload_flag;
-        status = be_mbox_notify(ctrl);
-        if (status)
-                SE_DEBUG(DBG_LVL_1, "mgmt_upload_connection Failed\n");
+        be_mcc_notify(phba);
         spin_unlock(&ctrl->mbox_lock);
-        return status;
+        return tag;
 }
 
 int mgmt_open_connection(struct beiscsi_hba *phba,
@@ -245,13 +277,14 @@ int mgmt_open_connection(struct beiscsi_hba *phba,
         struct sockaddr_in *daddr_in = (struct sockaddr_in *)dst_addr;
         struct sockaddr_in6 *daddr_in6 = (struct sockaddr_in6 *)dst_addr;
         struct be_ctrl_info *ctrl = &phba->ctrl;
-        struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
-        struct tcp_connect_and_offload_in *req = embedded_payload(wrb);
+        struct be_mcc_wrb *wrb;
+        struct tcp_connect_and_offload_in *req;
         unsigned short def_hdr_id;
         unsigned short def_data_id;
         struct phys_addr template_address = { 0, 0 };
         struct phys_addr *ptemplate_address;
-        int status = 0;
+        unsigned int tag = 0;
+        unsigned int i;
         unsigned short cid = beiscsi_ep->ep_cid;
 
         phwi_ctrlr = phba->phwi_ctrlr;
@@ -262,7 +295,14 @@ int mgmt_open_connection(struct beiscsi_hba *phba,
         ptemplate_address = &template_address;
         ISCSI_GET_PDU_TEMPLATE_ADDRESS(phba, ptemplate_address);
         spin_lock(&ctrl->mbox_lock);
-        memset(wrb, 0, sizeof(*wrb));
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                return tag;
+        }
+        wrb = wrb_from_mccq(phba);
+        req = embedded_payload(wrb);
+        wrb->tag0 |= tag;
 
         be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
         be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
@@ -296,26 +336,47 @@ int mgmt_open_connection(struct beiscsi_hba *phba,
 
         }
         req->cid = cid;
-        req->cq_id = phwi_context->be_cq.id;
+        i = phba->nxt_cqid++;
+        if (phba->nxt_cqid == phba->num_cpus)
+                phba->nxt_cqid = 0;
+        req->cq_id = phwi_context->be_cq[i].id;
+        SE_DEBUG(DBG_LVL_8, "i=%d cq_id=%d \n", i, req->cq_id);
         req->defq_id = def_hdr_id;
         req->hdr_ring_id = def_hdr_id;
         req->data_ring_id = def_data_id;
         req->do_offload = 1;
         req->dataout_template_pa.lo = ptemplate_address->lo;
         req->dataout_template_pa.hi = ptemplate_address->hi;
-        status = be_mbox_notify(ctrl);
-        if (!status) {
-                struct iscsi_endpoint *ep;
-                struct tcp_connect_and_offload_out *ptcpcnct_out =
-                                                        embedded_payload(wrb);
-
-                ep = phba->ep_array[ptcpcnct_out->cid];
-                beiscsi_ep = ep->dd_data;
-                beiscsi_ep->fw_handle = 0;
-                beiscsi_ep->cid_vld = 1;
-                SE_DEBUG(DBG_LVL_8, "mgmt_open_connection Success\n");
-        } else
-                SE_DEBUG(DBG_LVL_1, "mgmt_open_connection Failed\n");
+        be_mcc_notify(phba);
         spin_unlock(&ctrl->mbox_lock);
-        return status;
+        return tag;
 }
+
+unsigned int be_cmd_get_mac_addr(struct beiscsi_hba *phba)
+{
+        struct be_ctrl_info *ctrl = &phba->ctrl;
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_req_get_mac_addr *req;
+        unsigned int tag = 0;
+
+        SE_DEBUG(DBG_LVL_8, "In be_cmd_get_mac_addr\n");
+        spin_lock(&ctrl->mbox_lock);
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                return tag;
+        }
+
+        wrb = wrb_from_mccq(phba);
+        req = embedded_payload(wrb);
+        wrb->tag0 |= tag;
+        be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
+        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
+                           OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG,
+                           sizeof(*req));
+
+        be_mcc_notify(phba);
+        spin_unlock(&ctrl->mbox_lock);
+        return tag;
+}
+
diff --git a/drivers/scsi/be2iscsi/be_mgmt.h b/drivers/scsi/be2iscsi/be_mgmt.h
index 00e816ee8070..3d316b82feb1 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.h
+++ b/drivers/scsi/be2iscsi/be_mgmt.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -94,7 +94,8 @@ unsigned char mgmt_upload_connection(struct beiscsi_hba *phba,
                                      unsigned short cid,
                                      unsigned int upload_flag);
 unsigned char mgmt_invalidate_icds(struct beiscsi_hba *phba,
-                                   unsigned int icd, unsigned int cid);
+                                struct invalidate_command_table *inv_tbl,
+                                unsigned int num_invalidate, unsigned int cid);
 
 struct iscsi_invalidate_connection_params_in {
         struct be_cmd_req_hdr hdr;
@@ -116,11 +117,6 @@ union iscsi_invalidate_connection_params {
         struct iscsi_invalidate_connection_params_out response;
 } __packed;
 
-struct invalidate_command_table {
-        unsigned short icd;
-        unsigned short cid;
-} __packed;
-
 struct invalidate_commands_params_in {
         struct be_cmd_req_hdr hdr;
         unsigned int ref_handle;
@@ -175,7 +171,9 @@ struct mgmt_hba_attributes {
         u8 phy_port;
         u32 firmware_post_status;
         u32 hba_mtu[8];
-        u32 future_u32[4];
+        u8 iscsi_features;
+        u8 future_u8[3];
+        u32 future_u32[3];
 } __packed;
 
 struct mgmt_controller_attributes {
@@ -229,6 +227,7 @@ struct beiscsi_endpoint {
         struct beiscsi_hba *phba;
         struct beiscsi_sess *sess;
         struct beiscsi_conn *conn;
+        struct iscsi_endpoint *openiscsi_ep;
         unsigned short ip_type;
         char dst6_addr[ISCSI_ADDRESS_BUF_LEN];
         unsigned long dst_addr;
@@ -246,4 +245,5 @@ unsigned char mgmt_invalidate_connection(struct beiscsi_hba *phba,
                                          unsigned short cid,
                                          unsigned short issue_reset,
                                          unsigned short savecfg_flag);
+
 #endif
diff --git a/drivers/scsi/bfa/Makefile b/drivers/scsi/bfa/Makefile
index 1d6009490d1c..17e06cae71b2 100644
--- a/drivers/scsi/bfa/Makefile
+++ b/drivers/scsi/bfa/Makefile
@@ -2,14 +2,14 @@ obj-$(CONFIG_SCSI_BFA_FC) := bfa.o
 
 bfa-y := bfad.o bfad_intr.o bfad_os.o bfad_im.o bfad_attr.o bfad_fwimg.o
 
-bfa-y += bfa_core.o bfa_ioc.o bfa_iocfc.o bfa_fcxp.o bfa_lps.o
-bfa-y += bfa_hw_cb.o bfa_hw_ct.o bfa_intr.o bfa_timer.o bfa_rport.o 
+bfa-y += bfa_core.o bfa_ioc.o bfa_ioc_ct.o bfa_ioc_cb.o bfa_iocfc.o bfa_fcxp.o
+bfa-y += bfa_lps.o bfa_hw_cb.o bfa_hw_ct.o bfa_intr.o bfa_timer.o bfa_rport.o
 bfa-y += bfa_fcport.o bfa_port.o bfa_uf.o bfa_sgpg.o bfa_module.o bfa_ioim.o
 bfa-y += bfa_itnim.o bfa_fcpim.o bfa_tskim.o bfa_log.o bfa_log_module.o
 bfa-y += bfa_csdebug.o bfa_sm.o plog.o
 
-bfa-y += fcbuild.o fabric.o fcpim.o vfapi.o fcptm.o bfa_fcs.o bfa_fcs_port.o 
+bfa-y += fcbuild.o fabric.o fcpim.o vfapi.o fcptm.o bfa_fcs.o bfa_fcs_port.o
 bfa-y += bfa_fcs_uf.o bfa_fcs_lport.o fab.o fdmi.o ms.o ns.o scn.o loop.o
 bfa-y += lport_api.o n2n.o rport.o rport_api.o rport_ftrs.o vport.o
 
-ccflags-y := -I$(obj) -I$(obj)/include -I$(obj)/include/cna
+ccflags-y := -I$(obj) -I$(obj)/include -I$(obj)/include/cna -DBFA_PERF_BUILD
diff --git a/drivers/scsi/bfa/bfa_cb_ioim_macros.h b/drivers/scsi/bfa/bfa_cb_ioim_macros.h
index 0050c838c358..961fe439daad 100644
--- a/drivers/scsi/bfa/bfa_cb_ioim_macros.h
+++ b/drivers/scsi/bfa/bfa_cb_ioim_macros.h
@@ -51,7 +51,7 @@ bfad_int_to_lun(u32 luno)
         lun.bfa_lun     = 0;
         lun.scsi_lun[0] = bfa_os_htons(luno);
 
-        return (lun.bfa_lun);
+        return lun.bfa_lun;
 }
 
 /**
@@ -68,7 +68,7 @@ bfa_cb_ioim_get_cdb(struct bfad_ioim_s *dio)
 {
         struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
 
-        return ((u8 *) cmnd->cmnd);
+        return (u8 *) cmnd->cmnd;
 }
 
 /**
@@ -97,7 +97,7 @@ bfa_cb_ioim_get_size(struct bfad_ioim_s *dio)
 {
         struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
 
-        return (scsi_bufflen(cmnd));
+        return scsi_bufflen(cmnd);
 }
 
 /**
@@ -129,7 +129,7 @@ bfa_cb_ioim_get_sgaddr(struct bfad_ioim_s *dio, int sgeid)
         sge = (struct scatterlist *)scsi_sglist(cmnd) + sgeid;
         addr = (u64) sg_dma_address(sge);
 
-        return (*(union bfi_addr_u *) &addr);
+        return *((union bfi_addr_u *) &addr);
 }
 
 static inline u32
@@ -197,7 +197,7 @@ bfa_cb_ioim_get_cdblen(struct bfad_ioim_s *dio)
 {
         struct scsi_cmnd *cmnd = (struct scsi_cmnd *)dio;
 
-        return (cmnd->cmd_len);
+        return cmnd->cmd_len;
 }
 
 
diff --git a/drivers/scsi/bfa/bfa_cee.c b/drivers/scsi/bfa/bfa_cee.c
index 7a959c34e789..2b917792c6bc 100644
--- a/drivers/scsi/bfa/bfa_cee.c
+++ b/drivers/scsi/bfa/bfa_cee.c
@@ -228,7 +228,7 @@ bfa_cee_reset_stats_isr(struct bfa_cee_s *cee, bfa_status_t status)
 u32
 bfa_cee_meminfo(void)
 {
-        return (bfa_cee_attr_meminfo() + bfa_cee_stats_meminfo());
+        return bfa_cee_attr_meminfo() + bfa_cee_stats_meminfo();
 }
 
 /**
diff --git a/drivers/scsi/bfa/bfa_core.c b/drivers/scsi/bfa/bfa_core.c
index 44e2d1155c51..0c08e185a766 100644
--- a/drivers/scsi/bfa/bfa_core.c
+++ b/drivers/scsi/bfa/bfa_core.c
@@ -385,6 +385,15 @@ bfa_debug_fwsave(struct bfa_s *bfa, void *trcdata, int *trclen)
 }
 
 /**
+ * Clear the saved firmware trace information of an IOC.
+ */
+void
+bfa_debug_fwsave_clear(struct bfa_s *bfa)
+{
+        bfa_ioc_debug_fwsave_clear(&bfa->ioc);
+}
+
+/**
  *              Fetch firmware trace data.
  *
  * @param[in]           bfa                     BFA instance
@@ -399,4 +408,14 @@ bfa_debug_fwtrc(struct bfa_s *bfa, void *trcdata, int *trclen)
 {
         return bfa_ioc_debug_fwtrc(&bfa->ioc, trcdata, trclen);
 }
+
+/**
+ * Reset hw semaphore & usage cnt regs and initialize.
+ */
+void
+bfa_chip_reset(struct bfa_s *bfa)
+{
+        bfa_ioc_ownership_reset(&bfa->ioc);
+        bfa_ioc_pll_init(&bfa->ioc);
+}
 #endif
diff --git a/drivers/scsi/bfa/bfa_csdebug.c b/drivers/scsi/bfa/bfa_csdebug.c
index 1b71d349451a..caeb1143a4e6 100644
--- a/drivers/scsi/bfa/bfa_csdebug.c
+++ b/drivers/scsi/bfa/bfa_csdebug.c
@@ -47,12 +47,12 @@ bfa_q_is_on_q_func(struct list_head *q, struct list_head *qe)
         tqe = bfa_q_next(q);
         while (tqe != q) {
                 if (tqe == qe)
-                        return (1);
+                        return 1;
                 tqe = bfa_q_next(tqe);
                 if (tqe == NULL)
                         break;
         }
-        return (0);
+        return 0;
 }
 
 
diff --git a/drivers/scsi/bfa/bfa_fcpim.c b/drivers/scsi/bfa/bfa_fcpim.c
index 401babe3494e..790c945aeae6 100644
--- a/drivers/scsi/bfa/bfa_fcpim.c
+++ b/drivers/scsi/bfa/bfa_fcpim.c
@@ -131,7 +131,7 @@ bfa_fcpim_path_tov_get(struct bfa_s *bfa)
 {
         struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
 
-        return (fcpim->path_tov / 1000);
+        return fcpim->path_tov / 1000;
 }
 
 bfa_status_t
@@ -169,7 +169,7 @@ bfa_fcpim_qdepth_get(struct bfa_s *bfa)
 {
         struct bfa_fcpim_mod_s *fcpim = BFA_FCPIM_MOD(bfa);
 
-        return (fcpim->q_depth);
+        return fcpim->q_depth;
 }
 
 
diff --git a/drivers/scsi/bfa/bfa_fcpim_priv.h b/drivers/scsi/bfa/bfa_fcpim_priv.h
index 153206cfb37a..5cf418460f75 100644
--- a/drivers/scsi/bfa/bfa_fcpim_priv.h
+++ b/drivers/scsi/bfa/bfa_fcpim_priv.h
@@ -35,7 +35,7 @@
 #define BFA_FCPIM_PATHTOV_MAX   (90 * 1000)     /* in millisecs */
 
 #define bfa_fcpim_stats(__fcpim, __stats)   \
-    (__fcpim)->stats.__stats ++
+    ((__fcpim)->stats.__stats++)
 
 struct bfa_fcpim_mod_s {
         struct bfa_s    *bfa;
@@ -143,7 +143,7 @@ struct bfa_itnim_s {
         struct bfa_itnim_hal_stats_s    stats;
 };
 
-#define bfa_itnim_is_online(_itnim) (_itnim)->is_online
+#define bfa_itnim_is_online(_itnim) ((_itnim)->is_online)
 #define BFA_FCPIM_MOD(_hal) (&(_hal)->modules.fcpim_mod)
 #define BFA_IOIM_FROM_TAG(_fcpim, _iotag)       \
         (&fcpim->ioim_arr[_iotag])
diff --git a/drivers/scsi/bfa/bfa_fcport.c b/drivers/scsi/bfa/bfa_fcport.c
index 992435987deb..c589488db0c1 100644
--- a/drivers/scsi/bfa/bfa_fcport.c
+++ b/drivers/scsi/bfa/bfa_fcport.c
@@ -23,40 +23,33 @@
 #include <cs/bfa_plog.h>
 #include <aen/bfa_aen_port.h>
 
-BFA_TRC_FILE(HAL, PPORT);
-BFA_MODULE(pport);
-
-#define bfa_pport_callback(__pport, __event) do {                       \
-        if ((__pport)->bfa->fcs) {      \
-                (__pport)->event_cbfn((__pport)->event_cbarg, (__event));      \
-        } else {                                                        \
-                (__pport)->hcb_event = (__event);      \
-                bfa_cb_queue((__pport)->bfa, &(__pport)->hcb_qe,        \
-                __bfa_cb_port_event, (__pport));      \
-        }                                                               \
-} while (0)
+BFA_TRC_FILE(HAL, FCPORT);
+BFA_MODULE(fcport);
 
 /*
  * The port is considered disabled if corresponding physical port or IOC are
  * disabled explicitly
  */
 #define BFA_PORT_IS_DISABLED(bfa) \
-        ((bfa_pport_is_disabled(bfa) == BFA_TRUE) || \
+        ((bfa_fcport_is_disabled(bfa) == BFA_TRUE) || \
         (bfa_ioc_is_disabled(&bfa->ioc) == BFA_TRUE))
 
 /*
  * forward declarations
  */
-static bfa_boolean_t bfa_pport_send_enable(struct bfa_pport_s *port);
-static bfa_boolean_t bfa_pport_send_disable(struct bfa_pport_s *port);
-static void     bfa_pport_update_linkinfo(struct bfa_pport_s *pport);
-static void     bfa_pport_reset_linkinfo(struct bfa_pport_s *pport);
-static void     bfa_pport_set_wwns(struct bfa_pport_s *port);
-static void     __bfa_cb_port_event(void *cbarg, bfa_boolean_t complete);
-static void     __bfa_cb_port_stats(void *cbarg, bfa_boolean_t complete);
-static void     __bfa_cb_port_stats_clr(void *cbarg, bfa_boolean_t complete);
-static void     bfa_port_stats_timeout(void *cbarg);
-static void     bfa_port_stats_clr_timeout(void *cbarg);
+static bfa_boolean_t bfa_fcport_send_enable(struct bfa_fcport_s *fcport);
+static bfa_boolean_t bfa_fcport_send_disable(struct bfa_fcport_s *fcport);
+static void     bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport);
+static void     bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport);
+static void     bfa_fcport_set_wwns(struct bfa_fcport_s *fcport);
+static void     __bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete);
+static void     bfa_fcport_callback(struct bfa_fcport_s *fcport,
+                                enum bfa_pport_linkstate event);
+static void     bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln,
+                                enum bfa_pport_linkstate event);
+static void     __bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete);
+static void     bfa_fcport_stats_get_timeout(void *cbarg);
+static void     bfa_fcport_stats_clr_timeout(void *cbarg);
 
 /**
  *  bfa_pport_private
@@ -65,111 +58,114 @@ static void     bfa_port_stats_clr_timeout(void *cbarg);
 /**
  * BFA port state machine events
  */
-enum bfa_pport_sm_event {
-        BFA_PPORT_SM_START = 1, /*  start port state machine */
-        BFA_PPORT_SM_STOP = 2,  /*  stop port state machine */
-        BFA_PPORT_SM_ENABLE = 3,        /*  enable port */
-        BFA_PPORT_SM_DISABLE = 4,       /*  disable port state machine */
-        BFA_PPORT_SM_FWRSP = 5, /*  firmware enable/disable rsp */
-        BFA_PPORT_SM_LINKUP = 6,        /*  firmware linkup event */
-        BFA_PPORT_SM_LINKDOWN = 7,      /*  firmware linkup down */
-        BFA_PPORT_SM_QRESUME = 8,       /*  CQ space available */
-        BFA_PPORT_SM_HWFAIL = 9,        /*  IOC h/w failure */
+enum bfa_fcport_sm_event {
+        BFA_FCPORT_SM_START = 1,        /*  start port state machine */
+        BFA_FCPORT_SM_STOP = 2, /*  stop port state machine */
+        BFA_FCPORT_SM_ENABLE = 3,       /*  enable port */
+        BFA_FCPORT_SM_DISABLE = 4,      /*  disable port state machine */
+        BFA_FCPORT_SM_FWRSP = 5,        /*  firmware enable/disable rsp */
+        BFA_FCPORT_SM_LINKUP = 6,       /*  firmware linkup event */
+        BFA_FCPORT_SM_LINKDOWN = 7,     /*  firmware linkup down */
+        BFA_FCPORT_SM_QRESUME = 8,      /*  CQ space available */
+        BFA_FCPORT_SM_HWFAIL = 9,       /*  IOC h/w failure */
 };
 
-static void     bfa_pport_sm_uninit(struct bfa_pport_s *pport,
-                                    enum bfa_pport_sm_event event);
-static void     bfa_pport_sm_enabling_qwait(struct bfa_pport_s *pport,
-                                            enum bfa_pport_sm_event event);
-static void     bfa_pport_sm_enabling(struct bfa_pport_s *pport,
-                                      enum bfa_pport_sm_event event);
-static void     bfa_pport_sm_linkdown(struct bfa_pport_s *pport,
-                                      enum bfa_pport_sm_event event);
-static void     bfa_pport_sm_linkup(struct bfa_pport_s *pport,
-                                    enum bfa_pport_sm_event event);
-static void     bfa_pport_sm_disabling(struct bfa_pport_s *pport,
-                                       enum bfa_pport_sm_event event);
-static void     bfa_pport_sm_disabling_qwait(struct bfa_pport_s *pport,
-                                             enum bfa_pport_sm_event event);
-static void     bfa_pport_sm_disabled(struct bfa_pport_s *pport,
-                                      enum bfa_pport_sm_event event);
-static void     bfa_pport_sm_stopped(struct bfa_pport_s *pport,
-                                     enum bfa_pport_sm_event event);
-static void     bfa_pport_sm_iocdown(struct bfa_pport_s *pport,
-                                     enum bfa_pport_sm_event event);
-static void     bfa_pport_sm_iocfail(struct bfa_pport_s *pport,
-                                     enum bfa_pport_sm_event event);
+/**
+ * BFA port link notification state machine events
+ */
+
+enum bfa_fcport_ln_sm_event {
+        BFA_FCPORT_LN_SM_LINKUP         = 1,    /*  linkup event */
+        BFA_FCPORT_LN_SM_LINKDOWN       = 2,    /*  linkdown event */
+        BFA_FCPORT_LN_SM_NOTIFICATION   = 3     /*  done notification */
+};
+
+static void     bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
+                                        enum bfa_fcport_sm_event event);
+static void     bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
+                                                enum bfa_fcport_sm_event event);
+static void     bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
+                                                enum bfa_fcport_sm_event event);
+static void     bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
+                                                enum bfa_fcport_sm_event event);
+static void     bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
+                                                enum bfa_fcport_sm_event event);
+static void     bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
+                                                enum bfa_fcport_sm_event event);
+static void     bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
+                                                enum bfa_fcport_sm_event event);
+static void     bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
+                                                enum bfa_fcport_sm_event event);
+static void     bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
+                                         enum bfa_fcport_sm_event event);
+static void     bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
+                                         enum bfa_fcport_sm_event event);
+static void     bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
+                                         enum bfa_fcport_sm_event event);
+
+static void     bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
+                                         enum bfa_fcport_ln_sm_event event);
+static void     bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
+                                         enum bfa_fcport_ln_sm_event event);
+static void     bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
+                                         enum bfa_fcport_ln_sm_event event);
+static void     bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
+                                         enum bfa_fcport_ln_sm_event event);
+static void     bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
+                                         enum bfa_fcport_ln_sm_event event);
+static void     bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
+                                         enum bfa_fcport_ln_sm_event event);
+static void     bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
+                                         enum bfa_fcport_ln_sm_event event);
 
 static struct bfa_sm_table_s hal_pport_sm_table[] = {
-        {BFA_SM(bfa_pport_sm_uninit), BFA_PPORT_ST_UNINIT},
-        {BFA_SM(bfa_pport_sm_enabling_qwait), BFA_PPORT_ST_ENABLING_QWAIT},
-        {BFA_SM(bfa_pport_sm_enabling), BFA_PPORT_ST_ENABLING},
-        {BFA_SM(bfa_pport_sm_linkdown), BFA_PPORT_ST_LINKDOWN},
-        {BFA_SM(bfa_pport_sm_linkup), BFA_PPORT_ST_LINKUP},
-        {BFA_SM(bfa_pport_sm_disabling_qwait),
-         BFA_PPORT_ST_DISABLING_QWAIT},
-        {BFA_SM(bfa_pport_sm_disabling), BFA_PPORT_ST_DISABLING},
-        {BFA_SM(bfa_pport_sm_disabled), BFA_PPORT_ST_DISABLED},
-        {BFA_SM(bfa_pport_sm_stopped), BFA_PPORT_ST_STOPPED},
-        {BFA_SM(bfa_pport_sm_iocdown), BFA_PPORT_ST_IOCDOWN},
-        {BFA_SM(bfa_pport_sm_iocfail), BFA_PPORT_ST_IOCDOWN},
+        {BFA_SM(bfa_fcport_sm_uninit), BFA_PPORT_ST_UNINIT},
+        {BFA_SM(bfa_fcport_sm_enabling_qwait), BFA_PPORT_ST_ENABLING_QWAIT},
+        {BFA_SM(bfa_fcport_sm_enabling), BFA_PPORT_ST_ENABLING},
+        {BFA_SM(bfa_fcport_sm_linkdown), BFA_PPORT_ST_LINKDOWN},
+        {BFA_SM(bfa_fcport_sm_linkup), BFA_PPORT_ST_LINKUP},
+        {BFA_SM(bfa_fcport_sm_disabling_qwait), BFA_PPORT_ST_DISABLING_QWAIT},
+        {BFA_SM(bfa_fcport_sm_disabling), BFA_PPORT_ST_DISABLING},
+        {BFA_SM(bfa_fcport_sm_disabled), BFA_PPORT_ST_DISABLED},
+        {BFA_SM(bfa_fcport_sm_stopped), BFA_PPORT_ST_STOPPED},
+        {BFA_SM(bfa_fcport_sm_iocdown), BFA_PPORT_ST_IOCDOWN},
+        {BFA_SM(bfa_fcport_sm_iocfail), BFA_PPORT_ST_IOCDOWN},
 };
 
 static void
-bfa_pport_aen_post(struct bfa_pport_s *pport, enum bfa_port_aen_event event)
+bfa_fcport_aen_post(struct bfa_fcport_s *fcport, enum bfa_port_aen_event event)
 {
         union bfa_aen_data_u aen_data;
-        struct bfa_log_mod_s *logmod = pport->bfa->logm;
-        wwn_t           pwwn = pport->pwwn;
+        struct bfa_log_mod_s *logmod = fcport->bfa->logm;
+        wwn_t           pwwn = fcport->pwwn;
         char            pwwn_ptr[BFA_STRING_32];
-        struct bfa_ioc_attr_s ioc_attr;
 
+        memset(&aen_data, 0, sizeof(aen_data));
         wwn2str(pwwn_ptr, pwwn);
-        switch (event) {
-        case BFA_PORT_AEN_ONLINE:
-                bfa_log(logmod, BFA_AEN_PORT_ONLINE, pwwn_ptr);
-                break;
-        case BFA_PORT_AEN_OFFLINE:
-                bfa_log(logmod, BFA_AEN_PORT_OFFLINE, pwwn_ptr);
-                break;
-        case BFA_PORT_AEN_ENABLE:
-                bfa_log(logmod, BFA_AEN_PORT_ENABLE, pwwn_ptr);
-                break;
-        case BFA_PORT_AEN_DISABLE:
-                bfa_log(logmod, BFA_AEN_PORT_DISABLE, pwwn_ptr);
-                break;
-        case BFA_PORT_AEN_DISCONNECT:
-                bfa_log(logmod, BFA_AEN_PORT_DISCONNECT, pwwn_ptr);
-                break;
-        case BFA_PORT_AEN_QOS_NEG:
-                bfa_log(logmod, BFA_AEN_PORT_QOS_NEG, pwwn_ptr);
-                break;
-        default:
-                break;
-        }
+        bfa_log(logmod, BFA_LOG_CREATE_ID(BFA_AEN_CAT_PORT, event), pwwn_ptr);
 
-        bfa_ioc_get_attr(&pport->bfa->ioc, &ioc_attr);
-        aen_data.port.ioc_type = ioc_attr.ioc_type;
+        aen_data.port.ioc_type = bfa_get_type(fcport->bfa);
         aen_data.port.pwwn = pwwn;
 }
 
 static void
-bfa_pport_sm_uninit(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
+bfa_fcport_sm_uninit(struct bfa_fcport_s *fcport,
+                        enum bfa_fcport_sm_event event)
 {
-        bfa_trc(pport->bfa, event);
+        bfa_trc(fcport->bfa, event);
 
         switch (event) {
-        case BFA_PPORT_SM_START:
+        case BFA_FCPORT_SM_START:
                 /**
                  * Start event after IOC is configured and BFA is started.
                  */
-                if (bfa_pport_send_enable(pport))
-                        bfa_sm_set_state(pport, bfa_pport_sm_enabling);
+                if (bfa_fcport_send_enable(fcport))
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
                 else
-                        bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait);
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
                 break;
 
-        case BFA_PPORT_SM_ENABLE:
+        case BFA_FCPORT_SM_ENABLE:
                 /**
                  * Port is persistently configured to be in enabled state. Do
                  * not change state. Port enabling is done when START event is
@@ -177,392 +173,412 @@ bfa_pport_sm_uninit(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
                  */
                 break;
 
-        case BFA_PPORT_SM_DISABLE:
+        case BFA_FCPORT_SM_DISABLE:
                 /**
                  * If a port is persistently configured to be disabled, the
                  * first event will a port disable request.
                  */
-                bfa_sm_set_state(pport, bfa_pport_sm_disabled);
+                bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
                 break;
 
-        case BFA_PPORT_SM_HWFAIL:
-                bfa_sm_set_state(pport, bfa_pport_sm_iocdown);
+        case BFA_FCPORT_SM_HWFAIL:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
                 break;
 
         default:
-                bfa_sm_fault(pport->bfa, event);
+                bfa_sm_fault(fcport->bfa, event);
         }
 }
 
 static void
-bfa_pport_sm_enabling_qwait(struct bfa_pport_s *pport,
-                            enum bfa_pport_sm_event event)
+bfa_fcport_sm_enabling_qwait(struct bfa_fcport_s *fcport,
+                            enum bfa_fcport_sm_event event)
 {
-        bfa_trc(pport->bfa, event);
+        bfa_trc(fcport->bfa, event);
 
         switch (event) {
-        case BFA_PPORT_SM_QRESUME:
-                bfa_sm_set_state(pport, bfa_pport_sm_enabling);
-                bfa_pport_send_enable(pport);
+        case BFA_FCPORT_SM_QRESUME:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
+                bfa_fcport_send_enable(fcport);
                 break;
 
-        case BFA_PPORT_SM_STOP:
-                bfa_reqq_wcancel(&pport->reqq_wait);
-                bfa_sm_set_state(pport, bfa_pport_sm_stopped);
+        case BFA_FCPORT_SM_STOP:
+                bfa_reqq_wcancel(&fcport->reqq_wait);
+                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
                 break;
 
-        case BFA_PPORT_SM_ENABLE:
+        case BFA_FCPORT_SM_ENABLE:
                 /**
                  * Already enable is in progress.
                  */
                 break;
 
-        case BFA_PPORT_SM_DISABLE:
+        case BFA_FCPORT_SM_DISABLE:
                 /**
                  * Just send disable request to firmware when room becomes
                  * available in request queue.
                  */
-                bfa_sm_set_state(pport, bfa_pport_sm_disabled);
-                bfa_reqq_wcancel(&pport->reqq_wait);
-                bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
+                bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
+                bfa_reqq_wcancel(&fcport->reqq_wait);
+                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
                              BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
-                bfa_pport_aen_post(pport, BFA_PORT_AEN_DISABLE);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
                 break;
 
-        case BFA_PPORT_SM_LINKUP:
-        case BFA_PPORT_SM_LINKDOWN:
+        case BFA_FCPORT_SM_LINKUP:
+        case BFA_FCPORT_SM_LINKDOWN:
                 /**
                  * Possible to get link events when doing back-to-back
                  * enable/disables.
                  */
                 break;
 
-        case BFA_PPORT_SM_HWFAIL:
-                bfa_reqq_wcancel(&pport->reqq_wait);
-                bfa_sm_set_state(pport, bfa_pport_sm_iocdown);
+        case BFA_FCPORT_SM_HWFAIL:
+                bfa_reqq_wcancel(&fcport->reqq_wait);
+                bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
                 break;
 
         default:
-                bfa_sm_fault(pport->bfa, event);
+                bfa_sm_fault(fcport->bfa, event);
         }
 }
 
 static void
-bfa_pport_sm_enabling(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
+bfa_fcport_sm_enabling(struct bfa_fcport_s *fcport,
+                enum bfa_fcport_sm_event event)
 {
-        bfa_trc(pport->bfa, event);
+        bfa_trc(fcport->bfa, event);
 
         switch (event) {
-        case BFA_PPORT_SM_FWRSP:
-        case BFA_PPORT_SM_LINKDOWN:
-                bfa_sm_set_state(pport, bfa_pport_sm_linkdown);
+        case BFA_FCPORT_SM_FWRSP:
+        case BFA_FCPORT_SM_LINKDOWN:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
                 break;
 
-        case BFA_PPORT_SM_LINKUP:
-                bfa_pport_update_linkinfo(pport);
-                bfa_sm_set_state(pport, bfa_pport_sm_linkup);
+        case BFA_FCPORT_SM_LINKUP:
+                bfa_fcport_update_linkinfo(fcport);
+                bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
 
-                bfa_assert(pport->event_cbfn);
-                bfa_pport_callback(pport, BFA_PPORT_LINKUP);
+                bfa_assert(fcport->event_cbfn);
+                bfa_fcport_callback(fcport, BFA_PPORT_LINKUP);
                 break;
 
-        case BFA_PPORT_SM_ENABLE:
+        case BFA_FCPORT_SM_ENABLE:
                 /**
                  * Already being enabled.
                  */
                 break;
 
-        case BFA_PPORT_SM_DISABLE:
-                if (bfa_pport_send_disable(pport))
-                        bfa_sm_set_state(pport, bfa_pport_sm_disabling);
+        case BFA_FCPORT_SM_DISABLE:
+                if (bfa_fcport_send_disable(fcport))
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
                 else
-                        bfa_sm_set_state(pport, bfa_pport_sm_disabling_qwait);
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
 
-                bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
+                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
                              BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
-                bfa_pport_aen_post(pport, BFA_PORT_AEN_DISABLE);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
                 break;
 
-        case BFA_PPORT_SM_STOP:
-                bfa_sm_set_state(pport, bfa_pport_sm_stopped);
+        case BFA_FCPORT_SM_STOP:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
                 break;
 
-        case BFA_PPORT_SM_HWFAIL:
-                bfa_sm_set_state(pport, bfa_pport_sm_iocdown);
+        case BFA_FCPORT_SM_HWFAIL:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
                 break;
 
         default:
-                bfa_sm_fault(pport->bfa, event);
+                bfa_sm_fault(fcport->bfa, event);
         }
 }
 
 static void
-bfa_pport_sm_linkdown(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
+bfa_fcport_sm_linkdown(struct bfa_fcport_s *fcport,
+                        enum bfa_fcport_sm_event event)
 {
-        bfa_trc(pport->bfa, event);
+        struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
+        bfa_trc(fcport->bfa, event);
 
         switch (event) {
-        case BFA_PPORT_SM_LINKUP:
-                bfa_pport_update_linkinfo(pport);
-                bfa_sm_set_state(pport, bfa_pport_sm_linkup);
-                bfa_assert(pport->event_cbfn);
-                bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
+        case BFA_FCPORT_SM_LINKUP:
+                bfa_fcport_update_linkinfo(fcport);
+                bfa_sm_set_state(fcport, bfa_fcport_sm_linkup);
+                bfa_assert(fcport->event_cbfn);
+                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
                              BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkup");
-                bfa_pport_callback(pport, BFA_PPORT_LINKUP);
-                bfa_pport_aen_post(pport, BFA_PORT_AEN_ONLINE);
+
+                if (!bfa_ioc_get_fcmode(&fcport->bfa->ioc)) {
+
+                        bfa_trc(fcport->bfa, pevent->link_state.fcf.fipenabled);
+                        bfa_trc(fcport->bfa, pevent->link_state.fcf.fipfailed);
+
+                        if (pevent->link_state.fcf.fipfailed)
+                                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
+                                        BFA_PL_EID_FIP_FCF_DISC, 0,
+                                        "FIP FCF Discovery Failed");
+                        else
+                                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
+                                        BFA_PL_EID_FIP_FCF_DISC, 0,
+                                        "FIP FCF Discovered");
+                }
+
+                bfa_fcport_callback(fcport, BFA_PPORT_LINKUP);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ONLINE);
                 /**
                  * If QoS is enabled and it is not online,
                  * Send a separate event.
                  */
-                if ((pport->cfg.qos_enabled)
-                    && (bfa_os_ntohl(pport->qos_attr.state) != BFA_QOS_ONLINE))
-                        bfa_pport_aen_post(pport, BFA_PORT_AEN_QOS_NEG);
+                if ((fcport->cfg.qos_enabled)
+                    && (bfa_os_ntohl(fcport->qos_attr.state) != BFA_QOS_ONLINE))
+                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_QOS_NEG);
 
                 break;
 
-        case BFA_PPORT_SM_LINKDOWN:
+        case BFA_FCPORT_SM_LINKDOWN:
                 /**
                  * Possible to get link down event.
                  */
                 break;
 
-        case BFA_PPORT_SM_ENABLE:
+        case BFA_FCPORT_SM_ENABLE:
                 /**
                  * Already enabled.
                  */
                 break;
 
-        case BFA_PPORT_SM_DISABLE:
-                if (bfa_pport_send_disable(pport))
-                        bfa_sm_set_state(pport, bfa_pport_sm_disabling);
+        case BFA_FCPORT_SM_DISABLE:
+                if (bfa_fcport_send_disable(fcport))
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
                 else
-                        bfa_sm_set_state(pport, bfa_pport_sm_disabling_qwait);
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
 
-                bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
+                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
                              BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
-                bfa_pport_aen_post(pport, BFA_PORT_AEN_DISABLE);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
                 break;
 
-        case BFA_PPORT_SM_STOP:
-                bfa_sm_set_state(pport, bfa_pport_sm_stopped);
+        case BFA_FCPORT_SM_STOP:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
                 break;
 
-        case BFA_PPORT_SM_HWFAIL:
-                bfa_sm_set_state(pport, bfa_pport_sm_iocdown);
+        case BFA_FCPORT_SM_HWFAIL:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
                 break;
 
         default:
-                bfa_sm_fault(pport->bfa, event);
+                bfa_sm_fault(fcport->bfa, event);
         }
 }
 
 static void
-bfa_pport_sm_linkup(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
+bfa_fcport_sm_linkup(struct bfa_fcport_s *fcport,
+                        enum bfa_fcport_sm_event event)
 {
-        bfa_trc(pport->bfa, event);
+        bfa_trc(fcport->bfa, event);
 
         switch (event) {
-        case BFA_PPORT_SM_ENABLE:
+        case BFA_FCPORT_SM_ENABLE:
                 /**
                  * Already enabled.
                  */
                 break;
 
-        case BFA_PPORT_SM_DISABLE:
-                if (bfa_pport_send_disable(pport))
-                        bfa_sm_set_state(pport, bfa_pport_sm_disabling);
+        case BFA_FCPORT_SM_DISABLE:
+                if (bfa_fcport_send_disable(fcport))
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
                 else
-                        bfa_sm_set_state(pport, bfa_pport_sm_disabling_qwait);
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_disabling_qwait);
 
-                bfa_pport_reset_linkinfo(pport);
-                bfa_pport_callback(pport, BFA_PPORT_LINKDOWN);
-                bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
+                bfa_fcport_reset_linkinfo(fcport);
+                bfa_fcport_callback(fcport, BFA_PPORT_LINKDOWN);
+                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
                              BFA_PL_EID_PORT_DISABLE, 0, "Port Disable");
-                bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE);
-                bfa_pport_aen_post(pport, BFA_PORT_AEN_DISABLE);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISABLE);
                 break;
 
-        case BFA_PPORT_SM_LINKDOWN:
-                bfa_sm_set_state(pport, bfa_pport_sm_linkdown);
-                bfa_pport_reset_linkinfo(pport);
-                bfa_pport_callback(pport, BFA_PPORT_LINKDOWN);
-                bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
+        case BFA_FCPORT_SM_LINKDOWN:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_linkdown);
+                bfa_fcport_reset_linkinfo(fcport);
+                bfa_fcport_callback(fcport, BFA_PPORT_LINKDOWN);
+                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
                              BFA_PL_EID_PORT_ST_CHANGE, 0, "Port Linkdown");
-                if (BFA_PORT_IS_DISABLED(pport->bfa)) {
-                        bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE);
-                } else {
-                        bfa_pport_aen_post(pport, BFA_PORT_AEN_DISCONNECT);
-                }
+                if (BFA_PORT_IS_DISABLED(fcport->bfa))
+                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
+                else
+                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
                 break;
 
-        case BFA_PPORT_SM_STOP:
-                bfa_sm_set_state(pport, bfa_pport_sm_stopped);
-                bfa_pport_reset_linkinfo(pport);
-                if (BFA_PORT_IS_DISABLED(pport->bfa)) {
-                        bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE);
-                } else {
-                        bfa_pport_aen_post(pport, BFA_PORT_AEN_DISCONNECT);
-                }
+        case BFA_FCPORT_SM_STOP:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
+                bfa_fcport_reset_linkinfo(fcport);
+                if (BFA_PORT_IS_DISABLED(fcport->bfa))
+                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
+                else
+                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
                 break;
 
-        case BFA_PPORT_SM_HWFAIL:
-                bfa_sm_set_state(pport, bfa_pport_sm_iocdown);
-                bfa_pport_reset_linkinfo(pport);
-                bfa_pport_callback(pport, BFA_PPORT_LINKDOWN);
-                if (BFA_PORT_IS_DISABLED(pport->bfa)) {
-                        bfa_pport_aen_post(pport, BFA_PORT_AEN_OFFLINE);
-                } else {
-                        bfa_pport_aen_post(pport, BFA_PORT_AEN_DISCONNECT);
-                }
+        case BFA_FCPORT_SM_HWFAIL:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
+                bfa_fcport_reset_linkinfo(fcport);
+                bfa_fcport_callback(fcport, BFA_PPORT_LINKDOWN);
+                if (BFA_PORT_IS_DISABLED(fcport->bfa))
+                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_OFFLINE);
+                else
+                        bfa_fcport_aen_post(fcport, BFA_PORT_AEN_DISCONNECT);
                 break;
 
         default:
-                bfa_sm_fault(pport->bfa, event);
+                bfa_sm_fault(fcport->bfa, event);
         }
 }
 
 static void
-bfa_pport_sm_disabling_qwait(struct bfa_pport_s *pport,
-                             enum bfa_pport_sm_event event)
+bfa_fcport_sm_disabling_qwait(struct bfa_fcport_s *fcport,
+                             enum bfa_fcport_sm_event event)
 {
-        bfa_trc(pport->bfa, event);
+        bfa_trc(fcport->bfa, event);
 
         switch (event) {
-        case BFA_PPORT_SM_QRESUME:
-                bfa_sm_set_state(pport, bfa_pport_sm_disabling);
-                bfa_pport_send_disable(pport);
+        case BFA_FCPORT_SM_QRESUME:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_disabling);
+                bfa_fcport_send_disable(fcport);
                 break;
 
-        case BFA_PPORT_SM_STOP:
-                bfa_sm_set_state(pport, bfa_pport_sm_stopped);
-                bfa_reqq_wcancel(&pport->reqq_wait);
+        case BFA_FCPORT_SM_STOP:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
+                bfa_reqq_wcancel(&fcport->reqq_wait);
                 break;
 
-        case BFA_PPORT_SM_DISABLE:
+        case BFA_FCPORT_SM_DISABLE:
                 /**
                  * Already being disabled.
                  */
                 break;
 
-        case BFA_PPORT_SM_LINKUP:
-        case BFA_PPORT_SM_LINKDOWN:
+        case BFA_FCPORT_SM_LINKUP:
+        case BFA_FCPORT_SM_LINKDOWN:
                 /**
                  * Possible to get link events when doing back-to-back
                  * enable/disables.
                  */
                 break;
 
-        case BFA_PPORT_SM_HWFAIL:
-                bfa_sm_set_state(pport, bfa_pport_sm_iocfail);
-                bfa_reqq_wcancel(&pport->reqq_wait);
+        case BFA_FCPORT_SM_HWFAIL:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
+                bfa_reqq_wcancel(&fcport->reqq_wait);
                 break;
 
         default:
-                bfa_sm_fault(pport->bfa, event);
+                bfa_sm_fault(fcport->bfa, event);
         }
 }
 
 static void
-bfa_pport_sm_disabling(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
+bfa_fcport_sm_disabling(struct bfa_fcport_s *fcport,
+                        enum bfa_fcport_sm_event event)
 {
-        bfa_trc(pport->bfa, event);
+        bfa_trc(fcport->bfa, event);
 
         switch (event) {
-        case BFA_PPORT_SM_FWRSP:
-                bfa_sm_set_state(pport, bfa_pport_sm_disabled);
+        case BFA_FCPORT_SM_FWRSP:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
                 break;
 
-        case BFA_PPORT_SM_DISABLE:
+        case BFA_FCPORT_SM_DISABLE:
                 /**
                  * Already being disabled.
                  */
                 break;
 
-        case BFA_PPORT_SM_ENABLE:
-                if (bfa_pport_send_enable(pport))
-                        bfa_sm_set_state(pport, bfa_pport_sm_enabling);
+        case BFA_FCPORT_SM_ENABLE:
+                if (bfa_fcport_send_enable(fcport))
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
                 else
-                        bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait);
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
 
-                bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
+                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
                              BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
-                bfa_pport_aen_post(pport, BFA_PORT_AEN_ENABLE);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE);
                 break;
 
-        case BFA_PPORT_SM_STOP:
-                bfa_sm_set_state(pport, bfa_pport_sm_stopped);
+        case BFA_FCPORT_SM_STOP:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
                 break;
 
-        case BFA_PPORT_SM_LINKUP:
-        case BFA_PPORT_SM_LINKDOWN:
+        case BFA_FCPORT_SM_LINKUP:
+        case BFA_FCPORT_SM_LINKDOWN:
                 /**
                  * Possible to get link events when doing back-to-back
                  * enable/disables.
                  */
                 break;
 
-        case BFA_PPORT_SM_HWFAIL:
-                bfa_sm_set_state(pport, bfa_pport_sm_iocfail);
+        case BFA_FCPORT_SM_HWFAIL:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
                 break;
 
         default:
-                bfa_sm_fault(pport->bfa, event);
+                bfa_sm_fault(fcport->bfa, event);
         }
 }
 
 static void
-bfa_pport_sm_disabled(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
+bfa_fcport_sm_disabled(struct bfa_fcport_s *fcport,
+                        enum bfa_fcport_sm_event event)
 {
-        bfa_trc(pport->bfa, event);
+        bfa_trc(fcport->bfa, event);
 
         switch (event) {
-        case BFA_PPORT_SM_START:
+        case BFA_FCPORT_SM_START:
                 /**
                  * Ignore start event for a port that is disabled.
                  */
                 break;
 
-        case BFA_PPORT_SM_STOP:
-                bfa_sm_set_state(pport, bfa_pport_sm_stopped);
+        case BFA_FCPORT_SM_STOP:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_stopped);
                 break;
 
-        case BFA_PPORT_SM_ENABLE:
-                if (bfa_pport_send_enable(pport))
-                        bfa_sm_set_state(pport, bfa_pport_sm_enabling);
+        case BFA_FCPORT_SM_ENABLE:
+                if (bfa_fcport_send_enable(fcport))
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
                 else
-                        bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait);
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
 
-                bfa_plog_str(pport->bfa->plog, BFA_PL_MID_HAL,
+                bfa_plog_str(fcport->bfa->plog, BFA_PL_MID_HAL,
                              BFA_PL_EID_PORT_ENABLE, 0, "Port Enable");
-                bfa_pport_aen_post(pport, BFA_PORT_AEN_ENABLE);
+                bfa_fcport_aen_post(fcport, BFA_PORT_AEN_ENABLE);
                 break;
 
-        case BFA_PPORT_SM_DISABLE:
+        case BFA_FCPORT_SM_DISABLE:
                 /**
                  * Already disabled.
                  */
                 break;
 
-        case BFA_PPORT_SM_HWFAIL:
-                bfa_sm_set_state(pport, bfa_pport_sm_iocfail);
+        case BFA_FCPORT_SM_HWFAIL:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_iocfail);
                 break;
 
         default:
-                bfa_sm_fault(pport->bfa, event);
+                bfa_sm_fault(fcport->bfa, event);
         }
 }
 
 static void
-bfa_pport_sm_stopped(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
+bfa_fcport_sm_stopped(struct bfa_fcport_s *fcport,
+                        enum bfa_fcport_sm_event event)
 {
-        bfa_trc(pport->bfa, event);
+        bfa_trc(fcport->bfa, event);
 
         switch (event) {
-        case BFA_PPORT_SM_START:
-                if (bfa_pport_send_enable(pport))
-                        bfa_sm_set_state(pport, bfa_pport_sm_enabling);
+        case BFA_FCPORT_SM_START:
+                if (bfa_fcport_send_enable(fcport))
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
                 else
-                        bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait);
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
                 break;
 
         default:
@@ -577,16 +593,17 @@ bfa_pport_sm_stopped(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
  * Port is enabled. IOC is down/failed.
  */
 static void
-bfa_pport_sm_iocdown(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
+bfa_fcport_sm_iocdown(struct bfa_fcport_s *fcport,
+                        enum bfa_fcport_sm_event event)
 {
-        bfa_trc(pport->bfa, event);
+        bfa_trc(fcport->bfa, event);
 
         switch (event) {
-        case BFA_PPORT_SM_START:
-                if (bfa_pport_send_enable(pport))
-                        bfa_sm_set_state(pport, bfa_pport_sm_enabling);
+        case BFA_FCPORT_SM_START:
+                if (bfa_fcport_send_enable(fcport))
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling);
                 else
-                        bfa_sm_set_state(pport, bfa_pport_sm_enabling_qwait);
+                        bfa_sm_set_state(fcport, bfa_fcport_sm_enabling_qwait);
                 break;
 
         default:
@@ -601,17 +618,18 @@ bfa_pport_sm_iocdown(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
  * Port is disabled. IOC is down/failed.
  */
 static void
-bfa_pport_sm_iocfail(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
+bfa_fcport_sm_iocfail(struct bfa_fcport_s *fcport,
+                        enum bfa_fcport_sm_event event)
 {
-        bfa_trc(pport->bfa, event);
+        bfa_trc(fcport->bfa, event);
 
         switch (event) {
-        case BFA_PPORT_SM_START:
-                bfa_sm_set_state(pport, bfa_pport_sm_disabled);
+        case BFA_FCPORT_SM_START:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_disabled);
                 break;
 
-        case BFA_PPORT_SM_ENABLE:
-                bfa_sm_set_state(pport, bfa_pport_sm_iocdown);
+        case BFA_FCPORT_SM_ENABLE:
+                bfa_sm_set_state(fcport, bfa_fcport_sm_iocdown);
                 break;
 
         default:
@@ -622,41 +640,226 @@ bfa_pport_sm_iocfail(struct bfa_pport_s *pport, enum bfa_pport_sm_event event)
         }
 }
 
+/**
+ * Link state is down
+ */
+static void
+bfa_fcport_ln_sm_dn(struct bfa_fcport_ln_s *ln,
+                enum bfa_fcport_ln_sm_event event)
+{
+        bfa_trc(ln->fcport->bfa, event);
+
+        switch (event) {
+        case BFA_FCPORT_LN_SM_LINKUP:
+                bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
+                bfa_fcport_queue_cb(ln, BFA_PPORT_LINKUP);
+                break;
 
+        default:
+                bfa_sm_fault(ln->fcport->bfa, event);
+        }
+}
+
+/**
+ * Link state is waiting for down notification
+ */
+static void
+bfa_fcport_ln_sm_dn_nf(struct bfa_fcport_ln_s *ln,
+                enum bfa_fcport_ln_sm_event event)
+{
+        bfa_trc(ln->fcport->bfa, event);
+
+        switch (event) {
+        case BFA_FCPORT_LN_SM_LINKUP:
+                bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
+                break;
+
+        case BFA_FCPORT_LN_SM_NOTIFICATION:
+                bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
+                break;
+
+        default:
+                bfa_sm_fault(ln->fcport->bfa, event);
+        }
+}
+
+/**
+ * Link state is waiting for down notification and there is a pending up
+ */
+static void
+bfa_fcport_ln_sm_dn_up_nf(struct bfa_fcport_ln_s *ln,
+                enum bfa_fcport_ln_sm_event event)
+{
+        bfa_trc(ln->fcport->bfa, event);
+
+        switch (event) {
+        case BFA_FCPORT_LN_SM_LINKDOWN:
+                bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
+                break;
+
+        case BFA_FCPORT_LN_SM_NOTIFICATION:
+                bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_nf);
+                bfa_fcport_queue_cb(ln, BFA_PPORT_LINKUP);
+                break;
+
+        default:
+                bfa_sm_fault(ln->fcport->bfa, event);
+        }
+}
+
+/**
+ * Link state is up
+ */
+static void
+bfa_fcport_ln_sm_up(struct bfa_fcport_ln_s *ln,
+                enum bfa_fcport_ln_sm_event event)
+{
+        bfa_trc(ln->fcport->bfa, event);
+
+        switch (event) {
+        case BFA_FCPORT_LN_SM_LINKDOWN:
+                bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
+                bfa_fcport_queue_cb(ln, BFA_PPORT_LINKDOWN);
+                break;
+
+        default:
+                bfa_sm_fault(ln->fcport->bfa, event);
+        }
+}
+
+/**
+ * Link state is waiting for up notification
+ */
+static void
+bfa_fcport_ln_sm_up_nf(struct bfa_fcport_ln_s *ln,
+                enum bfa_fcport_ln_sm_event event)
+{
+        bfa_trc(ln->fcport->bfa, event);
+
+        switch (event) {
+        case BFA_FCPORT_LN_SM_LINKDOWN:
+                bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
+                break;
+
+        case BFA_FCPORT_LN_SM_NOTIFICATION:
+                bfa_sm_set_state(ln, bfa_fcport_ln_sm_up);
+                break;
+
+        default:
+                bfa_sm_fault(ln->fcport->bfa, event);
+        }
+}
+
+/**
+ * Link state is waiting for up notification and there is a pending down
+ */
+static void
+bfa_fcport_ln_sm_up_dn_nf(struct bfa_fcport_ln_s *ln,
+                enum bfa_fcport_ln_sm_event event)
+{
+        bfa_trc(ln->fcport->bfa, event);
+
+        switch (event) {
+        case BFA_FCPORT_LN_SM_LINKUP:
+                bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_up_nf);
+                break;
+
+        case BFA_FCPORT_LN_SM_NOTIFICATION:
+                bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_nf);
+                bfa_fcport_queue_cb(ln, BFA_PPORT_LINKDOWN);
+                break;
+
+        default:
+                bfa_sm_fault(ln->fcport->bfa, event);
+        }
+}
+
+/**
+ * Link state is waiting for up notification and there are pending down and up
+ */
+static void
+bfa_fcport_ln_sm_up_dn_up_nf(struct bfa_fcport_ln_s *ln,
+                        enum bfa_fcport_ln_sm_event event)
+{
+        bfa_trc(ln->fcport->bfa, event);
+
+        switch (event) {
+        case BFA_FCPORT_LN_SM_LINKDOWN:
+                bfa_sm_set_state(ln, bfa_fcport_ln_sm_up_dn_nf);
+                break;
+
+        case BFA_FCPORT_LN_SM_NOTIFICATION:
+                bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn_up_nf);
+                bfa_fcport_queue_cb(ln, BFA_PPORT_LINKDOWN);
+                break;
+
+        default:
+                bfa_sm_fault(ln->fcport->bfa, event);
+        }
+}
 
 /**
  *  bfa_pport_private
  */
 
 static void
-__bfa_cb_port_event(void *cbarg, bfa_boolean_t complete)
+__bfa_cb_fcport_event(void *cbarg, bfa_boolean_t complete)
 {
-        struct bfa_pport_s *pport = cbarg;
+        struct bfa_fcport_ln_s *ln = cbarg;
 
         if (complete)
-                pport->event_cbfn(pport->event_cbarg, pport->hcb_event);
+                ln->fcport->event_cbfn(ln->fcport->event_cbarg, ln->ln_event);
+        else
+                bfa_sm_send_event(ln, BFA_FCPORT_LN_SM_NOTIFICATION);
+}
+
+static void
+bfa_fcport_callback(struct bfa_fcport_s *fcport, enum bfa_pport_linkstate event)
+{
+        if (fcport->bfa->fcs) {
+                fcport->event_cbfn(fcport->event_cbarg, event);
+                return;
+        }
+
+        switch (event) {
+        case BFA_PPORT_LINKUP:
+                bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKUP);
+                break;
+        case BFA_PPORT_LINKDOWN:
+                bfa_sm_send_event(&fcport->ln, BFA_FCPORT_LN_SM_LINKDOWN);
+                break;
+        default:
+                bfa_assert(0);
+        }
+}
+
+static void
+bfa_fcport_queue_cb(struct bfa_fcport_ln_s *ln, enum bfa_pport_linkstate event)
+{
+        ln->ln_event = event;
+        bfa_cb_queue(ln->fcport->bfa, &ln->ln_qe, __bfa_cb_fcport_event, ln);
 }
 
-#define PPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_pport_stats_u), \
+#define FCPORT_STATS_DMA_SZ (BFA_ROUNDUP(sizeof(union bfa_fcport_stats_u), \
                                                         BFA_CACHELINE_SZ))
 
 static void
-bfa_pport_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
+bfa_fcport_meminfo(struct bfa_iocfc_cfg_s *cfg, u32 *ndm_len,
                   u32 *dm_len)
 {
-        *dm_len += PPORT_STATS_DMA_SZ;
+        *dm_len += FCPORT_STATS_DMA_SZ;
 }
 
 static void
-bfa_pport_qresume(void *cbarg)
+bfa_fcport_qresume(void *cbarg)
 {
-        struct bfa_pport_s *port = cbarg;
+        struct bfa_fcport_s *fcport = cbarg;
 
-        bfa_sm_send_event(port, BFA_PPORT_SM_QRESUME);
+        bfa_sm_send_event(fcport, BFA_FCPORT_SM_QRESUME);
 }
 
 static void
-bfa_pport_mem_claim(struct bfa_pport_s *pport, struct bfa_meminfo_s *meminfo)
+bfa_fcport_mem_claim(struct bfa_fcport_s *fcport, struct bfa_meminfo_s *meminfo)
 {
         u8        *dm_kva;
         u64        dm_pa;
@@ -664,12 +867,12 @@ bfa_pport_mem_claim(struct bfa_pport_s *pport, struct bfa_meminfo_s *meminfo)
         dm_kva = bfa_meminfo_dma_virt(meminfo);
         dm_pa = bfa_meminfo_dma_phys(meminfo);
 
-        pport->stats_kva = dm_kva;
-        pport->stats_pa = dm_pa;
-        pport->stats = (union bfa_pport_stats_u *)dm_kva;
+        fcport->stats_kva = dm_kva;
+        fcport->stats_pa = dm_pa;
+        fcport->stats = (union bfa_fcport_stats_u *)dm_kva;
 
-        dm_kva += PPORT_STATS_DMA_SZ;
-        dm_pa += PPORT_STATS_DMA_SZ;
+        dm_kva += FCPORT_STATS_DMA_SZ;
+        dm_pa += FCPORT_STATS_DMA_SZ;
 
         bfa_meminfo_dma_virt(meminfo) = dm_kva;
         bfa_meminfo_dma_phys(meminfo) = dm_pa;
@@ -679,18 +882,21 @@ bfa_pport_mem_claim(struct bfa_pport_s *pport, struct bfa_meminfo_s *meminfo)
  * Memory initialization.
  */
 static void
-bfa_pport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
+bfa_fcport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
                  struct bfa_meminfo_s *meminfo, struct bfa_pcidev_s *pcidev)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
-        struct bfa_pport_cfg_s *port_cfg = &pport->cfg;
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
+        struct bfa_pport_cfg_s *port_cfg = &fcport->cfg;
+        struct bfa_fcport_ln_s *ln = &fcport->ln;
 
-        bfa_os_memset(pport, 0, sizeof(struct bfa_pport_s));
-        pport->bfa = bfa;
+        bfa_os_memset(fcport, 0, sizeof(struct bfa_fcport_s));
+        fcport->bfa = bfa;
+        ln->fcport = fcport;
 
-        bfa_pport_mem_claim(pport, meminfo);
+        bfa_fcport_mem_claim(fcport, meminfo);
 
-        bfa_sm_set_state(pport, bfa_pport_sm_uninit);
+        bfa_sm_set_state(fcport, bfa_fcport_sm_uninit);
+        bfa_sm_set_state(ln, bfa_fcport_ln_sm_dn);
 
         /**
          * initialize and set default configuration
@@ -702,30 +908,30 @@ bfa_pport_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
 
         port_cfg->trl_def_speed = BFA_PPORT_SPEED_1GBPS;
 
-        bfa_reqq_winit(&pport->reqq_wait, bfa_pport_qresume, pport);
+        bfa_reqq_winit(&fcport->reqq_wait, bfa_fcport_qresume, fcport);
 }
 
 static void
-bfa_pport_initdone(struct bfa_s *bfa)
+bfa_fcport_initdone(struct bfa_s *bfa)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
         /**
          * Initialize port attributes from IOC hardware data.
          */
-        bfa_pport_set_wwns(pport);
-        if (pport->cfg.maxfrsize == 0)
-                pport->cfg.maxfrsize = bfa_ioc_maxfrsize(&bfa->ioc);
-        pport->cfg.rx_bbcredit = bfa_ioc_rx_bbcredit(&bfa->ioc);
-        pport->speed_sup = bfa_ioc_speed_sup(&bfa->ioc);
+        bfa_fcport_set_wwns(fcport);
+        if (fcport->cfg.maxfrsize == 0)
+                fcport->cfg.maxfrsize = bfa_ioc_maxfrsize(&bfa->ioc);
+        fcport->cfg.rx_bbcredit = bfa_ioc_rx_bbcredit(&bfa->ioc);
+        fcport->speed_sup = bfa_ioc_speed_sup(&bfa->ioc);
 
-        bfa_assert(pport->cfg.maxfrsize);
-        bfa_assert(pport->cfg.rx_bbcredit);
-        bfa_assert(pport->speed_sup);
+        bfa_assert(fcport->cfg.maxfrsize);
+        bfa_assert(fcport->cfg.rx_bbcredit);
+        bfa_assert(fcport->speed_sup);
 }
 
 static void
-bfa_pport_detach(struct bfa_s *bfa)
+bfa_fcport_detach(struct bfa_s *bfa)
 {
 }
 
@@ -733,95 +939,97 @@ bfa_pport_detach(struct bfa_s *bfa)
  * Called when IOC is ready.
  */
 static void
-bfa_pport_start(struct bfa_s *bfa)
+bfa_fcport_start(struct bfa_s *bfa)
 {
-        bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_START);
+        bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_START);
 }
 
 /**
  * Called before IOC is stopped.
  */
 static void
-bfa_pport_stop(struct bfa_s *bfa)
+bfa_fcport_stop(struct bfa_s *bfa)
 {
-        bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_STOP);
+        bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_STOP);
 }
 
 /**
  * Called when IOC failure is detected.
  */
 static void
-bfa_pport_iocdisable(struct bfa_s *bfa)
+bfa_fcport_iocdisable(struct bfa_s *bfa)
 {
-        bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_HWFAIL);
+        bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_HWFAIL);
 }
 
 static void
-bfa_pport_update_linkinfo(struct bfa_pport_s *pport)
+bfa_fcport_update_linkinfo(struct bfa_fcport_s *fcport)
 {
-        struct bfi_pport_event_s *pevent = pport->event_arg.i2hmsg.event;
+        struct bfi_fcport_event_s *pevent = fcport->event_arg.i2hmsg.event;
 
-        pport->speed = pevent->link_state.speed;
-        pport->topology = pevent->link_state.topology;
+        fcport->speed = pevent->link_state.speed;
+        fcport->topology = pevent->link_state.topology;
 
-        if (pport->topology == BFA_PPORT_TOPOLOGY_LOOP)
-                pport->myalpa = pevent->link_state.tl.loop_info.myalpa;
+        if (fcport->topology == BFA_PPORT_TOPOLOGY_LOOP)
+                fcport->myalpa =
+                        pevent->link_state.tl.loop_info.myalpa;
 
         /*
          * QoS Details
          */
-        bfa_os_assign(pport->qos_attr, pevent->link_state.qos_attr);
-        bfa_os_assign(pport->qos_vc_attr, pevent->link_state.qos_vc_attr);
+        bfa_os_assign(fcport->qos_attr, pevent->link_state.qos_attr);
+        bfa_os_assign(fcport->qos_vc_attr, pevent->link_state.qos_vc_attr);
 
-        bfa_trc(pport->bfa, pport->speed);
-        bfa_trc(pport->bfa, pport->topology);
+        bfa_trc(fcport->bfa, fcport->speed);
+        bfa_trc(fcport->bfa, fcport->topology);
 }
 
 static void
-bfa_pport_reset_linkinfo(struct bfa_pport_s *pport)
+bfa_fcport_reset_linkinfo(struct bfa_fcport_s *fcport)
 {
-        pport->speed = BFA_PPORT_SPEED_UNKNOWN;
-        pport->topology = BFA_PPORT_TOPOLOGY_NONE;
+        fcport->speed = BFA_PPORT_SPEED_UNKNOWN;
+        fcport->topology = BFA_PPORT_TOPOLOGY_NONE;
 }
 
 /**
  * Send port enable message to firmware.
  */
 static          bfa_boolean_t
-bfa_pport_send_enable(struct bfa_pport_s *port)
+bfa_fcport_send_enable(struct bfa_fcport_s *fcport)
 {
-        struct bfi_pport_enable_req_s *m;
+        struct bfi_fcport_enable_req_s *m;
 
         /**
          * Increment message tag before queue check, so that responses to old
          * requests are discarded.
          */
-        port->msgtag++;
+        fcport->msgtag++;
 
         /**
          * check for room in queue to send request now
          */
-        m = bfa_reqq_next(port->bfa, BFA_REQQ_PORT);
+        m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
         if (!m) {
-                bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->reqq_wait);
+                bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
+                                                        &fcport->reqq_wait);
                 return BFA_FALSE;
         }
 
-        bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_ENABLE_REQ,
-                    bfa_lpuid(port->bfa));
-        m->nwwn = port->nwwn;
-        m->pwwn = port->pwwn;
-        m->port_cfg = port->cfg;
-        m->msgtag = port->msgtag;
-        m->port_cfg.maxfrsize = bfa_os_htons(port->cfg.maxfrsize);
-        bfa_dma_be_addr_set(m->stats_dma_addr, port->stats_pa);
-        bfa_trc(port->bfa, m->stats_dma_addr.a32.addr_lo);
-        bfa_trc(port->bfa, m->stats_dma_addr.a32.addr_hi);
+        bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_ENABLE_REQ,
+                                bfa_lpuid(fcport->bfa));
+        m->nwwn = fcport->nwwn;
+        m->pwwn = fcport->pwwn;
+        m->port_cfg = fcport->cfg;
+        m->msgtag = fcport->msgtag;
+        m->port_cfg.maxfrsize = bfa_os_htons(fcport->cfg.maxfrsize);
+        bfa_dma_be_addr_set(m->stats_dma_addr, fcport->stats_pa);
+        bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_lo);
+        bfa_trc(fcport->bfa, m->stats_dma_addr.a32.addr_hi);
 
         /**
          * queue I/O message to firmware
          */
-        bfa_reqq_produce(port->bfa, BFA_REQQ_PORT);
+        bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
         return BFA_TRUE;
 }
 
@@ -829,74 +1037,226 @@ bfa_pport_send_enable(struct bfa_pport_s *port)
  * Send port disable message to firmware.
  */
 static          bfa_boolean_t
-bfa_pport_send_disable(struct bfa_pport_s *port)
+bfa_fcport_send_disable(struct bfa_fcport_s *fcport)
 {
-        bfi_pport_disable_req_t *m;
+        struct bfi_fcport_req_s *m;
 
         /**
          * Increment message tag before queue check, so that responses to old
          * requests are discarded.
          */
-        port->msgtag++;
+        fcport->msgtag++;
 
         /**
          * check for room in queue to send request now
          */
-        m = bfa_reqq_next(port->bfa, BFA_REQQ_PORT);
+        m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
         if (!m) {
-                bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->reqq_wait);
+                bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
+                                                        &fcport->reqq_wait);
                 return BFA_FALSE;
         }
 
-        bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_DISABLE_REQ,
-                    bfa_lpuid(port->bfa));
-        m->msgtag = port->msgtag;
+        bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_DISABLE_REQ,
+                        bfa_lpuid(fcport->bfa));
+        m->msgtag = fcport->msgtag;
 
         /**
          * queue I/O message to firmware
          */
-        bfa_reqq_produce(port->bfa, BFA_REQQ_PORT);
+        bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
 
         return BFA_TRUE;
 }
 
 static void
-bfa_pport_set_wwns(struct bfa_pport_s *port)
+bfa_fcport_set_wwns(struct bfa_fcport_s *fcport)
 {
-        port->pwwn = bfa_ioc_get_pwwn(&port->bfa->ioc);
-        port->nwwn = bfa_ioc_get_nwwn(&port->bfa->ioc);
+        fcport->pwwn = bfa_ioc_get_pwwn(&fcport->bfa->ioc);
+        fcport->nwwn = bfa_ioc_get_nwwn(&fcport->bfa->ioc);
 
-        bfa_trc(port->bfa, port->pwwn);
-        bfa_trc(port->bfa, port->nwwn);
+        bfa_trc(fcport->bfa, fcport->pwwn);
+        bfa_trc(fcport->bfa, fcport->nwwn);
 }
 
 static void
-bfa_port_send_txcredit(void *port_cbarg)
+bfa_fcport_send_txcredit(void *port_cbarg)
 {
 
-        struct bfa_pport_s *port = port_cbarg;
-        struct bfi_pport_set_svc_params_req_s *m;
+        struct bfa_fcport_s *fcport = port_cbarg;
+        struct bfi_fcport_set_svc_params_req_s *m;
 
         /**
          * check for room in queue to send request now
          */
-        m = bfa_reqq_next(port->bfa, BFA_REQQ_PORT);
+        m = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
         if (!m) {
-                bfa_trc(port->bfa, port->cfg.tx_bbcredit);
+                bfa_trc(fcport->bfa, fcport->cfg.tx_bbcredit);
                 return;
         }
 
-        bfi_h2i_set(m->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_SET_SVC_PARAMS_REQ,
-                    bfa_lpuid(port->bfa));
-        m->tx_bbcredit = bfa_os_htons((u16) port->cfg.tx_bbcredit);
+        bfi_h2i_set(m->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_SET_SVC_PARAMS_REQ,
+                        bfa_lpuid(fcport->bfa));
+        m->tx_bbcredit = bfa_os_htons((u16) fcport->cfg.tx_bbcredit);
 
         /**
          * queue I/O message to firmware
          */
-        bfa_reqq_produce(port->bfa, BFA_REQQ_PORT);
+        bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
+}
+
+static void
+bfa_fcport_qos_stats_swap(struct bfa_qos_stats_s *d,
+        struct bfa_qos_stats_s *s)
+{
+        u32     *dip = (u32 *) d;
+        u32     *sip = (u32 *) s;
+        int             i;
+
+        /* Now swap the 32 bit fields */
+        for (i = 0; i < (sizeof(struct bfa_qos_stats_s)/sizeof(u32)); ++i)
+                dip[i] = bfa_os_ntohl(sip[i]);
+}
+
+static void
+bfa_fcport_fcoe_stats_swap(struct bfa_fcoe_stats_s *d,
+        struct bfa_fcoe_stats_s *s)
+{
+        u32     *dip = (u32 *) d;
+        u32     *sip = (u32 *) s;
+        int             i;
+
+        for (i = 0; i < ((sizeof(struct bfa_fcoe_stats_s))/sizeof(u32));
+                i = i + 2) {
+#ifdef __BIGENDIAN
+                dip[i] = bfa_os_ntohl(sip[i]);
+                dip[i + 1] = bfa_os_ntohl(sip[i + 1]);
+#else
+                dip[i] = bfa_os_ntohl(sip[i + 1]);
+                dip[i + 1] = bfa_os_ntohl(sip[i]);
+#endif
+        }
+}
+
+static void
+__bfa_cb_fcport_stats_get(void *cbarg, bfa_boolean_t complete)
+{
+        struct bfa_fcport_s *fcport = cbarg;
+
+        if (complete) {
+                if (fcport->stats_status == BFA_STATUS_OK) {
+
+                        /* Swap FC QoS or FCoE stats */
+                        if (bfa_ioc_get_fcmode(&fcport->bfa->ioc))
+                                bfa_fcport_qos_stats_swap(
+                                        &fcport->stats_ret->fcqos,
+                                        &fcport->stats->fcqos);
+                        else
+                                bfa_fcport_fcoe_stats_swap(
+                                        &fcport->stats_ret->fcoe,
+                                        &fcport->stats->fcoe);
+                }
+                fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
+        } else {
+                fcport->stats_busy = BFA_FALSE;
+                fcport->stats_status = BFA_STATUS_OK;
+        }
 }
 
+static void
+bfa_fcport_stats_get_timeout(void *cbarg)
+{
+        struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
+
+        bfa_trc(fcport->bfa, fcport->stats_qfull);
+
+        if (fcport->stats_qfull) {
+                bfa_reqq_wcancel(&fcport->stats_reqq_wait);
+                fcport->stats_qfull = BFA_FALSE;
+        }
+
+        fcport->stats_status = BFA_STATUS_ETIMER;
+        bfa_cb_queue(fcport->bfa, &fcport->hcb_qe, __bfa_cb_fcport_stats_get,
+                fcport);
+}
+
+static void
+bfa_fcport_send_stats_get(void *cbarg)
+{
+        struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
+        struct bfi_fcport_req_s *msg;
+
+        msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
+
+        if (!msg) {
+                fcport->stats_qfull = BFA_TRUE;
+                bfa_reqq_winit(&fcport->stats_reqq_wait,
+                                bfa_fcport_send_stats_get, fcport);
+                bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
+                                &fcport->stats_reqq_wait);
+                return;
+        }
+        fcport->stats_qfull = BFA_FALSE;
+
+        bfa_os_memset(msg, 0, sizeof(struct bfi_fcport_req_s));
+        bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_GET_REQ,
+                bfa_lpuid(fcport->bfa));
+        bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
+}
+
+static void
+__bfa_cb_fcport_stats_clr(void *cbarg, bfa_boolean_t complete)
+{
+        struct bfa_fcport_s *fcport = cbarg;
+
+        if (complete) {
+                fcport->stats_cbfn(fcport->stats_cbarg, fcport->stats_status);
+        } else {
+                fcport->stats_busy = BFA_FALSE;
+                fcport->stats_status = BFA_STATUS_OK;
+        }
+}
+
+static void
+bfa_fcport_stats_clr_timeout(void *cbarg)
+{
+        struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
+
+        bfa_trc(fcport->bfa, fcport->stats_qfull);
+
+        if (fcport->stats_qfull) {
+                bfa_reqq_wcancel(&fcport->stats_reqq_wait);
+                fcport->stats_qfull = BFA_FALSE;
+        }
+
+        fcport->stats_status = BFA_STATUS_ETIMER;
+        bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
+                        __bfa_cb_fcport_stats_clr, fcport);
+}
+
+static void
+bfa_fcport_send_stats_clear(void *cbarg)
+{
+        struct bfa_fcport_s *fcport = (struct bfa_fcport_s *) cbarg;
+        struct bfi_fcport_req_s *msg;
 
+        msg = bfa_reqq_next(fcport->bfa, BFA_REQQ_PORT);
+
+        if (!msg) {
+                fcport->stats_qfull = BFA_TRUE;
+                bfa_reqq_winit(&fcport->stats_reqq_wait,
+                                bfa_fcport_send_stats_clear, fcport);
+                bfa_reqq_wait(fcport->bfa, BFA_REQQ_PORT,
+                                &fcport->stats_reqq_wait);
+                return;
+        }
+        fcport->stats_qfull = BFA_FALSE;
+
+        bfa_os_memset(msg, 0, sizeof(struct bfi_fcport_req_s));
+        bfi_h2i_set(msg->mh, BFI_MC_FCPORT, BFI_FCPORT_H2I_STATS_CLEAR_REQ,
+                        bfa_lpuid(fcport->bfa));
+        bfa_reqq_produce(fcport->bfa, BFA_REQQ_PORT);
+}
 
 /**
  *  bfa_pport_public
@@ -906,32 +1266,32 @@ bfa_port_send_txcredit(void *port_cbarg)
  * Firmware message handler.
  */
 void
-bfa_pport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
+bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
-        union bfi_pport_i2h_msg_u i2hmsg;
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
+        union bfi_fcport_i2h_msg_u i2hmsg;
 
         i2hmsg.msg = msg;
-        pport->event_arg.i2hmsg = i2hmsg;
+        fcport->event_arg.i2hmsg = i2hmsg;
 
         switch (msg->mhdr.msg_id) {
-        case BFI_PPORT_I2H_ENABLE_RSP:
-                if (pport->msgtag == i2hmsg.enable_rsp->msgtag)
-                        bfa_sm_send_event(pport, BFA_PPORT_SM_FWRSP);
+        case BFI_FCPORT_I2H_ENABLE_RSP:
+                if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
+                        bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
                 break;
 
-        case BFI_PPORT_I2H_DISABLE_RSP:
-                if (pport->msgtag == i2hmsg.enable_rsp->msgtag)
-                        bfa_sm_send_event(pport, BFA_PPORT_SM_FWRSP);
+        case BFI_FCPORT_I2H_DISABLE_RSP:
+                if (fcport->msgtag == i2hmsg.penable_rsp->msgtag)
+                        bfa_sm_send_event(fcport, BFA_FCPORT_SM_FWRSP);
                 break;
 
-        case BFI_PPORT_I2H_EVENT:
+        case BFI_FCPORT_I2H_EVENT:
                 switch (i2hmsg.event->link_state.linkstate) {
                 case BFA_PPORT_LINKUP:
-                        bfa_sm_send_event(pport, BFA_PPORT_SM_LINKUP);
+                        bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKUP);
                         break;
                 case BFA_PPORT_LINKDOWN:
-                        bfa_sm_send_event(pport, BFA_PPORT_SM_LINKDOWN);
+                        bfa_sm_send_event(fcport, BFA_FCPORT_SM_LINKDOWN);
                         break;
                 case BFA_PPORT_TRUNK_LINKDOWN:
                         /** todo: event notification */
@@ -939,42 +1299,40 @@ bfa_pport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
                 }
                 break;
 
-        case BFI_PPORT_I2H_GET_STATS_RSP:
-        case BFI_PPORT_I2H_GET_QOS_STATS_RSP:
+        case BFI_FCPORT_I2H_STATS_GET_RSP:
                 /*
                  * check for timer pop before processing the rsp
                  */
-                if (pport->stats_busy == BFA_FALSE
-                    || pport->stats_status == BFA_STATUS_ETIMER)
+                if (fcport->stats_busy == BFA_FALSE ||
+                        fcport->stats_status == BFA_STATUS_ETIMER)
                         break;
 
-                bfa_timer_stop(&pport->timer);
-                pport->stats_status = i2hmsg.getstats_rsp->status;
-                bfa_cb_queue(pport->bfa, &pport->hcb_qe, __bfa_cb_port_stats,
-                             pport);
+                bfa_timer_stop(&fcport->timer);
+                fcport->stats_status = i2hmsg.pstatsget_rsp->status;
+                bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
+                                __bfa_cb_fcport_stats_get, fcport);
                 break;
-        case BFI_PPORT_I2H_CLEAR_STATS_RSP:
-        case BFI_PPORT_I2H_CLEAR_QOS_STATS_RSP:
+
+        case BFI_FCPORT_I2H_STATS_CLEAR_RSP:
                 /*
                  * check for timer pop before processing the rsp
                  */
-                if (pport->stats_busy == BFA_FALSE
-                    || pport->stats_status == BFA_STATUS_ETIMER)
+                if (fcport->stats_busy == BFA_FALSE ||
+                        fcport->stats_status == BFA_STATUS_ETIMER)
                         break;
 
-                bfa_timer_stop(&pport->timer);
-                pport->stats_status = BFA_STATUS_OK;
-                bfa_cb_queue(pport->bfa, &pport->hcb_qe,
-                             __bfa_cb_port_stats_clr, pport);
+                bfa_timer_stop(&fcport->timer);
+                fcport->stats_status = BFA_STATUS_OK;
+                bfa_cb_queue(fcport->bfa, &fcport->hcb_qe,
+                                __bfa_cb_fcport_stats_clr, fcport);
                 break;
 
         default:
                 bfa_assert(0);
+        break;
         }
 }
 
-
-
 /**
  *  bfa_pport_api
  */
@@ -983,35 +1341,35 @@ bfa_pport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg)
  * Registered callback for port events.
  */
 void
-bfa_pport_event_register(struct bfa_s *bfa,
+bfa_fcport_event_register(struct bfa_s *bfa,
                          void (*cbfn) (void *cbarg, bfa_pport_event_t event),
                          void *cbarg)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        pport->event_cbfn = cbfn;
-        pport->event_cbarg = cbarg;
+        fcport->event_cbfn = cbfn;
+        fcport->event_cbarg = cbarg;
 }
 
 bfa_status_t
-bfa_pport_enable(struct bfa_s *bfa)
+bfa_fcport_enable(struct bfa_s *bfa)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        if (pport->diag_busy)
-                return (BFA_STATUS_DIAG_BUSY);
+        if (fcport->diag_busy)
+                return BFA_STATUS_DIAG_BUSY;
         else if (bfa_sm_cmp_state
-                 (BFA_PORT_MOD(bfa), bfa_pport_sm_disabling_qwait))
-                return (BFA_STATUS_DEVBUSY);
+                 (BFA_FCPORT_MOD(bfa), bfa_fcport_sm_disabling_qwait))
+                return BFA_STATUS_DEVBUSY;
 
-        bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_ENABLE);
+        bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_ENABLE);
         return BFA_STATUS_OK;
 }
 
 bfa_status_t
-bfa_pport_disable(struct bfa_s *bfa)
+bfa_fcport_disable(struct bfa_s *bfa)
 {
-        bfa_sm_send_event(BFA_PORT_MOD(bfa), BFA_PPORT_SM_DISABLE);
+        bfa_sm_send_event(BFA_FCPORT_MOD(bfa), BFA_FCPORT_SM_DISABLE);
         return BFA_STATUS_OK;
 }
 
@@ -1019,43 +1377,43 @@ bfa_pport_disable(struct bfa_s *bfa)
  * Configure port speed.
  */
 bfa_status_t
-bfa_pport_cfg_speed(struct bfa_s *bfa, enum bfa_pport_speed speed)
+bfa_fcport_cfg_speed(struct bfa_s *bfa, enum bfa_pport_speed speed)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
         bfa_trc(bfa, speed);
 
-        if ((speed != BFA_PPORT_SPEED_AUTO) && (speed > pport->speed_sup)) {
-                bfa_trc(bfa, pport->speed_sup);
+        if ((speed != BFA_PPORT_SPEED_AUTO) && (speed > fcport->speed_sup)) {
+                bfa_trc(bfa, fcport->speed_sup);
                 return BFA_STATUS_UNSUPP_SPEED;
         }
 
-        pport->cfg.speed = speed;
+        fcport->cfg.speed = speed;
 
-        return (BFA_STATUS_OK);
+        return BFA_STATUS_OK;
 }
 
 /**
  * Get current speed.
  */
 enum bfa_pport_speed
-bfa_pport_get_speed(struct bfa_s *bfa)
+bfa_fcport_get_speed(struct bfa_s *bfa)
 {
-        struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        return port->speed;
+        return fcport->speed;
 }
 
 /**
  * Configure port topology.
  */
 bfa_status_t
-bfa_pport_cfg_topology(struct bfa_s *bfa, enum bfa_pport_topology topology)
+bfa_fcport_cfg_topology(struct bfa_s *bfa, enum bfa_pport_topology topology)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
         bfa_trc(bfa, topology);
-        bfa_trc(bfa, pport->cfg.topology);
+        bfa_trc(bfa, fcport->cfg.topology);
 
         switch (topology) {
         case BFA_PPORT_TOPOLOGY_P2P:
@@ -1067,120 +1425,120 @@ bfa_pport_cfg_topology(struct bfa_s *bfa, enum bfa_pport_topology topology)
                 return BFA_STATUS_EINVAL;
         }
 
-        pport->cfg.topology = topology;
-        return (BFA_STATUS_OK);
+        fcport->cfg.topology = topology;
+        return BFA_STATUS_OK;
 }
 
 /**
  * Get current topology.
  */
 enum bfa_pport_topology
-bfa_pport_get_topology(struct bfa_s *bfa)
+bfa_fcport_get_topology(struct bfa_s *bfa)
 {
-        struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        return port->topology;
+        return fcport->topology;
 }
 
 bfa_status_t
-bfa_pport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa)
+bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
         bfa_trc(bfa, alpa);
-        bfa_trc(bfa, pport->cfg.cfg_hardalpa);
-        bfa_trc(bfa, pport->cfg.hardalpa);
+        bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
+        bfa_trc(bfa, fcport->cfg.hardalpa);
 
-        pport->cfg.cfg_hardalpa = BFA_TRUE;
-        pport->cfg.hardalpa = alpa;
+        fcport->cfg.cfg_hardalpa = BFA_TRUE;
+        fcport->cfg.hardalpa = alpa;
 
-        return (BFA_STATUS_OK);
+        return BFA_STATUS_OK;
 }
 
 bfa_status_t
-bfa_pport_clr_hardalpa(struct bfa_s *bfa)
+bfa_fcport_clr_hardalpa(struct bfa_s *bfa)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        bfa_trc(bfa, pport->cfg.cfg_hardalpa);
-        bfa_trc(bfa, pport->cfg.hardalpa);
+        bfa_trc(bfa, fcport->cfg.cfg_hardalpa);
+        bfa_trc(bfa, fcport->cfg.hardalpa);
 
-        pport->cfg.cfg_hardalpa = BFA_FALSE;
-        return (BFA_STATUS_OK);
+        fcport->cfg.cfg_hardalpa = BFA_FALSE;
+        return BFA_STATUS_OK;
 }
 
 bfa_boolean_t
-bfa_pport_get_hardalpa(struct bfa_s *bfa, u8 *alpa)
+bfa_fcport_get_hardalpa(struct bfa_s *bfa, u8 *alpa)
 {
-        struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        *alpa = port->cfg.hardalpa;
-        return port->cfg.cfg_hardalpa;
+        *alpa = fcport->cfg.hardalpa;
+        return fcport->cfg.cfg_hardalpa;
 }
 
 u8
-bfa_pport_get_myalpa(struct bfa_s *bfa)
+bfa_fcport_get_myalpa(struct bfa_s *bfa)
 {
-        struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        return port->myalpa;
+        return fcport->myalpa;
 }
 
 bfa_status_t
-bfa_pport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize)
+bfa_fcport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxfrsize)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
         bfa_trc(bfa, maxfrsize);
-        bfa_trc(bfa, pport->cfg.maxfrsize);
+        bfa_trc(bfa, fcport->cfg.maxfrsize);
 
         /*
          * with in range
          */
         if ((maxfrsize > FC_MAX_PDUSZ) || (maxfrsize < FC_MIN_PDUSZ))
-                return (BFA_STATUS_INVLD_DFSZ);
+                return BFA_STATUS_INVLD_DFSZ;
 
         /*
          * power of 2, if not the max frame size of 2112
          */
         if ((maxfrsize != FC_MAX_PDUSZ) && (maxfrsize & (maxfrsize - 1)))
-                return (BFA_STATUS_INVLD_DFSZ);
+                return BFA_STATUS_INVLD_DFSZ;
 
-        pport->cfg.maxfrsize = maxfrsize;
-        return (BFA_STATUS_OK);
+        fcport->cfg.maxfrsize = maxfrsize;
+        return BFA_STATUS_OK;
 }
 
 u16
-bfa_pport_get_maxfrsize(struct bfa_s *bfa)
+bfa_fcport_get_maxfrsize(struct bfa_s *bfa)
 {
-        struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        return port->cfg.maxfrsize;
+        return fcport->cfg.maxfrsize;
 }
 
 u32
-bfa_pport_mypid(struct bfa_s *bfa)
+bfa_fcport_mypid(struct bfa_s *bfa)
 {
-        struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        return port->mypid;
+        return fcport->mypid;
 }
 
 u8
-bfa_pport_get_rx_bbcredit(struct bfa_s *bfa)
+bfa_fcport_get_rx_bbcredit(struct bfa_s *bfa)
 {
-        struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        return port->cfg.rx_bbcredit;
+        return fcport->cfg.rx_bbcredit;
 }
 
 void
-bfa_pport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit)
+bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit)
 {
-        struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        port->cfg.tx_bbcredit = (u8) tx_bbcredit;
-        bfa_port_send_txcredit(port);
+        fcport->cfg.tx_bbcredit = (u8) tx_bbcredit;
+        bfa_fcport_send_txcredit(fcport);
 }
 
 /**
@@ -1188,302 +1546,192 @@ bfa_pport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit)
  */
 
 wwn_t
-bfa_pport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node)
+bfa_fcport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
         if (node)
-                return pport->nwwn;
+                return fcport->nwwn;
         else
-                return pport->pwwn;
+                return fcport->pwwn;
 }
 
 void
-bfa_pport_get_attr(struct bfa_s *bfa, struct bfa_pport_attr_s *attr)
+bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_pport_attr_s *attr)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
         bfa_os_memset(attr, 0, sizeof(struct bfa_pport_attr_s));
 
-        attr->nwwn = pport->nwwn;
-        attr->pwwn = pport->pwwn;
+        attr->nwwn = fcport->nwwn;
+        attr->pwwn = fcport->pwwn;
 
-        bfa_os_memcpy(&attr->pport_cfg, &pport->cfg,
+        bfa_os_memcpy(&attr->pport_cfg, &fcport->cfg,
                       sizeof(struct bfa_pport_cfg_s));
         /*
          * speed attributes
          */
-        attr->pport_cfg.speed = pport->cfg.speed;
-        attr->speed_supported = pport->speed_sup;
-        attr->speed = pport->speed;
+        attr->pport_cfg.speed = fcport->cfg.speed;
+        attr->speed_supported = fcport->speed_sup;
+        attr->speed = fcport->speed;
         attr->cos_supported = FC_CLASS_3;
 
         /*
          * topology attributes
          */
-        attr->pport_cfg.topology = pport->cfg.topology;
-        attr->topology = pport->topology;
+        attr->pport_cfg.topology = fcport->cfg.topology;
+        attr->topology = fcport->topology;
 
         /*
          * beacon attributes
          */
-        attr->beacon = pport->beacon;
-        attr->link_e2e_beacon = pport->link_e2e_beacon;
-        attr->plog_enabled = bfa_plog_get_setting(pport->bfa->plog);
+        attr->beacon = fcport->beacon;
+        attr->link_e2e_beacon = fcport->link_e2e_beacon;
+        attr->plog_enabled = bfa_plog_get_setting(fcport->bfa->plog);
 
         attr->pport_cfg.path_tov = bfa_fcpim_path_tov_get(bfa);
         attr->pport_cfg.q_depth = bfa_fcpim_qdepth_get(bfa);
-        attr->port_state = bfa_sm_to_state(hal_pport_sm_table, pport->sm);
-        if (bfa_ioc_is_disabled(&pport->bfa->ioc))
+        attr->port_state = bfa_sm_to_state(hal_pport_sm_table, fcport->sm);
+        if (bfa_ioc_is_disabled(&fcport->bfa->ioc))
                 attr->port_state = BFA_PPORT_ST_IOCDIS;
-        else if (bfa_ioc_fw_mismatch(&pport->bfa->ioc))
+        else if (bfa_ioc_fw_mismatch(&fcport->bfa->ioc))
                 attr->port_state = BFA_PPORT_ST_FWMISMATCH;
 }
 
-static void
-bfa_port_stats_query(void *cbarg)
-{
-        struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg;
-        bfi_pport_get_stats_req_t *msg;
-
-        msg = bfa_reqq_next(port->bfa, BFA_REQQ_PORT);
-
-        if (!msg) {
-                port->stats_qfull = BFA_TRUE;
-                bfa_reqq_winit(&port->stats_reqq_wait, bfa_port_stats_query,
-                               port);
-                bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->stats_reqq_wait);
-                return;
-        }
-        port->stats_qfull = BFA_FALSE;
-
-        bfa_os_memset(msg, 0, sizeof(bfi_pport_get_stats_req_t));
-        bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_GET_STATS_REQ,
-                    bfa_lpuid(port->bfa));
-        bfa_reqq_produce(port->bfa, BFA_REQQ_PORT);
+#define BFA_FCPORT_STATS_TOV    1000
 
-        return;
-}
-
-static void
-bfa_port_stats_clear(void *cbarg)
+/**
+ * Fetch port attributes (FCQoS or FCoE).
+ */
+bfa_status_t
+bfa_fcport_get_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
+                    bfa_cb_pport_t cbfn, void *cbarg)
 {
-        struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg;
-        bfi_pport_clear_stats_req_t *msg;
-
-        msg = bfa_reqq_next(port->bfa, BFA_REQQ_PORT);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        if (!msg) {
-                port->stats_qfull = BFA_TRUE;
-                bfa_reqq_winit(&port->stats_reqq_wait, bfa_port_stats_clear,
-                               port);
-                bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->stats_reqq_wait);
-                return;
+        if (fcport->stats_busy) {
+                bfa_trc(bfa, fcport->stats_busy);
+                return BFA_STATUS_DEVBUSY;
         }
-        port->stats_qfull = BFA_FALSE;
-
-        bfa_os_memset(msg, 0, sizeof(bfi_pport_clear_stats_req_t));
-        bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_CLEAR_STATS_REQ,
-                    bfa_lpuid(port->bfa));
-        bfa_reqq_produce(port->bfa, BFA_REQQ_PORT);
-        return;
-}
-
-static void
-bfa_port_qos_stats_clear(void *cbarg)
-{
-        struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg;
-        bfi_pport_clear_qos_stats_req_t *msg;
 
-        msg = bfa_reqq_next(port->bfa, BFA_REQQ_PORT);
+        fcport->stats_busy  = BFA_TRUE;
+        fcport->stats_ret   = stats;
+        fcport->stats_cbfn  = cbfn;
+        fcport->stats_cbarg = cbarg;
 
-        if (!msg) {
-                port->stats_qfull = BFA_TRUE;
-                bfa_reqq_winit(&port->stats_reqq_wait, bfa_port_qos_stats_clear,
-                               port);
-                bfa_reqq_wait(port->bfa, BFA_REQQ_PORT, &port->stats_reqq_wait);
-                return;
-        }
-        port->stats_qfull = BFA_FALSE;
+        bfa_fcport_send_stats_get(fcport);
 
-        bfa_os_memset(msg, 0, sizeof(bfi_pport_clear_qos_stats_req_t));
-        bfi_h2i_set(msg->mh, BFI_MC_FC_PORT, BFI_PPORT_H2I_CLEAR_QOS_STATS_REQ,
-                    bfa_lpuid(port->bfa));
-        bfa_reqq_produce(port->bfa, BFA_REQQ_PORT);
-        return;
-}
-
-static void
-bfa_pport_stats_swap(union bfa_pport_stats_u *d, union bfa_pport_stats_u *s)
-{
-        u32       *dip = (u32 *) d;
-        u32       *sip = (u32 *) s;
-        int             i;
-
-        /*
-         * Do 64 bit fields swap first
-         */
-        for (i = 0;
-             i <
-             ((sizeof(union bfa_pport_stats_u) -
-               sizeof(struct bfa_qos_stats_s)) / sizeof(u32)); i = i + 2) {
-#ifdef __BIGENDIAN
-                dip[i] = bfa_os_ntohl(sip[i]);
-                dip[i + 1] = bfa_os_ntohl(sip[i + 1]);
-#else
-                dip[i] = bfa_os_ntohl(sip[i + 1]);
-                dip[i + 1] = bfa_os_ntohl(sip[i]);
-#endif
-        }
-
-        /*
-         * Now swap the 32 bit fields
-         */
-        for (; i < (sizeof(union bfa_pport_stats_u) / sizeof(u32)); ++i)
-                dip[i] = bfa_os_ntohl(sip[i]);
+        bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_get_timeout,
+                fcport, BFA_FCPORT_STATS_TOV);
+        return BFA_STATUS_OK;
 }
 
-static void
-__bfa_cb_port_stats_clr(void *cbarg, bfa_boolean_t complete)
+/**
+ * Reset port statistics (FCQoS or FCoE).
+ */
+bfa_status_t
+bfa_fcport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
 {
-        struct bfa_pport_s *port = cbarg;
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        if (complete) {
-                port->stats_cbfn(port->stats_cbarg, port->stats_status);
-        } else {
-                port->stats_busy = BFA_FALSE;
-                port->stats_status = BFA_STATUS_OK;
+        if (fcport->stats_busy) {
+                bfa_trc(bfa, fcport->stats_busy);
+                return BFA_STATUS_DEVBUSY;
         }
-}
-
-static void
-bfa_port_stats_clr_timeout(void *cbarg)
-{
-        struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg;
 
-        bfa_trc(port->bfa, port->stats_qfull);
+        fcport->stats_busy = BFA_TRUE;
+        fcport->stats_cbfn = cbfn;
+        fcport->stats_cbarg = cbarg;
 
-        if (port->stats_qfull) {
-                bfa_reqq_wcancel(&port->stats_reqq_wait);
-                port->stats_qfull = BFA_FALSE;
-        }
+        bfa_fcport_send_stats_clear(fcport);
 
-        port->stats_status = BFA_STATUS_ETIMER;
-        bfa_cb_queue(port->bfa, &port->hcb_qe, __bfa_cb_port_stats_clr, port);
+        bfa_timer_start(bfa, &fcport->timer, bfa_fcport_stats_clr_timeout,
+                        fcport, BFA_FCPORT_STATS_TOV);
+        return BFA_STATUS_OK;
 }
 
-static void
-__bfa_cb_port_stats(void *cbarg, bfa_boolean_t complete)
+/**
+ * Fetch FCQoS port statistics
+ */
+bfa_status_t
+bfa_fcport_get_qos_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
+        bfa_cb_pport_t cbfn, void *cbarg)
 {
-        struct bfa_pport_s *port = cbarg;
+        /* Meaningful only for FC mode */
+        bfa_assert(bfa_ioc_get_fcmode(&bfa->ioc));
 
-        if (complete) {
-                if (port->stats_status == BFA_STATUS_OK)
-                        bfa_pport_stats_swap(port->stats_ret, port->stats);
-                port->stats_cbfn(port->stats_cbarg, port->stats_status);
-        } else {
-                port->stats_busy = BFA_FALSE;
-                port->stats_status = BFA_STATUS_OK;
-        }
+        return bfa_fcport_get_stats(bfa, stats, cbfn, cbarg);
 }
 
-static void
-bfa_port_stats_timeout(void *cbarg)
+/**
+ * Reset FCoE port statistics
+ */
+bfa_status_t
+bfa_fcport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
 {
-        struct bfa_pport_s *port = (struct bfa_pport_s *)cbarg;
-
-        bfa_trc(port->bfa, port->stats_qfull);
+        /* Meaningful only for FC mode */
+        bfa_assert(bfa_ioc_get_fcmode(&bfa->ioc));
 
-        if (port->stats_qfull) {
-                bfa_reqq_wcancel(&port->stats_reqq_wait);
-                port->stats_qfull = BFA_FALSE;
-        }
-
-        port->stats_status = BFA_STATUS_ETIMER;
-        bfa_cb_queue(port->bfa, &port->hcb_qe, __bfa_cb_port_stats, port);
+        return bfa_fcport_clear_stats(bfa, cbfn, cbarg);
 }
 
-#define BFA_PORT_STATS_TOV      1000
-
 /**
- * Fetch port attributes.
+ * Fetch FCQoS port statistics
  */
 bfa_status_t
-bfa_pport_get_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats,
-                    bfa_cb_pport_t cbfn, void *cbarg)
+bfa_fcport_get_fcoe_stats(struct bfa_s *bfa, union bfa_fcport_stats_u *stats,
+        bfa_cb_pport_t cbfn, void *cbarg)
 {
-        struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
+        /* Meaningful only for FCoE mode */
+        bfa_assert(!bfa_ioc_get_fcmode(&bfa->ioc));
 
-        if (port->stats_busy) {
-                bfa_trc(bfa, port->stats_busy);
-                return (BFA_STATUS_DEVBUSY);
-        }
-
-        port->stats_busy = BFA_TRUE;
-        port->stats_ret = stats;
-        port->stats_cbfn = cbfn;
-        port->stats_cbarg = cbarg;
-
-        bfa_port_stats_query(port);
-
-        bfa_timer_start(bfa, &port->timer, bfa_port_stats_timeout, port,
-                        BFA_PORT_STATS_TOV);
-        return (BFA_STATUS_OK);
+        return bfa_fcport_get_stats(bfa, stats, cbfn, cbarg);
 }
 
+/**
+ * Reset FCoE port statistics
+ */
 bfa_status_t
-bfa_pport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
+bfa_fcport_clear_fcoe_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
 {
-        struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
-
-        if (port->stats_busy) {
-                bfa_trc(bfa, port->stats_busy);
-                return (BFA_STATUS_DEVBUSY);
-        }
-
-        port->stats_busy = BFA_TRUE;
-        port->stats_cbfn = cbfn;
-        port->stats_cbarg = cbarg;
-
-        bfa_port_stats_clear(port);
+        /* Meaningful only for FCoE mode */
+        bfa_assert(!bfa_ioc_get_fcmode(&bfa->ioc));
 
-        bfa_timer_start(bfa, &port->timer, bfa_port_stats_clr_timeout, port,
-                        BFA_PORT_STATS_TOV);
-        return (BFA_STATUS_OK);
+        return bfa_fcport_clear_stats(bfa, cbfn, cbarg);
 }
 
 bfa_status_t
-bfa_pport_trunk_enable(struct bfa_s *bfa, u8 bitmap)
+bfa_fcport_trunk_enable(struct bfa_s *bfa, u8 bitmap)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
         bfa_trc(bfa, bitmap);
-        bfa_trc(bfa, pport->cfg.trunked);
-        bfa_trc(bfa, pport->cfg.trunk_ports);
+        bfa_trc(bfa, fcport->cfg.trunked);
+        bfa_trc(bfa, fcport->cfg.trunk_ports);
 
         if (!bitmap || (bitmap & (bitmap - 1)))
                 return BFA_STATUS_EINVAL;
 
-        pport->cfg.trunked = BFA_TRUE;
-        pport->cfg.trunk_ports = bitmap;
+        fcport->cfg.trunked = BFA_TRUE;
+        fcport->cfg.trunk_ports = bitmap;
 
         return BFA_STATUS_OK;
 }
 
 void
-bfa_pport_qos_get_attr(struct bfa_s *bfa, struct bfa_qos_attr_s *qos_attr)
+bfa_fcport_qos_get_attr(struct bfa_s *bfa, struct bfa_qos_attr_s *qos_attr)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        qos_attr->state = bfa_os_ntohl(pport->qos_attr.state);
-        qos_attr->total_bb_cr = bfa_os_ntohl(pport->qos_attr.total_bb_cr);
+        qos_attr->state = bfa_os_ntohl(fcport->qos_attr.state);
+        qos_attr->total_bb_cr = bfa_os_ntohl(fcport->qos_attr.total_bb_cr);
 }
 
 void
-bfa_pport_qos_get_vc_attr(struct bfa_s *bfa,
+bfa_fcport_qos_get_vc_attr(struct bfa_s *bfa,
                           struct bfa_qos_vc_attr_s *qos_vc_attr)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
-        struct bfa_qos_vc_attr_s *bfa_vc_attr = &pport->qos_vc_attr;
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
+        struct bfa_qos_vc_attr_s *bfa_vc_attr = &fcport->qos_vc_attr;
         u32        i = 0;
 
         qos_vc_attr->total_vc_count = bfa_os_ntohs(bfa_vc_attr->total_vc_count);
@@ -1506,166 +1754,136 @@ bfa_pport_qos_get_vc_attr(struct bfa_s *bfa,
 }
 
 /**
- * Fetch QoS Stats.
- */
-bfa_status_t
-bfa_pport_get_qos_stats(struct bfa_s *bfa, union bfa_pport_stats_u *stats,
-                        bfa_cb_pport_t cbfn, void *cbarg)
-{
-        /*
-         * QoS stats is embedded in port stats
-         */
-        return (bfa_pport_get_stats(bfa, stats, cbfn, cbarg));
-}
-
-bfa_status_t
-bfa_pport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn, void *cbarg)
-{
-        struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
-
-        if (port->stats_busy) {
-                bfa_trc(bfa, port->stats_busy);
-                return (BFA_STATUS_DEVBUSY);
-        }
-
-        port->stats_busy = BFA_TRUE;
-        port->stats_cbfn = cbfn;
-        port->stats_cbarg = cbarg;
-
-        bfa_port_qos_stats_clear(port);
-
-        bfa_timer_start(bfa, &port->timer, bfa_port_stats_clr_timeout, port,
-                        BFA_PORT_STATS_TOV);
-        return (BFA_STATUS_OK);
-}
-
-/**
  * Fetch port attributes.
  */
 bfa_status_t
-bfa_pport_trunk_disable(struct bfa_s *bfa)
+bfa_fcport_trunk_disable(struct bfa_s *bfa)
 {
-        return (BFA_STATUS_OK);
+        return BFA_STATUS_OK;
 }
 
 bfa_boolean_t
-bfa_pport_trunk_query(struct bfa_s *bfa, u32 *bitmap)
+bfa_fcport_trunk_query(struct bfa_s *bfa, u32 *bitmap)
 {
-        struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        *bitmap = port->cfg.trunk_ports;
-        return port->cfg.trunked;
+        *bitmap = fcport->cfg.trunk_ports;
+        return fcport->cfg.trunked;
 }
 
 bfa_boolean_t
-bfa_pport_is_disabled(struct bfa_s *bfa)
+bfa_fcport_is_disabled(struct bfa_s *bfa)
 {
-        struct bfa_pport_s *port = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        return (bfa_sm_to_state(hal_pport_sm_table, port->sm) ==
-                BFA_PPORT_ST_DISABLED);
+        return bfa_sm_to_state(hal_pport_sm_table, fcport->sm) ==
+                BFA_PPORT_ST_DISABLED;
 
 }
 
 bfa_boolean_t
-bfa_pport_is_ratelim(struct bfa_s *bfa)
+bfa_fcport_is_ratelim(struct bfa_s *bfa)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-return (pport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE);
+        return fcport->cfg.ratelimit ? BFA_TRUE : BFA_FALSE;
 
 }
 
 void
-bfa_pport_cfg_qos(struct bfa_s *bfa, bfa_boolean_t on_off)
+bfa_fcport_cfg_qos(struct bfa_s *bfa, bfa_boolean_t on_off)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
+        enum bfa_ioc_type_e ioc_type = bfa_get_type(bfa);
 
         bfa_trc(bfa, on_off);
-        bfa_trc(bfa, pport->cfg.qos_enabled);
+        bfa_trc(bfa, fcport->cfg.qos_enabled);
 
-        pport->cfg.qos_enabled = on_off;
+        bfa_trc(bfa, ioc_type);
+
+        if (ioc_type == BFA_IOC_TYPE_FC)
+                fcport->cfg.qos_enabled = on_off;
 }
 
 void
-bfa_pport_cfg_ratelim(struct bfa_s *bfa, bfa_boolean_t on_off)
+bfa_fcport_cfg_ratelim(struct bfa_s *bfa, bfa_boolean_t on_off)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
         bfa_trc(bfa, on_off);
-        bfa_trc(bfa, pport->cfg.ratelimit);
+        bfa_trc(bfa, fcport->cfg.ratelimit);
 
-        pport->cfg.ratelimit = on_off;
-        if (pport->cfg.trl_def_speed == BFA_PPORT_SPEED_UNKNOWN)
-                pport->cfg.trl_def_speed = BFA_PPORT_SPEED_1GBPS;
+        fcport->cfg.ratelimit = on_off;
+        if (fcport->cfg.trl_def_speed == BFA_PPORT_SPEED_UNKNOWN)
+                fcport->cfg.trl_def_speed = BFA_PPORT_SPEED_1GBPS;
 }
 
 /**
  * Configure default minimum ratelim speed
  */
 bfa_status_t
-bfa_pport_cfg_ratelim_speed(struct bfa_s *bfa, enum bfa_pport_speed speed)
+bfa_fcport_cfg_ratelim_speed(struct bfa_s *bfa, enum bfa_pport_speed speed)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
         bfa_trc(bfa, speed);
 
         /*
          * Auto and speeds greater than the supported speed, are invalid
          */
-        if ((speed == BFA_PPORT_SPEED_AUTO) || (speed > pport->speed_sup)) {
-                bfa_trc(bfa, pport->speed_sup);
+        if ((speed == BFA_PPORT_SPEED_AUTO) || (speed > fcport->speed_sup)) {
+                bfa_trc(bfa, fcport->speed_sup);
                 return BFA_STATUS_UNSUPP_SPEED;
         }
 
-        pport->cfg.trl_def_speed = speed;
+        fcport->cfg.trl_def_speed = speed;
 
-        return (BFA_STATUS_OK);
+        return BFA_STATUS_OK;
 }
 
 /**
  * Get default minimum ratelim speed
  */
 enum bfa_pport_speed
-bfa_pport_get_ratelim_speed(struct bfa_s *bfa)
+bfa_fcport_get_ratelim_speed(struct bfa_s *bfa)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
-        bfa_trc(bfa, pport->cfg.trl_def_speed);
-        return (pport->cfg.trl_def_speed);
+        bfa_trc(bfa, fcport->cfg.trl_def_speed);
+        return fcport->cfg.trl_def_speed;
 
 }
 
 void
-bfa_pport_busy(struct bfa_s *bfa, bfa_boolean_t status)
+bfa_fcport_busy(struct bfa_s *bfa, bfa_boolean_t status)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
         bfa_trc(bfa, status);
-        bfa_trc(bfa, pport->diag_busy);
+        bfa_trc(bfa, fcport->diag_busy);
 
-        pport->diag_busy = status;
+        fcport->diag_busy = status;
 }
 
 void
-bfa_pport_beacon(struct bfa_s *bfa, bfa_boolean_t beacon,
+bfa_fcport_beacon(struct bfa_s *bfa, bfa_boolean_t beacon,
                  bfa_boolean_t link_e2e_beacon)
 {
-        struct bfa_pport_s *pport = BFA_PORT_MOD(bfa);
+        struct bfa_fcport_s *fcport = BFA_FCPORT_MOD(bfa);
 
         bfa_trc(bfa, beacon);
         bfa_trc(bfa, link_e2e_beacon);
-        bfa_trc(bfa, pport->beacon);
-        bfa_trc(bfa, pport->link_e2e_beacon);
+        bfa_trc(bfa, fcport->beacon);
+        bfa_trc(bfa, fcport->link_e2e_beacon);
 
-        pport->beacon = beacon;
-        pport->link_e2e_beacon = link_e2e_beacon;
+        fcport->beacon = beacon;
+        fcport->link_e2e_beacon = link_e2e_beacon;
 }
 
 bfa_boolean_t
-bfa_pport_is_linkup(struct bfa_s *bfa)
+bfa_fcport_is_linkup(struct bfa_s *bfa)
 {
-        return bfa_sm_cmp_state(BFA_PORT_MOD(bfa), bfa_pport_sm_linkup);
+        return bfa_sm_cmp_state(BFA_FCPORT_MOD(bfa), bfa_fcport_sm_linkup);
 }
 
 
diff --git a/drivers/scsi/bfa/bfa_fcs.c b/drivers/scsi/bfa/bfa_fcs.c
index 7cb39a306ea9..3516172c597c 100644
--- a/drivers/scsi/bfa/bfa_fcs.c
+++ b/drivers/scsi/bfa/bfa_fcs.c
@@ -36,6 +36,7 @@
  * FCS sub-modules
  */
 struct bfa_fcs_mod_s {
+        void            (*attach) (struct bfa_fcs_s *fcs);
         void            (*modinit) (struct bfa_fcs_s *fcs);
         void            (*modexit) (struct bfa_fcs_s *fcs);
 };
@@ -43,12 +44,10 @@ struct bfa_fcs_mod_s {
 #define BFA_FCS_MODULE(_mod) { _mod ## _modinit, _mod ## _modexit }
 
 static struct bfa_fcs_mod_s fcs_modules[] = {
-        BFA_FCS_MODULE(bfa_fcs_pport),
-        BFA_FCS_MODULE(bfa_fcs_uf),
-        BFA_FCS_MODULE(bfa_fcs_fabric),
-        BFA_FCS_MODULE(bfa_fcs_vport),
-        BFA_FCS_MODULE(bfa_fcs_rport),
-        BFA_FCS_MODULE(bfa_fcs_fcpim),
+        { bfa_fcs_pport_attach, NULL, NULL },
+        { bfa_fcs_uf_attach, NULL, NULL },
+        { bfa_fcs_fabric_attach, bfa_fcs_fabric_modinit,
+         bfa_fcs_fabric_modexit },
 };
 
 /**
@@ -71,16 +70,10 @@ bfa_fcs_exit_comp(void *fcs_cbarg)
  */
 
 /**
- *              FCS instance initialization.
- *
- *      param[in]               fcs             FCS instance
- *      param[in]               bfa             BFA instance
- *      param[in]               bfad            BFA driver instance
- *
- *      return None
+ * fcs attach -- called once to initialize data structures at driver attach time
  */
 void
-bfa_fcs_init(struct bfa_fcs_s *fcs, struct bfa_s *bfa, struct bfad_s *bfad,
+bfa_fcs_attach(struct bfa_fcs_s *fcs, struct bfa_s *bfa, struct bfad_s *bfad,
                         bfa_boolean_t min_cfg)
 {
         int             i;
@@ -95,7 +88,24 @@ bfa_fcs_init(struct bfa_fcs_s *fcs, struct bfa_s *bfa, struct bfad_s *bfad,
 
         for (i = 0; i < sizeof(fcs_modules) / sizeof(fcs_modules[0]); i++) {
                 mod = &fcs_modules[i];
-                mod->modinit(fcs);
+                if (mod->attach)
+                        mod->attach(fcs);
+        }
+}
+
+/**
+ * fcs initialization, called once after bfa initialization is complete
+ */
+void
+bfa_fcs_init(struct bfa_fcs_s *fcs)
+{
+        int             i;
+        struct bfa_fcs_mod_s  *mod;
+
+        for (i = 0; i < sizeof(fcs_modules) / sizeof(fcs_modules[0]); i++) {
+                mod = &fcs_modules[i];
+                if (mod->modinit)
+                        mod->modinit(fcs);
         }
 }
 
@@ -127,6 +137,23 @@ bfa_fcs_driver_info_init(struct bfa_fcs_s *fcs,
 }
 
 /**
+ *      @brief
+ *              FCS FDMI Driver Parameter Initialization
+ *
+ *      @param[in]              fcs             FCS instance
+ *      @param[in]              fdmi_enable     TRUE/FALSE
+ *
+ *      @return None
+ */
+void
+bfa_fcs_set_fdmi_param(struct bfa_fcs_s *fcs, bfa_boolean_t fdmi_enable)
+{
+
+        fcs->fdmi_enabled = fdmi_enable;
+
+}
+
+/**
  *              FCS instance cleanup and exit.
  *
  *      param[in]               fcs                     FCS instance
@@ -143,10 +170,12 @@ bfa_fcs_exit(struct bfa_fcs_s *fcs)
         nmods = sizeof(fcs_modules) / sizeof(fcs_modules[0]);
 
         for (i = 0; i < nmods; i++) {
-                bfa_wc_up(&fcs->wc);
 
                 mod = &fcs_modules[i];
-                mod->modexit(fcs);
+                if (mod->modexit) {
+                        bfa_wc_up(&fcs->wc);
+                        mod->modexit(fcs);
+                }
         }
 
         bfa_wc_wait(&fcs->wc);
diff --git a/drivers/scsi/bfa/bfa_fcs_lport.c b/drivers/scsi/bfa/bfa_fcs_lport.c
index 8975ed041dc0..7c1251c682d8 100644
--- a/drivers/scsi/bfa/bfa_fcs_lport.c
+++ b/drivers/scsi/bfa/bfa_fcs_lport.c
@@ -114,7 +114,7 @@ bfa_fcs_port_sm_uninit(struct bfa_fcs_port_s *port,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -136,7 +136,7 @@ bfa_fcs_port_sm_init(struct bfa_fcs_port_s *port, enum bfa_fcs_port_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -176,7 +176,7 @@ bfa_fcs_port_sm_online(struct bfa_fcs_port_s *port,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -214,7 +214,7 @@ bfa_fcs_port_sm_offline(struct bfa_fcs_port_s *port,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -234,7 +234,7 @@ bfa_fcs_port_sm_deleting(struct bfa_fcs_port_s *port,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -263,30 +263,8 @@ bfa_fcs_port_aen_post(struct bfa_fcs_port_s *port,
 
         bfa_assert(role <= BFA_PORT_ROLE_FCP_MAX);
 
-        switch (event) {
-        case BFA_LPORT_AEN_ONLINE:
-                bfa_log(logmod, BFA_AEN_LPORT_ONLINE, lpwwn_ptr,
-                        role_str[role / 2]);
-                break;
-        case BFA_LPORT_AEN_OFFLINE:
-                bfa_log(logmod, BFA_AEN_LPORT_OFFLINE, lpwwn_ptr,
-                        role_str[role / 2]);
-                break;
-        case BFA_LPORT_AEN_NEW:
-                bfa_log(logmod, BFA_AEN_LPORT_NEW, lpwwn_ptr,
-                        role_str[role / 2]);
-                break;
-        case BFA_LPORT_AEN_DELETE:
-                bfa_log(logmod, BFA_AEN_LPORT_DELETE, lpwwn_ptr,
-                        role_str[role / 2]);
-                break;
-        case BFA_LPORT_AEN_DISCONNECT:
-                bfa_log(logmod, BFA_AEN_LPORT_DISCONNECT, lpwwn_ptr,
-                        role_str[role / 2]);
-                break;
-        default:
-                break;
-        }
+        bfa_log(logmod, BFA_LOG_CREATE_ID(BFA_AEN_CAT_LPORT, event), lpwwn_ptr,
+                role_str[role/2]);
 
         aen_data.lport.vf_id = port->fabric->vf_id;
         aen_data.lport.roles = role;
@@ -568,11 +546,10 @@ bfa_fcs_port_offline_actions(struct bfa_fcs_port_s *port)
 
         __port_action[port->fabric->fab_type].offline(port);
 
-        if (bfa_fcs_fabric_is_online(port->fabric) == BFA_TRUE) {
+        if (bfa_fcs_fabric_is_online(port->fabric) == BFA_TRUE)
                 bfa_fcs_port_aen_post(port, BFA_LPORT_AEN_DISCONNECT);
-        } else {
+        else
                 bfa_fcs_port_aen_post(port, BFA_LPORT_AEN_OFFLINE);
-        }
         bfa_fcb_port_offline(port->fcs->bfad, port->port_cfg.roles,
                         port->fabric->vf_drv,
                         (port->vport == NULL) ? NULL : port->vport->vport_drv);
@@ -777,7 +754,7 @@ bfa_fcs_port_get_rport_by_pwwn(struct bfa_fcs_port_s *port, wwn_t pwwn)
         }
 
         bfa_trc(port->fcs, pwwn);
-        return (NULL);
+        return NULL;
 }
 
 /**
@@ -796,7 +773,7 @@ bfa_fcs_port_get_rport_by_nwwn(struct bfa_fcs_port_s *port, wwn_t nwwn)
         }
 
         bfa_trc(port->fcs, nwwn);
-        return (NULL);
+        return NULL;
 }
 
 /**
@@ -870,40 +847,50 @@ bfa_fcs_port_lip(struct bfa_fcs_port_s *port)
 bfa_boolean_t
 bfa_fcs_port_is_online(struct bfa_fcs_port_s *port)
 {
-        return (bfa_sm_cmp_state(port, bfa_fcs_port_sm_online));
+        return bfa_sm_cmp_state(port, bfa_fcs_port_sm_online);
 }
 
 /**
- * Logical port initialization of base or virtual port.
- * Called by fabric for base port or by vport for virtual ports.
+ * Attach time initialization of logical ports.
  */
 void
-bfa_fcs_lport_init(struct bfa_fcs_port_s *lport, struct bfa_fcs_s *fcs,
-                   u16 vf_id, struct bfa_port_cfg_s *port_cfg,
-                   struct bfa_fcs_vport_s *vport)
+bfa_fcs_lport_attach(struct bfa_fcs_port_s *lport, struct bfa_fcs_s *fcs,
+                uint16_t vf_id, struct bfa_fcs_vport_s *vport)
 {
         lport->fcs = fcs;
         lport->fabric = bfa_fcs_vf_lookup(fcs, vf_id);
-        bfa_os_assign(lport->port_cfg, *port_cfg);
         lport->vport = vport;
         lport->lp_tag = (vport) ? bfa_lps_get_tag(vport->lps) :
                          bfa_lps_get_tag(lport->fabric->lps);
 
         INIT_LIST_HEAD(&lport->rport_q);
         lport->num_rports = 0;
+}
+
+/**
+ * Logical port initialization of base or virtual port.
+ * Called by fabric for base port or by vport for virtual ports.
+ */
 
-        lport->bfad_port =
-                bfa_fcb_port_new(fcs->bfad, lport, lport->port_cfg.roles,
+void
+bfa_fcs_lport_init(struct bfa_fcs_port_s *lport,
+                struct bfa_port_cfg_s *port_cfg)
+{
+        struct bfa_fcs_vport_s *vport = lport->vport;
+
+        bfa_os_assign(lport->port_cfg, *port_cfg);
+
+        lport->bfad_port = bfa_fcb_port_new(lport->fcs->bfad, lport,
+                                lport->port_cfg.roles,
                                 lport->fabric->vf_drv,
                                 vport ? vport->vport_drv : NULL);
+
         bfa_fcs_port_aen_post(lport, BFA_LPORT_AEN_NEW);
 
         bfa_sm_set_state(lport, bfa_fcs_port_sm_uninit);
         bfa_sm_send_event(lport, BFA_FCS_PORT_SM_CREATE);
 }
 
-
-
 /**
  *  fcs_lport_api
  */
@@ -922,13 +909,20 @@ bfa_fcs_port_get_attr(struct bfa_fcs_port_s *port,
         if (port->fabric) {
                 port_attr->port_type = bfa_fcs_fabric_port_type(port->fabric);
                 port_attr->loopback = bfa_fcs_fabric_is_loopback(port->fabric);
+                port_attr->authfail =
+                                bfa_fcs_fabric_is_auth_failed(port->fabric);
                 port_attr->fabric_name = bfa_fcs_port_get_fabric_name(port);
                 memcpy(port_attr->fabric_ip_addr,
                        bfa_fcs_port_get_fabric_ipaddr(port),
                        BFA_FCS_FABRIC_IPADDR_SZ);
 
-                if (port->vport != NULL)
+                if (port->vport != NULL) {
                         port_attr->port_type = BFA_PPORT_TYPE_VPORT;
+                        port_attr->fpma_mac =
+                                bfa_lps_get_lp_mac(port->vport->lps);
+                } else
+                        port_attr->fpma_mac =
+                                bfa_lps_get_lp_mac(port->fabric->lps);
 
         } else {
                 port_attr->port_type = BFA_PPORT_TYPE_UNKNOWN;
diff --git a/drivers/scsi/bfa/bfa_fcs_port.c b/drivers/scsi/bfa/bfa_fcs_port.c
index 9c4b24e62de1..3c27788cd527 100644
--- a/drivers/scsi/bfa/bfa_fcs_port.c
+++ b/drivers/scsi/bfa/bfa_fcs_port.c
@@ -55,14 +55,7 @@ bfa_fcs_pport_event_handler(void *cbarg, bfa_pport_event_t event)
 }
 
 void
-bfa_fcs_pport_modinit(struct bfa_fcs_s *fcs)
+bfa_fcs_pport_attach(struct bfa_fcs_s *fcs)
 {
-        bfa_pport_event_register(fcs->bfa, bfa_fcs_pport_event_handler,
-                                     fcs);
-}
-
-void
-bfa_fcs_pport_modexit(struct bfa_fcs_s *fcs)
-{
-        bfa_fcs_modexit_comp(fcs);
+        bfa_fcport_event_register(fcs->bfa, bfa_fcs_pport_event_handler, fcs);
 }
diff --git a/drivers/scsi/bfa/bfa_fcs_uf.c b/drivers/scsi/bfa/bfa_fcs_uf.c
index ad01db6444b2..3d57d48bbae4 100644
--- a/drivers/scsi/bfa/bfa_fcs_uf.c
+++ b/drivers/scsi/bfa/bfa_fcs_uf.c
@@ -93,13 +93,7 @@ bfa_fcs_uf_recv(void *cbarg, struct bfa_uf_s *uf)
 }
 
 void
-bfa_fcs_uf_modinit(struct bfa_fcs_s *fcs)
+bfa_fcs_uf_attach(struct bfa_fcs_s *fcs)
 {
         bfa_uf_recv_register(fcs->bfa, bfa_fcs_uf_recv, fcs);
 }
-
-void
-bfa_fcs_uf_modexit(struct bfa_fcs_s *fcs)
-{
-        bfa_fcs_modexit_comp(fcs);
-}
diff --git a/drivers/scsi/bfa/bfa_fcxp.c b/drivers/scsi/bfa/bfa_fcxp.c
index 4754a0e9006a..cf0ad6782686 100644
--- a/drivers/scsi/bfa/bfa_fcxp.c
+++ b/drivers/scsi/bfa/bfa_fcxp.c
@@ -199,7 +199,7 @@ bfa_fcxp_get(struct bfa_fcxp_mod_s *fm)
         if (fcxp)
                 list_add_tail(&fcxp->qe, &fm->fcxp_active_q);
 
-        return (fcxp);
+        return fcxp;
 }
 
 static void
@@ -503,7 +503,7 @@ bfa_fcxp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles,
 
         fcxp = bfa_fcxp_get(BFA_FCXP_MOD(bfa));
         if (fcxp == NULL)
-                return (NULL);
+                return NULL;
 
         bfa_trc(bfa, fcxp->fcxp_tag);
 
@@ -568,7 +568,7 @@ bfa_fcxp_alloc(void *caller, struct bfa_s *bfa, int nreq_sgles,
                 }
         }
 
-        return (fcxp);
+        return fcxp;
 }
 
 /**
@@ -709,7 +709,7 @@ bfa_status_t
 bfa_fcxp_abort(struct bfa_fcxp_s *fcxp)
 {
         bfa_assert(0);
-        return (BFA_STATUS_OK);
+        return BFA_STATUS_OK;
 }
 
 void
diff --git a/drivers/scsi/bfa/bfa_hw_cb.c b/drivers/scsi/bfa/bfa_hw_cb.c
index ede1438619e2..871a4e28575c 100644
--- a/drivers/scsi/bfa/bfa_hw_cb.c
+++ b/drivers/scsi/bfa/bfa_hw_cb.c
@@ -53,6 +53,18 @@ bfa_hwcb_reginit(struct bfa_s *bfa)
 }
 
 void
+bfa_hwcb_reqq_ack(struct bfa_s *bfa, int reqq)
+{
+}
+
+static void
+bfa_hwcb_reqq_ack_msix(struct bfa_s *bfa, int reqq)
+{
+        bfa_reg_write(bfa->iocfc.bfa_regs.intr_status,
+                __HFN_INT_CPE_Q0 << CPE_Q_NUM(bfa_ioc_pcifn(&bfa->ioc), reqq));
+}
+
+void
 bfa_hwcb_rspq_ack(struct bfa_s *bfa, int rspq)
 {
 }
@@ -136,6 +148,7 @@ bfa_hwcb_msix_uninstall(struct bfa_s *bfa)
 void
 bfa_hwcb_isr_mode_set(struct bfa_s *bfa, bfa_boolean_t msix)
 {
+        bfa->iocfc.hwif.hw_reqq_ack = bfa_hwcb_reqq_ack_msix;
         bfa->iocfc.hwif.hw_rspq_ack = bfa_hwcb_rspq_ack_msix;
 }
 
diff --git a/drivers/scsi/bfa/bfa_hw_ct.c b/drivers/scsi/bfa/bfa_hw_ct.c
index 51ae5740e6e9..76ceb9a4bf2f 100644
--- a/drivers/scsi/bfa/bfa_hw_ct.c
+++ b/drivers/scsi/bfa/bfa_hw_ct.c
@@ -85,6 +85,15 @@ bfa_hwct_reginit(struct bfa_s *bfa)
 }
 
 void
+bfa_hwct_reqq_ack(struct bfa_s *bfa, int reqq)
+{
+        u32 r32;
+
+        r32 = bfa_reg_read(bfa->iocfc.bfa_regs.cpe_q_ctrl[reqq]);
+        bfa_reg_write(bfa->iocfc.bfa_regs.cpe_q_ctrl[reqq], r32);
+}
+
+void
 bfa_hwct_rspq_ack(struct bfa_s *bfa, int rspq)
 {
         u32     r32;
diff --git a/drivers/scsi/bfa/bfa_intr.c b/drivers/scsi/bfa/bfa_intr.c
index 0ca125712a04..0eba3f930d5b 100644
--- a/drivers/scsi/bfa/bfa_intr.c
+++ b/drivers/scsi/bfa/bfa_intr.c
@@ -15,7 +15,7 @@
  * General Public License for more details.
  */
 #include <bfa.h>
-#include <bfi/bfi_cbreg.h>
+#include <bfi/bfi_ctreg.h>
 #include <bfa_port_priv.h>
 #include <bfa_intr_priv.h>
 #include <cs/bfa_debug.h>
@@ -34,6 +34,26 @@ bfa_msix_lpu(struct bfa_s *bfa)
         bfa_ioc_mbox_isr(&bfa->ioc);
 }
 
+static void
+bfa_reqq_resume(struct bfa_s *bfa, int qid)
+{
+        struct list_head *waitq, *qe, *qen;
+        struct bfa_reqq_wait_s *wqe;
+
+        waitq = bfa_reqq(bfa, qid);
+        list_for_each_safe(qe, qen, waitq) {
+                /**
+                 * Callback only as long as there is room in request queue
+                 */
+                if (bfa_reqq_full(bfa, qid))
+                        break;
+
+                list_del(qe);
+                wqe = (struct bfa_reqq_wait_s *) qe;
+                wqe->qresume(wqe->cbarg);
+        }
+}
+
 void
 bfa_msix_all(struct bfa_s *bfa, int vec)
 {
@@ -59,7 +79,7 @@ bfa_intx(struct bfa_s *bfa)
         qintr = intr & __HFN_INT_RME_MASK;
         bfa_reg_write(bfa->iocfc.bfa_regs.intr_status, qintr);
 
-        for (queue = 0; queue < BFI_IOC_MAX_CQS_ASIC; queue ++) {
+        for (queue = 0; queue < BFI_IOC_MAX_CQS_ASIC; queue++) {
                 if (intr & (__HFN_INT_RME_Q0 << queue))
                         bfa_msix_rspq(bfa, queue & (BFI_IOC_MAX_CQS - 1));
         }
@@ -96,7 +116,8 @@ bfa_isr_enable(struct bfa_s *bfa)
 
         bfa_msix_install(bfa);
         intr_unmask = (__HFN_INT_ERR_EMC | __HFN_INT_ERR_LPU0 |
-                       __HFN_INT_ERR_LPU1 | __HFN_INT_ERR_PSS);
+                       __HFN_INT_ERR_LPU1 | __HFN_INT_ERR_PSS |
+                       __HFN_INT_LL_HALT);
 
         if (pci_func == 0)
                 intr_unmask |= (__HFN_INT_CPE_Q0 | __HFN_INT_CPE_Q1 |
@@ -127,23 +148,18 @@ bfa_isr_disable(struct bfa_s *bfa)
 void
 bfa_msix_reqq(struct bfa_s *bfa, int qid)
 {
-        struct list_head                *waitq, *qe, *qen;
-        struct bfa_reqq_wait_s  *wqe;
+        struct list_head *waitq;
 
         qid &= (BFI_IOC_MAX_CQS - 1);
 
-        waitq = bfa_reqq(bfa, qid);
-        list_for_each_safe(qe, qen, waitq) {
-                /**
-                 * Callback only as long as there is room in request queue
-                 */
-                if (bfa_reqq_full(bfa, qid))
-                        break;
+        bfa->iocfc.hwif.hw_reqq_ack(bfa, qid);
 
-                list_del(qe);
-                wqe = (struct bfa_reqq_wait_s *) qe;
-                wqe->qresume(wqe->cbarg);
-        }
+        /**
+         * Resume any pending requests in the corresponding reqq.
+         */
+        waitq = bfa_reqq(bfa, qid);
+        if (!list_empty(waitq))
+                bfa_reqq_resume(bfa, qid);
 }
 
 void
@@ -157,26 +173,27 @@ bfa_isr_unhandled(struct bfa_s *bfa, struct bfi_msg_s *m)
 }
 
 void
-bfa_msix_rspq(struct bfa_s *bfa, int rsp_qid)
+bfa_msix_rspq(struct bfa_s *bfa, int qid)
 {
-        struct bfi_msg_s      *m;
-        u32        pi, ci;
+        struct bfi_msg_s *m;
+        u32 pi, ci;
+        struct list_head *waitq;
 
-        bfa_trc_fp(bfa, rsp_qid);
+        bfa_trc_fp(bfa, qid);
 
-        rsp_qid &= (BFI_IOC_MAX_CQS - 1);
+        qid &= (BFI_IOC_MAX_CQS - 1);
 
-        bfa->iocfc.hwif.hw_rspq_ack(bfa, rsp_qid);
+        bfa->iocfc.hwif.hw_rspq_ack(bfa, qid);
 
-        ci = bfa_rspq_ci(bfa, rsp_qid);
-        pi = bfa_rspq_pi(bfa, rsp_qid);
+        ci = bfa_rspq_ci(bfa, qid);
+        pi = bfa_rspq_pi(bfa, qid);
 
         bfa_trc_fp(bfa, ci);
         bfa_trc_fp(bfa, pi);
 
         if (bfa->rme_process) {
                 while (ci != pi) {
-                        m = bfa_rspq_elem(bfa, rsp_qid, ci);
+                        m = bfa_rspq_elem(bfa, qid, ci);
                         bfa_assert_fp(m->mhdr.msg_class < BFI_MC_MAX);
 
                         bfa_isrs[m->mhdr.msg_class] (bfa, m);
@@ -188,25 +205,59 @@ bfa_msix_rspq(struct bfa_s *bfa, int rsp_qid)
         /**
          * update CI
          */
-        bfa_rspq_ci(bfa, rsp_qid) = pi;
-        bfa_reg_write(bfa->iocfc.bfa_regs.rme_q_ci[rsp_qid], pi);
+        bfa_rspq_ci(bfa, qid) = pi;
+        bfa_reg_write(bfa->iocfc.bfa_regs.rme_q_ci[qid], pi);
         bfa_os_mmiowb();
+
+        /**
+         * Resume any pending requests in the corresponding reqq.
+         */
+        waitq = bfa_reqq(bfa, qid);
+        if (!list_empty(waitq))
+                bfa_reqq_resume(bfa, qid);
 }
 
 void
 bfa_msix_lpu_err(struct bfa_s *bfa, int vec)
 {
-        u32 intr;
+        u32 intr, curr_value;
 
         intr = bfa_reg_read(bfa->iocfc.bfa_regs.intr_status);
 
         if (intr & (__HFN_INT_MBOX_LPU0 | __HFN_INT_MBOX_LPU1))
                 bfa_msix_lpu(bfa);
 
-        if (intr & (__HFN_INT_ERR_EMC |
-                    __HFN_INT_ERR_LPU0 | __HFN_INT_ERR_LPU1 |
-                    __HFN_INT_ERR_PSS))
+        intr &= (__HFN_INT_ERR_EMC | __HFN_INT_ERR_LPU0 |
+                __HFN_INT_ERR_LPU1 | __HFN_INT_ERR_PSS | __HFN_INT_LL_HALT);
+
+        if (intr) {
+                if (intr & __HFN_INT_LL_HALT) {
+                        /**
+                         * If LL_HALT bit is set then FW Init Halt LL Port
+                         * Register needs to be cleared as well so Interrupt
+                         * Status Register will be cleared.
+                         */
+                        curr_value = bfa_reg_read(bfa->ioc.ioc_regs.ll_halt);
+                        curr_value &= ~__FW_INIT_HALT_P;
+                        bfa_reg_write(bfa->ioc.ioc_regs.ll_halt, curr_value);
+                }
+
+                if (intr & __HFN_INT_ERR_PSS) {
+                        /**
+                         * ERR_PSS bit needs to be cleared as well in case
+                         * interrups are shared so driver's interrupt handler is
+                         * still called eventhough it is already masked out.
+                         */
+                        curr_value = bfa_reg_read(
+                                bfa->ioc.ioc_regs.pss_err_status_reg);
+                        curr_value &= __PSS_ERR_STATUS_SET;
+                        bfa_reg_write(bfa->ioc.ioc_regs.pss_err_status_reg,
+                                curr_value);
+                }
+
+                bfa_reg_write(bfa->iocfc.bfa_regs.intr_status, intr);
                 bfa_msix_errint(bfa, intr);
+        }
 }
 
 void
diff --git a/drivers/scsi/bfa/bfa_intr_priv.h b/drivers/scsi/bfa/bfa_intr_priv.h
index 8ce6e6b105c8..5fc301cf4d1b 100644
--- a/drivers/scsi/bfa/bfa_intr_priv.h
+++ b/drivers/scsi/bfa/bfa_intr_priv.h
@@ -26,9 +26,9 @@ void bfa_isr_unhandled(struct bfa_s *bfa, struct bfi_msg_s *m);
 void bfa_isr_bind(enum bfi_mclass mc, bfa_isr_func_t isr_func);
 
 
-#define bfa_reqq_pi(__bfa, __reqq)      (__bfa)->iocfc.req_cq_pi[__reqq]
+#define bfa_reqq_pi(__bfa, __reqq)      ((__bfa)->iocfc.req_cq_pi[__reqq])
 #define bfa_reqq_ci(__bfa, __reqq)                                      \
-        *(u32 *)((__bfa)->iocfc.req_cq_shadow_ci[__reqq].kva)
+        (*(u32 *)((__bfa)->iocfc.req_cq_shadow_ci[__reqq].kva))
 
 #define bfa_reqq_full(__bfa, __reqq)                            \
         (((bfa_reqq_pi(__bfa, __reqq) + 1) &                    \
@@ -50,14 +50,16 @@ void bfa_isr_bind(enum bfi_mclass mc, bfa_isr_func_t isr_func);
 } while (0)
 
 #define bfa_rspq_pi(__bfa, __rspq)                                      \
-        *(u32 *)((__bfa)->iocfc.rsp_cq_shadow_pi[__rspq].kva)
+        (*(u32 *)((__bfa)->iocfc.rsp_cq_shadow_pi[__rspq].kva))
 
-#define bfa_rspq_ci(__bfa, __rspq)      (__bfa)->iocfc.rsp_cq_ci[__rspq]
+#define bfa_rspq_ci(__bfa, __rspq)      ((__bfa)->iocfc.rsp_cq_ci[__rspq])
 #define bfa_rspq_elem(__bfa, __rspq, __ci)                              \
-        &((struct bfi_msg_s *)((__bfa)->iocfc.rsp_cq_ba[__rspq].kva))[__ci]
+        (&((struct bfi_msg_s *)((__bfa)->iocfc.rsp_cq_ba[__rspq].kva))[__ci])
 
-#define CQ_INCR(__index, __size)                                        \
-                        (__index)++; (__index) &= ((__size) - 1)
+#define CQ_INCR(__index, __size) do {                                   \
+                        (__index)++;                                    \
+                        (__index) &= ((__size) - 1);      \
+} while (0)
 
 /**
  * Queue element to wait for room in request queue. FIFO order is
@@ -94,7 +96,7 @@ bfa_reqq_winit(struct bfa_reqq_wait_s *wqe, void (*qresume) (void *cbarg),
         wqe->cbarg = cbarg;
 }
 
-#define bfa_reqq(__bfa, __reqq) &(__bfa)->reqq_waitq[__reqq]
+#define bfa_reqq(__bfa, __reqq) (&(__bfa)->reqq_waitq[__reqq])
 
 /**
  * static inline void
diff --git a/drivers/scsi/bfa/bfa_ioc.c b/drivers/scsi/bfa/bfa_ioc.c
index 149348934ce3..e038bc9769f6 100644
--- a/drivers/scsi/bfa/bfa_ioc.c
+++ b/drivers/scsi/bfa/bfa_ioc.c
@@ -18,7 +18,7 @@
 #include <bfa.h>
 #include <bfa_ioc.h>
 #include <bfa_fwimg_priv.h>
-#include <bfa_trcmod_priv.h>
+#include <cna/bfa_cna_trcmod.h>
 #include <cs/bfa_debug.h>
 #include <bfi/bfi_ioc.h>
 #include <bfi/bfi_ctreg.h>
@@ -27,18 +27,17 @@
 #include <log/bfa_log_hal.h>
 #include <defs/bfa_defs_pci.h>
 
-BFA_TRC_FILE(HAL, IOC);
+BFA_TRC_FILE(CNA, IOC);
 
 /**
  * IOC local definitions
  */
 #define BFA_IOC_TOV             2000    /* msecs */
-#define BFA_IOC_HB_TOV          1000    /* msecs */
-#define BFA_IOC_HB_FAIL_MAX     4
-#define BFA_IOC_HWINIT_MAX      2
+#define BFA_IOC_HWSEM_TOV       500     /* msecs */
+#define BFA_IOC_HB_TOV          500     /* msecs */
+#define BFA_IOC_HWINIT_MAX      2
 #define BFA_IOC_FWIMG_MINSZ     (16 * 1024)
-#define BFA_IOC_TOV_RECOVER     (BFA_IOC_HB_FAIL_MAX * BFA_IOC_HB_TOV \
-                                + BFA_IOC_TOV)
+#define BFA_IOC_TOV_RECOVER      BFA_IOC_HB_TOV
 
 #define bfa_ioc_timer_start(__ioc)                                      \
         bfa_timer_begin((__ioc)->timer_mod, &(__ioc)->ioc_timer,        \
@@ -51,12 +50,25 @@ BFA_TRC_FILE(HAL, IOC);
          (sizeof(struct bfa_trc_mod_s) -                        \
           BFA_TRC_MAX * sizeof(struct bfa_trc_s)))
 #define BFA_DBG_FWTRC_OFF(_fn)  (BFI_IOC_TRC_OFF + BFA_DBG_FWTRC_LEN * (_fn))
-#define bfa_ioc_stats(_ioc, _stats)     (_ioc)->stats._stats ++
 
-#define BFA_FLASH_CHUNK_NO(off)         (off / BFI_FLASH_CHUNK_SZ_WORDS)
-#define BFA_FLASH_OFFSET_IN_CHUNK(off)  (off % BFI_FLASH_CHUNK_SZ_WORDS)
-#define BFA_FLASH_CHUNK_ADDR(chunkno)   (chunkno * BFI_FLASH_CHUNK_SZ_WORDS)
-bfa_boolean_t   bfa_auto_recover = BFA_FALSE;
+/**
+ * Asic specific macros : see bfa_hw_cb.c and bfa_hw_ct.c for details.
+ */
+
+#define bfa_ioc_firmware_lock(__ioc)                    \
+                        ((__ioc)->ioc_hwif->ioc_firmware_lock(__ioc))
+#define bfa_ioc_firmware_unlock(__ioc)                  \
+                        ((__ioc)->ioc_hwif->ioc_firmware_unlock(__ioc))
+#define bfa_ioc_fwimg_get_chunk(__ioc, __off)           \
+                        ((__ioc)->ioc_hwif->ioc_fwimg_get_chunk(__ioc, __off))
+#define bfa_ioc_fwimg_get_size(__ioc)                   \
+                        ((__ioc)->ioc_hwif->ioc_fwimg_get_size(__ioc))
+#define bfa_ioc_reg_init(__ioc) ((__ioc)->ioc_hwif->ioc_reg_init(__ioc))
+#define bfa_ioc_map_port(__ioc) ((__ioc)->ioc_hwif->ioc_map_port(__ioc))
+#define bfa_ioc_notify_hbfail(__ioc)                    \
+                        ((__ioc)->ioc_hwif->ioc_notify_hbfail(__ioc))
+
+bfa_boolean_t   bfa_auto_recover = BFA_TRUE;
 
 /*
  * forward declarations
@@ -64,7 +76,6 @@ bfa_boolean_t   bfa_auto_recover = BFA_FALSE;
 static void     bfa_ioc_aen_post(struct bfa_ioc_s *bfa,
                                  enum bfa_ioc_aen_event event);
 static void     bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc);
-static void     bfa_ioc_hw_sem_release(struct bfa_ioc_s *ioc);
 static void     bfa_ioc_hw_sem_get_cancel(struct bfa_ioc_s *ioc);
 static void     bfa_ioc_hwinit(struct bfa_ioc_s *ioc, bfa_boolean_t force);
 static void     bfa_ioc_timeout(void *ioc);
@@ -77,8 +88,6 @@ static void     bfa_ioc_reset(struct bfa_ioc_s *ioc, bfa_boolean_t force);
 static void     bfa_ioc_mbox_poll(struct bfa_ioc_s *ioc);
 static void     bfa_ioc_mbox_hbfail(struct bfa_ioc_s *ioc);
 static void     bfa_ioc_recover(struct bfa_ioc_s *ioc);
-static bfa_boolean_t bfa_ioc_firmware_lock(struct bfa_ioc_s *ioc);
-static void     bfa_ioc_firmware_unlock(struct bfa_ioc_s *ioc);
 static void     bfa_ioc_disable_comp(struct bfa_ioc_s *ioc);
 static void     bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc);
 
@@ -508,14 +517,19 @@ bfa_ioc_sm_disabling(struct bfa_ioc_s *ioc, enum ioc_event event)
         bfa_trc(ioc, event);
 
         switch (event) {
-        case IOC_E_HWERROR:
         case IOC_E_FWRSP_DISABLE:
                 bfa_ioc_timer_stop(ioc);
+                bfa_fsm_set_state(ioc, bfa_ioc_sm_disabled);
+                break;
+
+        case IOC_E_HWERROR:
+                bfa_ioc_timer_stop(ioc);
                 /*
                  * !!! fall through !!!
                  */
 
         case IOC_E_TIMEOUT:
+                bfa_reg_write(ioc->ioc_regs.ioc_fwstate, BFI_IOC_FAIL);
                 bfa_fsm_set_state(ioc, bfa_ioc_sm_disabled);
                 break;
 
@@ -608,15 +622,12 @@ bfa_ioc_sm_hbfail_entry(struct bfa_ioc_s *ioc)
          * Mark IOC as failed in hardware and stop firmware.
          */
         bfa_ioc_lpu_stop(ioc);
-        bfa_reg_write(ioc->ioc_regs.ioc_fwstate, BFI_IOC_HBFAIL);
+        bfa_reg_write(ioc->ioc_regs.ioc_fwstate, BFI_IOC_FAIL);
 
-        if (ioc->pcidev.device_id == BFA_PCI_DEVICE_ID_CT) {
-                bfa_reg_write(ioc->ioc_regs.ll_halt, __FW_INIT_HALT_P);
-                /*
-                 * Wait for halt to take effect
-                 */
-                bfa_reg_read(ioc->ioc_regs.ll_halt);
-        }
+        /**
+         * Notify other functions on HB failure.
+         */
+        bfa_ioc_notify_hbfail(ioc);
 
         /**
          * Notify driver and common modules registered for notification.
@@ -672,6 +683,12 @@ bfa_ioc_sm_hbfail(struct bfa_ioc_s *ioc, enum ioc_event event)
                  */
                 break;
 
+        case IOC_E_HWERROR:
+                /*
+                 * HB failure notification, ignore.
+                 */
+                break;
+
         default:
                 bfa_sm_fault(ioc, event);
         }
@@ -700,7 +717,7 @@ bfa_ioc_disable_comp(struct bfa_ioc_s *ioc)
         }
 }
 
-static void
+void
 bfa_ioc_sem_timeout(void *ioc_arg)
 {
         struct bfa_ioc_s *ioc = (struct bfa_ioc_s *)ioc_arg;
@@ -708,26 +725,32 @@ bfa_ioc_sem_timeout(void *ioc_arg)
         bfa_ioc_hw_sem_get(ioc);
 }
 
-static void
-bfa_ioc_usage_sem_get(struct bfa_ioc_s *ioc)
+bfa_boolean_t
+bfa_ioc_sem_get(bfa_os_addr_t sem_reg)
 {
-        u32        r32;
-        int             cnt = 0;
-#define BFA_SEM_SPINCNT 1000
+        u32 r32;
+        int cnt = 0;
+#define BFA_SEM_SPINCNT 3000
 
-        do {
-                r32 = bfa_reg_read(ioc->ioc_regs.ioc_usage_sem_reg);
+        r32 = bfa_reg_read(sem_reg);
+
+        while (r32 && (cnt < BFA_SEM_SPINCNT)) {
                 cnt++;
-                if (cnt > BFA_SEM_SPINCNT)
-                        break;
-        } while (r32 != 0);
+                bfa_os_udelay(2);
+                r32 = bfa_reg_read(sem_reg);
+        }
+
+        if (r32 == 0)
+                return BFA_TRUE;
+
         bfa_assert(cnt < BFA_SEM_SPINCNT);
+        return BFA_FALSE;
 }
 
-static void
-bfa_ioc_usage_sem_release(struct bfa_ioc_s *ioc)
+void
+bfa_ioc_sem_release(bfa_os_addr_t sem_reg)
 {
-        bfa_reg_write(ioc->ioc_regs.ioc_usage_sem_reg, 1);
+        bfa_reg_write(sem_reg, 1);
 }
 
 static void
@@ -737,7 +760,7 @@ bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc)
 
         /**
          * First read to the semaphore register will return 0, subsequent reads
-         * will return 1. Semaphore is released by writing 0 to the register
+         * will return 1. Semaphore is released by writing 1 to the register
          */
         r32 = bfa_reg_read(ioc->ioc_regs.ioc_sem_reg);
         if (r32 == 0) {
@@ -746,10 +769,10 @@ bfa_ioc_hw_sem_get(struct bfa_ioc_s *ioc)
         }
 
         bfa_timer_begin(ioc->timer_mod, &ioc->sem_timer, bfa_ioc_sem_timeout,
-                        ioc, BFA_IOC_TOV);
+                        ioc, BFA_IOC_HWSEM_TOV);
 }
 
-static void
+void
 bfa_ioc_hw_sem_release(struct bfa_ioc_s *ioc)
 {
         bfa_reg_write(ioc->ioc_regs.ioc_sem_reg, 1);
@@ -828,7 +851,7 @@ bfa_ioc_lpu_stop(struct bfa_ioc_s *ioc)
 /**
  * Get driver and firmware versions.
  */
-static void
+void
 bfa_ioc_fwver_get(struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)
 {
         u32        pgnum, pgoff;
@@ -847,24 +870,10 @@ bfa_ioc_fwver_get(struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)
         }
 }
 
-static u32 *
-bfa_ioc_fwimg_get_chunk(struct bfa_ioc_s *ioc, u32 off)
-{
-        if (ioc->ctdev)
-                return bfi_image_ct_get_chunk(off);
-        return bfi_image_cb_get_chunk(off);
-}
-
-static          u32
-bfa_ioc_fwimg_get_size(struct bfa_ioc_s *ioc)
-{
-return (ioc->ctdev) ? bfi_image_ct_size : bfi_image_cb_size;
-}
-
 /**
  * Returns TRUE if same.
  */
-static          bfa_boolean_t
+bfa_boolean_t
 bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc, struct bfi_ioc_image_hdr_s *fwhdr)
 {
         struct bfi_ioc_image_hdr_s *drv_fwhdr;
@@ -921,95 +930,6 @@ bfa_ioc_fwver_valid(struct bfa_ioc_s *ioc)
 }
 
 /**
- * Return true if firmware of current driver matches the running firmware.
- */
-static          bfa_boolean_t
-bfa_ioc_firmware_lock(struct bfa_ioc_s *ioc)
-{
-        enum bfi_ioc_state ioc_fwstate;
-        u32        usecnt;
-        struct bfi_ioc_image_hdr_s fwhdr;
-
-        /**
-         * Firmware match check is relevant only for CNA.
-         */
-        if (!ioc->cna)
-                return BFA_TRUE;
-
-        /**
-         * If bios boot (flash based) -- do not increment usage count
-         */
-        if (bfa_ioc_fwimg_get_size(ioc) < BFA_IOC_FWIMG_MINSZ)
-                return BFA_TRUE;
-
-        bfa_ioc_usage_sem_get(ioc);
-        usecnt = bfa_reg_read(ioc->ioc_regs.ioc_usage_reg);
-
-        /**
-         * If usage count is 0, always return TRUE.
-         */
-        if (usecnt == 0) {
-                bfa_reg_write(ioc->ioc_regs.ioc_usage_reg, 1);
-                bfa_ioc_usage_sem_release(ioc);
-                bfa_trc(ioc, usecnt);
-                return BFA_TRUE;
-        }
-
-        ioc_fwstate = bfa_reg_read(ioc->ioc_regs.ioc_fwstate);
-        bfa_trc(ioc, ioc_fwstate);
-
-        /**
-         * Use count cannot be non-zero and chip in uninitialized state.
-         */
-        bfa_assert(ioc_fwstate != BFI_IOC_UNINIT);
-
-        /**
-         * Check if another driver with a different firmware is active
-         */
-        bfa_ioc_fwver_get(ioc, &fwhdr);
-        if (!bfa_ioc_fwver_cmp(ioc, &fwhdr)) {
-                bfa_ioc_usage_sem_release(ioc);
-                bfa_trc(ioc, usecnt);
-                return BFA_FALSE;
-        }
-
-        /**
-         * Same firmware version. Increment the reference count.
-         */
-        usecnt++;
-        bfa_reg_write(ioc->ioc_regs.ioc_usage_reg, usecnt);
-        bfa_ioc_usage_sem_release(ioc);
-        bfa_trc(ioc, usecnt);
-        return BFA_TRUE;
-}
-
-static void
-bfa_ioc_firmware_unlock(struct bfa_ioc_s *ioc)
-{
-        u32        usecnt;
-
-        /**
-         * Firmware lock is relevant only for CNA.
-         * If bios boot (flash based) -- do not decrement usage count
-         */
-        if (!ioc->cna || (bfa_ioc_fwimg_get_size(ioc) < BFA_IOC_FWIMG_MINSZ))
-                return;
-
-        /**
-         * decrement usage count
-         */
-        bfa_ioc_usage_sem_get(ioc);
-        usecnt = bfa_reg_read(ioc->ioc_regs.ioc_usage_reg);
-        bfa_assert(usecnt > 0);
-
-        usecnt--;
-        bfa_reg_write(ioc->ioc_regs.ioc_usage_reg, usecnt);
-        bfa_trc(ioc, usecnt);
-
-        bfa_ioc_usage_sem_release(ioc);
-}
-
-/**
  * Conditionally flush any pending message from firmware at start.
  */
 static void
@@ -1152,33 +1072,27 @@ bfa_ioc_send_getattr(struct bfa_ioc_s *ioc)
 static void
 bfa_ioc_hb_check(void *cbarg)
 {
-        struct bfa_ioc_s *ioc = cbarg;
-        u32        hb_count;
+        struct bfa_ioc_s  *ioc = cbarg;
+        u32     hb_count;
 
         hb_count = bfa_reg_read(ioc->ioc_regs.heartbeat);
         if (ioc->hb_count == hb_count) {
-                ioc->hb_fail++;
-        } else {
-                ioc->hb_count = hb_count;
-                ioc->hb_fail = 0;
-        }
-
-        if (ioc->hb_fail >= BFA_IOC_HB_FAIL_MAX) {
-                bfa_log(ioc->logm, BFA_LOG_HAL_HEARTBEAT_FAILURE, hb_count);
-                ioc->hb_fail = 0;
+                bfa_log(ioc->logm, BFA_LOG_HAL_HEARTBEAT_FAILURE,
+                        hb_count);
                 bfa_ioc_recover(ioc);
                 return;
+        } else {
+                ioc->hb_count = hb_count;
         }
 
         bfa_ioc_mbox_poll(ioc);
-        bfa_timer_begin(ioc->timer_mod, &ioc->ioc_timer, bfa_ioc_hb_check, ioc,
-                        BFA_IOC_HB_TOV);
+        bfa_timer_begin(ioc->timer_mod, &ioc->ioc_timer, bfa_ioc_hb_check,
+                        ioc, BFA_IOC_HB_TOV);
 }
 
 static void
 bfa_ioc_hb_monitor(struct bfa_ioc_s *ioc)
 {
-        ioc->hb_fail = 0;
         ioc->hb_count = bfa_reg_read(ioc->ioc_regs.heartbeat);
         bfa_timer_begin(ioc->timer_mod, &ioc->ioc_timer, bfa_ioc_hb_check, ioc,
                         BFA_IOC_HB_TOV);
@@ -1191,112 +1105,6 @@ bfa_ioc_hb_stop(struct bfa_ioc_s *ioc)
 }
 
 /**
- * Host to LPU mailbox message addresses
- */
-static struct {
-        u32        hfn_mbox, lpu_mbox, hfn_pgn;
-} iocreg_fnreg[] = {
-        {
-        HOSTFN0_LPU_MBOX0_0, LPU_HOSTFN0_MBOX0_0, HOST_PAGE_NUM_FN0}, {
-        HOSTFN1_LPU_MBOX0_8, LPU_HOSTFN1_MBOX0_8, HOST_PAGE_NUM_FN1}, {
-        HOSTFN2_LPU_MBOX0_0, LPU_HOSTFN2_MBOX0_0, HOST_PAGE_NUM_FN2}, {
-        HOSTFN3_LPU_MBOX0_8, LPU_HOSTFN3_MBOX0_8, HOST_PAGE_NUM_FN3}
-};
-
-/**
- * Host <-> LPU mailbox command/status registers - port 0
- */
-static struct {
-        u32        hfn, lpu;
-} iocreg_mbcmd_p0[] = {
-        {
-        HOSTFN0_LPU0_MBOX0_CMD_STAT, LPU0_HOSTFN0_MBOX0_CMD_STAT}, {
-        HOSTFN1_LPU0_MBOX0_CMD_STAT, LPU0_HOSTFN1_MBOX0_CMD_STAT}, {
-        HOSTFN2_LPU0_MBOX0_CMD_STAT, LPU0_HOSTFN2_MBOX0_CMD_STAT}, {
-        HOSTFN3_LPU0_MBOX0_CMD_STAT, LPU0_HOSTFN3_MBOX0_CMD_STAT}
-};
-
-/**
- * Host <-> LPU mailbox command/status registers - port 1
- */
-static struct {
-        u32        hfn, lpu;
-} iocreg_mbcmd_p1[] = {
-        {
-        HOSTFN0_LPU1_MBOX0_CMD_STAT, LPU1_HOSTFN0_MBOX0_CMD_STAT}, {
-        HOSTFN1_LPU1_MBOX0_CMD_STAT, LPU1_HOSTFN1_MBOX0_CMD_STAT}, {
-        HOSTFN2_LPU1_MBOX0_CMD_STAT, LPU1_HOSTFN2_MBOX0_CMD_STAT}, {
-        HOSTFN3_LPU1_MBOX0_CMD_STAT, LPU1_HOSTFN3_MBOX0_CMD_STAT}
-};
-
-/**
- * Shared IRQ handling in INTX mode
- */
-static struct {
-        u32        isr, msk;
-} iocreg_shirq_next[] = {
-        {
-        HOSTFN1_INT_STATUS, HOSTFN1_INT_MSK}, {
-        HOSTFN2_INT_STATUS, HOSTFN2_INT_MSK}, {
-        HOSTFN3_INT_STATUS, HOSTFN3_INT_MSK}, {
-HOSTFN0_INT_STATUS, HOSTFN0_INT_MSK},};
-
-static void
-bfa_ioc_reg_init(struct bfa_ioc_s *ioc)
-{
-        bfa_os_addr_t   rb;
-        int             pcifn = bfa_ioc_pcifn(ioc);
-
-        rb = bfa_ioc_bar0(ioc);
-
-        ioc->ioc_regs.hfn_mbox = rb + iocreg_fnreg[pcifn].hfn_mbox;
-        ioc->ioc_regs.lpu_mbox = rb + iocreg_fnreg[pcifn].lpu_mbox;
-        ioc->ioc_regs.host_page_num_fn = rb + iocreg_fnreg[pcifn].hfn_pgn;
-
-        if (ioc->port_id == 0) {
-                ioc->ioc_regs.heartbeat = rb + BFA_IOC0_HBEAT_REG;
-                ioc->ioc_regs.ioc_fwstate = rb + BFA_IOC0_STATE_REG;
-                ioc->ioc_regs.hfn_mbox_cmd = rb + iocreg_mbcmd_p0[pcifn].hfn;
-                ioc->ioc_regs.lpu_mbox_cmd = rb + iocreg_mbcmd_p0[pcifn].lpu;
-                ioc->ioc_regs.ll_halt = rb + FW_INIT_HALT_P0;
-        } else {
-                ioc->ioc_regs.heartbeat = (rb + BFA_IOC1_HBEAT_REG);
-                ioc->ioc_regs.ioc_fwstate = (rb + BFA_IOC1_STATE_REG);
-                ioc->ioc_regs.hfn_mbox_cmd = rb + iocreg_mbcmd_p1[pcifn].hfn;
-                ioc->ioc_regs.lpu_mbox_cmd = rb + iocreg_mbcmd_p1[pcifn].lpu;
-                ioc->ioc_regs.ll_halt = rb + FW_INIT_HALT_P1;
-        }
-
-        /**
-         * Shared IRQ handling in INTX mode
-         */
-        ioc->ioc_regs.shirq_isr_next = rb + iocreg_shirq_next[pcifn].isr;
-        ioc->ioc_regs.shirq_msk_next = rb + iocreg_shirq_next[pcifn].msk;
-
-        /*
-         * PSS control registers
-         */
-        ioc->ioc_regs.pss_ctl_reg = (rb + PSS_CTL_REG);
-        ioc->ioc_regs.app_pll_fast_ctl_reg = (rb + APP_PLL_425_CTL_REG);
-        ioc->ioc_regs.app_pll_slow_ctl_reg = (rb + APP_PLL_312_CTL_REG);
-
-        /*
-         * IOC semaphore registers and serialization
-         */
-        ioc->ioc_regs.ioc_sem_reg = (rb + HOST_SEM0_REG);
-        ioc->ioc_regs.ioc_usage_sem_reg = (rb + HOST_SEM1_REG);
-        ioc->ioc_regs.ioc_usage_reg = (rb + BFA_FW_USE_COUNT);
-
-        /**
-         * sram memory access
-         */
-        ioc->ioc_regs.smem_page_start = (rb + PSS_SMEM_PAGE_START);
-        ioc->ioc_regs.smem_pg0 = BFI_IOC_SMEM_PG0_CB;
-        if (ioc->pcidev.device_id == BFA_PCI_DEVICE_ID_CT)
-                ioc->ioc_regs.smem_pg0 = BFI_IOC_SMEM_PG0_CT;
-}
-
-/**
  *      Initiate a full firmware download.
  */
 static void
@@ -1321,9 +1129,6 @@ bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type,
         if (bfa_ioc_fwimg_get_size(ioc) < BFA_IOC_FWIMG_MINSZ)
                 boot_type = BFI_BOOT_TYPE_FLASH;
         fwimg = bfa_ioc_fwimg_get_chunk(ioc, chunkno);
-        fwimg[BFI_BOOT_TYPE_OFF / sizeof(u32)] = bfa_os_swap32(boot_type);
-        fwimg[BFI_BOOT_PARAM_OFF / sizeof(u32)] =
-                bfa_os_swap32(boot_param);
 
         pgnum = bfa_ioc_smem_pgnum(ioc, loff);
         pgoff = bfa_ioc_smem_pgoff(ioc, loff);
@@ -1332,17 +1137,17 @@ bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type,
 
         for (i = 0; i < bfa_ioc_fwimg_get_size(ioc); i++) {
 
-                if (BFA_FLASH_CHUNK_NO(i) != chunkno) {
-                        chunkno = BFA_FLASH_CHUNK_NO(i);
+                if (BFA_IOC_FLASH_CHUNK_NO(i) != chunkno) {
+                        chunkno = BFA_IOC_FLASH_CHUNK_NO(i);
                         fwimg = bfa_ioc_fwimg_get_chunk(ioc,
-                                        BFA_FLASH_CHUNK_ADDR(chunkno));
+                                        BFA_IOC_FLASH_CHUNK_ADDR(chunkno));
                 }
 
                 /**
                  * write smem
                  */
                 bfa_mem_write(ioc->ioc_regs.smem_page_start, loff,
-                              fwimg[BFA_FLASH_OFFSET_IN_CHUNK(i)]);
+                              fwimg[BFA_IOC_FLASH_OFFSET_IN_CHUNK(i)]);
 
                 loff += sizeof(u32);
 
@@ -1358,6 +1163,14 @@ bfa_ioc_download_fw(struct bfa_ioc_s *ioc, u32 boot_type,
 
         bfa_reg_write(ioc->ioc_regs.host_page_num_fn,
                       bfa_ioc_smem_pgnum(ioc, 0));
+
+        /*
+         * Set boot type and boot param at the end.
+         */
+        bfa_mem_write(ioc->ioc_regs.smem_page_start, BFI_BOOT_TYPE_OFF,
+                        bfa_os_swap32(boot_type));
+        bfa_mem_write(ioc->ioc_regs.smem_page_start, BFI_BOOT_PARAM_OFF,
+                        bfa_os_swap32(boot_param));
 }
 
 static void
@@ -1440,168 +1253,10 @@ bfa_ioc_mbox_hbfail(struct bfa_ioc_s *ioc)
 }
 
 /**
- * Initialize IOC to port mapping.
- */
-
-#define FNC_PERS_FN_SHIFT(__fn) ((__fn) * 8)
-static void
-bfa_ioc_map_port(struct bfa_ioc_s *ioc)
-{
-        bfa_os_addr_t   rb = ioc->pcidev.pci_bar_kva;
-        u32        r32;
-
-        /**
-         * For crossbow, port id is same as pci function.
-         */
-        if (ioc->pcidev.device_id != BFA_PCI_DEVICE_ID_CT) {
-                ioc->port_id = bfa_ioc_pcifn(ioc);
-                return;
-        }
-
-        /**
-         * For catapult, base port id on personality register and IOC type
-         */
-        r32 = bfa_reg_read(rb + FNC_PERS_REG);
-        r32 >>= FNC_PERS_FN_SHIFT(bfa_ioc_pcifn(ioc));
-        ioc->port_id = (r32 & __F0_PORT_MAP_MK) >> __F0_PORT_MAP_SH;
-
-        bfa_trc(ioc, bfa_ioc_pcifn(ioc));
-        bfa_trc(ioc, ioc->port_id);
-}
-
-
-
-/**
  *  bfa_ioc_public
  */
 
 /**
-* Set interrupt mode for a function: INTX or MSIX
- */
-void
-bfa_ioc_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t msix)
-{
-        bfa_os_addr_t   rb = ioc->pcidev.pci_bar_kva;
-        u32        r32, mode;
-
-        r32 = bfa_reg_read(rb + FNC_PERS_REG);
-        bfa_trc(ioc, r32);
-
-        mode = (r32 >> FNC_PERS_FN_SHIFT(bfa_ioc_pcifn(ioc))) &
-                __F0_INTX_STATUS;
-
-        /**
-         * If already in desired mode, do not change anything
-         */
-        if (!msix && mode)
-                return;
-
-        if (msix)
-                mode = __F0_INTX_STATUS_MSIX;
-        else
-                mode = __F0_INTX_STATUS_INTA;
-
-        r32 &= ~(__F0_INTX_STATUS << FNC_PERS_FN_SHIFT(bfa_ioc_pcifn(ioc)));
-        r32 |= (mode << FNC_PERS_FN_SHIFT(bfa_ioc_pcifn(ioc)));
-        bfa_trc(ioc, r32);
-
-        bfa_reg_write(rb + FNC_PERS_REG, r32);
-}
-
-bfa_status_t
-bfa_ioc_pll_init(struct bfa_ioc_s *ioc)
-{
-        bfa_os_addr_t   rb = ioc->pcidev.pci_bar_kva;
-        u32        pll_sclk, pll_fclk, r32;
-
-        if (ioc->pcidev.device_id == BFA_PCI_DEVICE_ID_CT) {
-                pll_sclk =
-                        __APP_PLL_312_ENABLE | __APP_PLL_312_LRESETN |
-                        __APP_PLL_312_RSEL200500 | __APP_PLL_312_P0_1(0U) |
-                        __APP_PLL_312_JITLMT0_1(3U) |
-                        __APP_PLL_312_CNTLMT0_1(1U);
-                pll_fclk =
-                        __APP_PLL_425_ENABLE | __APP_PLL_425_LRESETN |
-                        __APP_PLL_425_RSEL200500 | __APP_PLL_425_P0_1(0U) |
-                        __APP_PLL_425_JITLMT0_1(3U) |
-                        __APP_PLL_425_CNTLMT0_1(1U);
-
-                /**
-                 *      For catapult, choose operational mode FC/FCoE
-                 */
-                if (ioc->fcmode) {
-                        bfa_reg_write((rb + OP_MODE), 0);
-                        bfa_reg_write((rb + ETH_MAC_SER_REG),
-                                      __APP_EMS_CMLCKSEL | __APP_EMS_REFCKBUFEN2
-                                      | __APP_EMS_CHANNEL_SEL);
-                } else {
-                        ioc->pllinit = BFA_TRUE;
-                        bfa_reg_write((rb + OP_MODE), __GLOBAL_FCOE_MODE);
-                        bfa_reg_write((rb + ETH_MAC_SER_REG),
-                                      __APP_EMS_REFCKBUFEN1);
-                }
-        } else {
-                pll_sclk =
-                        __APP_PLL_312_ENABLE | __APP_PLL_312_LRESETN |
-                        __APP_PLL_312_P0_1(3U) | __APP_PLL_312_JITLMT0_1(3U) |
-                        __APP_PLL_312_CNTLMT0_1(3U);
-                pll_fclk =
-                        __APP_PLL_425_ENABLE | __APP_PLL_425_LRESETN |
-                        __APP_PLL_425_RSEL200500 | __APP_PLL_425_P0_1(3U) |
-                        __APP_PLL_425_JITLMT0_1(3U) |
-                        __APP_PLL_425_CNTLMT0_1(3U);
-        }
-
-        bfa_reg_write((rb + BFA_IOC0_STATE_REG), BFI_IOC_UNINIT);
-        bfa_reg_write((rb + BFA_IOC1_STATE_REG), BFI_IOC_UNINIT);
-
-        bfa_reg_write((rb + HOSTFN0_INT_MSK), 0xffffffffU);
-        bfa_reg_write((rb + HOSTFN1_INT_MSK), 0xffffffffU);
-        bfa_reg_write((rb + HOSTFN0_INT_STATUS), 0xffffffffU);
-        bfa_reg_write((rb + HOSTFN1_INT_STATUS), 0xffffffffU);
-        bfa_reg_write((rb + HOSTFN0_INT_MSK), 0xffffffffU);
-        bfa_reg_write((rb + HOSTFN1_INT_MSK), 0xffffffffU);
-
-        bfa_reg_write(ioc->ioc_regs.app_pll_slow_ctl_reg,
-                      __APP_PLL_312_LOGIC_SOFT_RESET);
-        bfa_reg_write(ioc->ioc_regs.app_pll_slow_ctl_reg,
-                      __APP_PLL_312_BYPASS | __APP_PLL_312_LOGIC_SOFT_RESET);
-        bfa_reg_write(ioc->ioc_regs.app_pll_fast_ctl_reg,
-                      __APP_PLL_425_LOGIC_SOFT_RESET);
-        bfa_reg_write(ioc->ioc_regs.app_pll_fast_ctl_reg,
-                      __APP_PLL_425_BYPASS | __APP_PLL_425_LOGIC_SOFT_RESET);
-        bfa_os_udelay(2);
-        bfa_reg_write(ioc->ioc_regs.app_pll_slow_ctl_reg,
-                      __APP_PLL_312_LOGIC_SOFT_RESET);
-        bfa_reg_write(ioc->ioc_regs.app_pll_fast_ctl_reg,
-                      __APP_PLL_425_LOGIC_SOFT_RESET);
-
-        bfa_reg_write(ioc->ioc_regs.app_pll_slow_ctl_reg,
-                      pll_sclk | __APP_PLL_312_LOGIC_SOFT_RESET);
-        bfa_reg_write(ioc->ioc_regs.app_pll_fast_ctl_reg,
-                      pll_fclk | __APP_PLL_425_LOGIC_SOFT_RESET);
-
-        /**
-         * Wait for PLLs to lock.
-         */
-        bfa_os_udelay(2000);
-        bfa_reg_write((rb + HOSTFN0_INT_STATUS), 0xffffffffU);
-        bfa_reg_write((rb + HOSTFN1_INT_STATUS), 0xffffffffU);
-
-        bfa_reg_write(ioc->ioc_regs.app_pll_slow_ctl_reg, pll_sclk);
-        bfa_reg_write(ioc->ioc_regs.app_pll_fast_ctl_reg, pll_fclk);
-
-        if (ioc->pcidev.device_id == BFA_PCI_DEVICE_ID_CT) {
-                bfa_reg_write((rb + MBIST_CTL_REG), __EDRAM_BISTR_START);
-                bfa_os_udelay(1000);
-                r32 = bfa_reg_read((rb + MBIST_STAT_REG));
-                bfa_trc(ioc, r32);
-        }
-
-        return BFA_STATUS_OK;
-}
-
-/**
  * Interface used by diag module to do firmware boot with memory test
  * as the entry vector.
  */
@@ -1642,7 +1297,7 @@ bfa_ioc_boot(struct bfa_ioc_s *ioc, u32 boot_type, u32 boot_param)
 void
 bfa_ioc_auto_recover(bfa_boolean_t auto_recover)
 {
-        bfa_auto_recover = BFA_FALSE;
+        bfa_auto_recover = auto_recover;
 }
 
 
@@ -1764,6 +1419,14 @@ bfa_ioc_pci_init(struct bfa_ioc_s *ioc, struct bfa_pcidev_s *pcidev,
         ioc->ctdev = (ioc->pcidev.device_id == BFA_PCI_DEVICE_ID_CT);
         ioc->cna = ioc->ctdev && !ioc->fcmode;
 
+        /**
+         * Set asic specific interfaces. See bfa_ioc_cb.c and bfa_ioc_ct.c
+         */
+        if (ioc->ctdev)
+                bfa_ioc_set_ct_hwif(ioc);
+        else
+                bfa_ioc_set_cb_hwif(ioc);
+
         bfa_ioc_map_port(ioc);
         bfa_ioc_reg_init(ioc);
 }
@@ -1830,7 +1493,6 @@ return (auto_recover) ? BFA_DBG_FWTRC_LEN : 0;
 void
 bfa_ioc_debug_memclaim(struct bfa_ioc_s *ioc, void *dbg_fwsave)
 {
-        bfa_assert(ioc->auto_recover);
         ioc->dbg_fwsave = dbg_fwsave;
         ioc->dbg_fwsave_len = bfa_ioc_debug_trcsz(ioc->auto_recover);
 }
@@ -1953,8 +1615,8 @@ bfa_ioc_error_isr(struct bfa_ioc_s *ioc)
 bfa_boolean_t
 bfa_ioc_is_disabled(struct bfa_ioc_s *ioc)
 {
-        return (bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabling)
-                || bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled));
+        return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabling)
+                || bfa_fsm_cmp_state(ioc, bfa_ioc_sm_disabled);
 }
 
 /**
@@ -1963,9 +1625,9 @@ bfa_ioc_is_disabled(struct bfa_ioc_s *ioc)
 bfa_boolean_t
 bfa_ioc_fw_mismatch(struct bfa_ioc_s *ioc)
 {
-        return (bfa_fsm_cmp_state(ioc, bfa_ioc_sm_reset)
+        return bfa_fsm_cmp_state(ioc, bfa_ioc_sm_reset)
                 || bfa_fsm_cmp_state(ioc, bfa_ioc_sm_fwcheck)
-                || bfa_fsm_cmp_state(ioc, bfa_ioc_sm_mismatch));
+                || bfa_fsm_cmp_state(ioc, bfa_ioc_sm_mismatch);
 }
 
 #define bfa_ioc_state_disabled(__sm)            \
@@ -1973,7 +1635,7 @@ bfa_ioc_fw_mismatch(struct bfa_ioc_s *ioc)
          ((__sm) == BFI_IOC_INITING) ||         \
          ((__sm) == BFI_IOC_HWINIT) ||          \
          ((__sm) == BFI_IOC_DISABLED) ||        \
-         ((__sm) == BFI_IOC_HBFAIL) ||          \
+         ((__sm) == BFI_IOC_FAIL) ||            \
          ((__sm) == BFI_IOC_CFG_DISABLED))
 
 /**
@@ -2017,46 +1679,28 @@ bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc,
                          struct bfa_adapter_attr_s *ad_attr)
 {
         struct bfi_ioc_attr_s *ioc_attr;
-        char            model[BFA_ADAPTER_MODEL_NAME_LEN];
 
         ioc_attr = ioc->attr;
-        bfa_os_memcpy((void *)&ad_attr->serial_num,
-                      (void *)ioc_attr->brcd_serialnum,
-                      BFA_ADAPTER_SERIAL_NUM_LEN);
-
-        bfa_os_memcpy(&ad_attr->fw_ver, ioc_attr->fw_version, BFA_VERSION_LEN);
-        bfa_os_memcpy(&ad_attr->optrom_ver, ioc_attr->optrom_version,
-                      BFA_VERSION_LEN);
-        bfa_os_memcpy(&ad_attr->manufacturer, BFA_MFG_NAME,
-                      BFA_ADAPTER_MFG_NAME_LEN);
+
+        bfa_ioc_get_adapter_serial_num(ioc, ad_attr->serial_num);
+        bfa_ioc_get_adapter_fw_ver(ioc, ad_attr->fw_ver);
+        bfa_ioc_get_adapter_optrom_ver(ioc, ad_attr->optrom_ver);
+        bfa_ioc_get_adapter_manufacturer(ioc, ad_attr->manufacturer);
         bfa_os_memcpy(&ad_attr->vpd, &ioc_attr->vpd,
                       sizeof(struct bfa_mfg_vpd_s));
 
-        ad_attr->nports = BFI_ADAPTER_GETP(NPORTS, ioc_attr->adapter_prop);
-        ad_attr->max_speed = BFI_ADAPTER_GETP(SPEED, ioc_attr->adapter_prop);
+        ad_attr->nports = bfa_ioc_get_nports(ioc);
+        ad_attr->max_speed = bfa_ioc_speed_sup(ioc);
 
-        /**
-         * model name
-         */
-        if (BFI_ADAPTER_GETP(SPEED, ioc_attr->adapter_prop) == 10) {
-                strcpy(model, "BR-10?0");
-                model[5] = '0' + ad_attr->nports;
-        } else {
-                strcpy(model, "Brocade-??5");
-                model[8] =
-                        '0' + BFI_ADAPTER_GETP(SPEED, ioc_attr->adapter_prop);
-                model[9] = '0' + ad_attr->nports;
-        }
+        bfa_ioc_get_adapter_model(ioc, ad_attr->model);
+        /* For now, model descr uses same model string */
+        bfa_ioc_get_adapter_model(ioc, ad_attr->model_descr);
 
         if (BFI_ADAPTER_IS_SPECIAL(ioc_attr->adapter_prop))
                 ad_attr->prototype = 1;
         else
                 ad_attr->prototype = 0;
 
-        bfa_os_memcpy(&ad_attr->model, model, BFA_ADAPTER_MODEL_NAME_LEN);
-        bfa_os_memcpy(&ad_attr->model_descr, &ad_attr->model,
-                      BFA_ADAPTER_MODEL_NAME_LEN);
-
         ad_attr->pwwn = bfa_ioc_get_pwwn(ioc);
         ad_attr->mac = bfa_ioc_get_mac(ioc);
 
@@ -2064,41 +1708,122 @@ bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc,
         ad_attr->pcie_lanes = ioc_attr->pcie_lanes;
         ad_attr->pcie_lanes_orig = ioc_attr->pcie_lanes_orig;
         ad_attr->asic_rev = ioc_attr->asic_rev;
-        ad_attr->hw_ver[0] = 'R';
-        ad_attr->hw_ver[1] = 'e';
-        ad_attr->hw_ver[2] = 'v';
-        ad_attr->hw_ver[3] = '-';
-        ad_attr->hw_ver[4] = ioc_attr->asic_rev;
-        ad_attr->hw_ver[5] = '\0';
+
+        bfa_ioc_get_pci_chip_rev(ioc, ad_attr->hw_ver);
 
         ad_attr->cna_capable = ioc->cna;
 }
 
+enum bfa_ioc_type_e
+bfa_ioc_get_type(struct bfa_ioc_s *ioc)
+{
+        if (!ioc->ctdev || ioc->fcmode)
+                return BFA_IOC_TYPE_FC;
+        else if (ioc->ioc_mc == BFI_MC_IOCFC)
+                return BFA_IOC_TYPE_FCoE;
+        else if (ioc->ioc_mc == BFI_MC_LL)
+                return BFA_IOC_TYPE_LL;
+        else {
+                bfa_assert(ioc->ioc_mc == BFI_MC_LL);
+                return BFA_IOC_TYPE_LL;
+        }
+}
+
+void
+bfa_ioc_get_adapter_serial_num(struct bfa_ioc_s *ioc, char *serial_num)
+{
+        bfa_os_memset((void *)serial_num, 0, BFA_ADAPTER_SERIAL_NUM_LEN);
+        bfa_os_memcpy((void *)serial_num,
+                        (void *)ioc->attr->brcd_serialnum,
+                        BFA_ADAPTER_SERIAL_NUM_LEN);
+}
+
+void
+bfa_ioc_get_adapter_fw_ver(struct bfa_ioc_s *ioc, char *fw_ver)
+{
+        bfa_os_memset((void *)fw_ver, 0, BFA_VERSION_LEN);
+        bfa_os_memcpy(fw_ver, ioc->attr->fw_version, BFA_VERSION_LEN);
+}
+
+void
+bfa_ioc_get_pci_chip_rev(struct bfa_ioc_s *ioc, char *chip_rev)
+{
+        bfa_assert(chip_rev);
+
+        bfa_os_memset((void *)chip_rev, 0, BFA_IOC_CHIP_REV_LEN);
+
+        chip_rev[0] = 'R';
+        chip_rev[1] = 'e';
+        chip_rev[2] = 'v';
+        chip_rev[3] = '-';
+        chip_rev[4] = ioc->attr->asic_rev;
+        chip_rev[5] = '\0';
+}
+
+void
+bfa_ioc_get_adapter_optrom_ver(struct bfa_ioc_s *ioc, char *optrom_ver)
+{
+        bfa_os_memset((void *)optrom_ver, 0, BFA_VERSION_LEN);
+        bfa_os_memcpy(optrom_ver, ioc->attr->optrom_version,
+                BFA_VERSION_LEN);
+}
+
+void
+bfa_ioc_get_adapter_manufacturer(struct bfa_ioc_s *ioc, char *manufacturer)
+{
+        bfa_os_memset((void *)manufacturer, 0, BFA_ADAPTER_MFG_NAME_LEN);
+        bfa_os_memcpy(manufacturer, BFA_MFG_NAME, BFA_ADAPTER_MFG_NAME_LEN);
+}
+
+void
+bfa_ioc_get_adapter_model(struct bfa_ioc_s *ioc, char *model)
+{
+        struct bfi_ioc_attr_s   *ioc_attr;
+        u8              nports;
+        u8              max_speed;
+
+        bfa_assert(model);
+        bfa_os_memset((void *)model, 0, BFA_ADAPTER_MODEL_NAME_LEN);
+
+        ioc_attr = ioc->attr;
+
+        nports = bfa_ioc_get_nports(ioc);
+        max_speed = bfa_ioc_speed_sup(ioc);
+
+        /**
+         * model name
+         */
+        if (max_speed == 10) {
+                strcpy(model, "BR-10?0");
+                model[5] = '0' + nports;
+        } else {
+                strcpy(model, "Brocade-??5");
+                model[8] = '0' + max_speed;
+                model[9] = '0' + nports;
+        }
+}
+
+enum bfa_ioc_state
+bfa_ioc_get_state(struct bfa_ioc_s *ioc)
+{
+        return bfa_sm_to_state(ioc_sm_table, ioc->fsm);
+}
+
 void
 bfa_ioc_get_attr(struct bfa_ioc_s *ioc, struct bfa_ioc_attr_s *ioc_attr)
 {
         bfa_os_memset((void *)ioc_attr, 0, sizeof(struct bfa_ioc_attr_s));
 
-        ioc_attr->state = bfa_sm_to_state(ioc_sm_table, ioc->fsm);
+        ioc_attr->state = bfa_ioc_get_state(ioc);
         ioc_attr->port_id = ioc->port_id;
 
-        if (!ioc->ctdev)
-                ioc_attr->ioc_type = BFA_IOC_TYPE_FC;
-        else if (ioc->ioc_mc == BFI_MC_IOCFC)
-                ioc_attr->ioc_type = BFA_IOC_TYPE_FCoE;
-        else if (ioc->ioc_mc == BFI_MC_LL)
-                ioc_attr->ioc_type = BFA_IOC_TYPE_LL;
+        ioc_attr->ioc_type = bfa_ioc_get_type(ioc);
 
         bfa_ioc_get_adapter_attr(ioc, &ioc_attr->adapter_attr);
 
         ioc_attr->pci_attr.device_id = ioc->pcidev.device_id;
         ioc_attr->pci_attr.pcifn = ioc->pcidev.pci_func;
-        ioc_attr->pci_attr.chip_rev[0] = 'R';
-        ioc_attr->pci_attr.chip_rev[1] = 'e';
-        ioc_attr->pci_attr.chip_rev[2] = 'v';
-        ioc_attr->pci_attr.chip_rev[3] = '-';
-        ioc_attr->pci_attr.chip_rev[4] = ioc_attr->adapter_attr.asic_rev;
-        ioc_attr->pci_attr.chip_rev[5] = '\0';
+        bfa_ioc_get_pci_chip_rev(ioc, ioc_attr->pci_attr.chip_rev);
 }
 
 /**
@@ -2195,29 +1920,6 @@ bfa_ioc_get_fcmode(struct bfa_ioc_s *ioc)
 }
 
 /**
- * Return true if interrupt should be claimed.
- */
-bfa_boolean_t
-bfa_ioc_intx_claim(struct bfa_ioc_s *ioc)
-{
-        u32        isr, msk;
-
-        /**
-         * Always claim if not catapult.
-         */
-        if (!ioc->ctdev)
-                return BFA_TRUE;
-
-        /**
-         * FALSE if next device is claiming interrupt.
-         * TRUE if next device is not interrupting or not present.
-         */
-        msk = bfa_reg_read(ioc->ioc_regs.shirq_msk_next);
-        isr = bfa_reg_read(ioc->ioc_regs.shirq_isr_next);
-        return !(isr & ~msk);
-}
-
-/**
  * Send AEN notification
  */
 static void
@@ -2226,32 +1928,14 @@ bfa_ioc_aen_post(struct bfa_ioc_s *ioc, enum bfa_ioc_aen_event event)
         union bfa_aen_data_u aen_data;
         struct bfa_log_mod_s *logmod = ioc->logm;
         s32         inst_num = 0;
-        struct bfa_ioc_attr_s ioc_attr;
+        enum bfa_ioc_type_e ioc_type;
 
-        switch (event) {
-        case BFA_IOC_AEN_HBGOOD:
-                bfa_log(logmod, BFA_AEN_IOC_HBGOOD, inst_num);
-                break;
-        case BFA_IOC_AEN_HBFAIL:
-                bfa_log(logmod, BFA_AEN_IOC_HBFAIL, inst_num);
-                break;
-        case BFA_IOC_AEN_ENABLE:
-                bfa_log(logmod, BFA_AEN_IOC_ENABLE, inst_num);
-                break;
-        case BFA_IOC_AEN_DISABLE:
-                bfa_log(logmod, BFA_AEN_IOC_DISABLE, inst_num);
-                break;
-        case BFA_IOC_AEN_FWMISMATCH:
-                bfa_log(logmod, BFA_AEN_IOC_FWMISMATCH, inst_num);
-                break;
-        default:
-                break;
-        }
+        bfa_log(logmod, BFA_LOG_CREATE_ID(BFA_AEN_CAT_IOC, event), inst_num);
 
         memset(&aen_data.ioc.pwwn, 0, sizeof(aen_data.ioc.pwwn));
         memset(&aen_data.ioc.mac, 0, sizeof(aen_data.ioc.mac));
-        bfa_ioc_get_attr(ioc, &ioc_attr);
-        switch (ioc_attr.ioc_type) {
+        ioc_type = bfa_ioc_get_type(ioc);
+        switch (ioc_type) {
         case BFA_IOC_TYPE_FC:
                 aen_data.ioc.pwwn = bfa_ioc_get_pwwn(ioc);
                 break;
@@ -2263,10 +1947,10 @@ bfa_ioc_aen_post(struct bfa_ioc_s *ioc, enum bfa_ioc_aen_event event)
                 aen_data.ioc.mac = bfa_ioc_get_mac(ioc);
                 break;
         default:
-                bfa_assert(ioc_attr.ioc_type == BFA_IOC_TYPE_FC);
+                bfa_assert(ioc_type == BFA_IOC_TYPE_FC);
                 break;
         }
-        aen_data.ioc.ioc_type = ioc_attr.ioc_type;
+        aen_data.ioc.ioc_type = ioc_type;
 }
 
 /**
@@ -2290,6 +1974,15 @@ bfa_ioc_debug_fwsave(struct bfa_ioc_s *ioc, void *trcdata, int *trclen)
 }
 
 /**
+ * Clear saved firmware trace
+ */
+void
+bfa_ioc_debug_fwsave_clear(struct bfa_ioc_s *ioc)
+{
+        ioc->dbg_fwsave_once = BFA_TRUE;
+}
+
+/**
  * Retrieve saved firmware trace from a prior IOC failure.
  */
 bfa_status_t
@@ -2304,6 +1997,13 @@ bfa_ioc_debug_fwtrc(struct bfa_ioc_s *ioc, void *trcdata, int *trclen)
 
         pgnum = bfa_ioc_smem_pgnum(ioc, loff);
         loff = bfa_ioc_smem_pgoff(ioc, loff);
+
+        /*
+         *  Hold semaphore to serialize pll init and fwtrc.
+         */
+        if (BFA_FALSE == bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg))
+                return BFA_STATUS_FAILED;
+
         bfa_reg_write(ioc->ioc_regs.host_page_num_fn, pgnum);
 
         tlen = *trclen;
@@ -2329,6 +2029,12 @@ bfa_ioc_debug_fwtrc(struct bfa_ioc_s *ioc, void *trcdata, int *trclen)
         }
         bfa_reg_write(ioc->ioc_regs.host_page_num_fn,
                       bfa_ioc_smem_pgnum(ioc, 0));
+
+        /*
+         *  release semaphore.
+         */
+        bfa_ioc_sem_release(ioc->ioc_regs.ioc_init_sem_reg);
+
         bfa_trc(ioc, pgnum);
 
         *trclen = tlen * sizeof(u32);
diff --git a/drivers/scsi/bfa/bfa_ioc.h b/drivers/scsi/bfa/bfa_ioc.h
index 58efd4b13143..d0804406ea1a 100644
--- a/drivers/scsi/bfa/bfa_ioc.h
+++ b/drivers/scsi/bfa/bfa_ioc.h
@@ -74,15 +74,18 @@ struct bfa_ioc_regs_s {
         bfa_os_addr_t   lpu_mbox_cmd;
         bfa_os_addr_t   lpu_mbox;
         bfa_os_addr_t   pss_ctl_reg;
+        bfa_os_addr_t   pss_err_status_reg;
         bfa_os_addr_t   app_pll_fast_ctl_reg;
         bfa_os_addr_t   app_pll_slow_ctl_reg;
         bfa_os_addr_t   ioc_sem_reg;
         bfa_os_addr_t   ioc_usage_sem_reg;
+        bfa_os_addr_t   ioc_init_sem_reg;
         bfa_os_addr_t   ioc_usage_reg;
         bfa_os_addr_t   host_page_num_fn;
         bfa_os_addr_t   heartbeat;
         bfa_os_addr_t   ioc_fwstate;
         bfa_os_addr_t   ll_halt;
+        bfa_os_addr_t   err_set;
         bfa_os_addr_t   shirq_isr_next;
         bfa_os_addr_t   shirq_msk_next;
         bfa_os_addr_t   smem_page_start;
@@ -154,7 +157,6 @@ struct bfa_ioc_s {
         struct bfa_timer_s      ioc_timer;
         struct bfa_timer_s      sem_timer;
         u32             hb_count;
-        u32             hb_fail;
         u32             retry_count;
         struct list_head                hb_notify_q;
         void                    *dbg_fwsave;
@@ -177,20 +179,45 @@ struct bfa_ioc_s {
         struct bfi_ioc_attr_s   *attr;
         struct bfa_ioc_cbfn_s   *cbfn;
         struct bfa_ioc_mbox_mod_s mbox_mod;
+        struct bfa_ioc_hwif_s   *ioc_hwif;
 };
 
-#define bfa_ioc_pcifn(__ioc)            (__ioc)->pcidev.pci_func
-#define bfa_ioc_devid(__ioc)            (__ioc)->pcidev.device_id
-#define bfa_ioc_bar0(__ioc)             (__ioc)->pcidev.pci_bar_kva
+struct bfa_ioc_hwif_s {
+        bfa_status_t    (*ioc_pll_init) (struct bfa_ioc_s *ioc);
+        bfa_boolean_t   (*ioc_firmware_lock)    (struct bfa_ioc_s *ioc);
+        void            (*ioc_firmware_unlock)  (struct bfa_ioc_s *ioc);
+        u32 *           (*ioc_fwimg_get_chunk)  (struct bfa_ioc_s *ioc,
+                                                u32 off);
+        u32             (*ioc_fwimg_get_size)   (struct bfa_ioc_s *ioc);
+        void            (*ioc_reg_init) (struct bfa_ioc_s *ioc);
+        void            (*ioc_map_port) (struct bfa_ioc_s *ioc);
+        void            (*ioc_isr_mode_set)     (struct bfa_ioc_s *ioc,
+                                                bfa_boolean_t msix);
+        void            (*ioc_notify_hbfail)    (struct bfa_ioc_s *ioc);
+        void            (*ioc_ownership_reset)  (struct bfa_ioc_s *ioc);
+};
+
+#define bfa_ioc_pcifn(__ioc)            ((__ioc)->pcidev.pci_func)
+#define bfa_ioc_devid(__ioc)            ((__ioc)->pcidev.device_id)
+#define bfa_ioc_bar0(__ioc)             ((__ioc)->pcidev.pci_bar_kva)
 #define bfa_ioc_portid(__ioc)           ((__ioc)->port_id)
 #define bfa_ioc_fetch_stats(__ioc, __stats) \
-                ((__stats)->drv_stats) = (__ioc)->stats
+                (((__stats)->drv_stats) = (__ioc)->stats)
 #define bfa_ioc_clr_stats(__ioc)        \
                 bfa_os_memset(&(__ioc)->stats, 0, sizeof((__ioc)->stats))
-#define bfa_ioc_maxfrsize(__ioc)        (__ioc)->attr->maxfrsize
-#define bfa_ioc_rx_bbcredit(__ioc)      (__ioc)->attr->rx_bbcredit
+#define bfa_ioc_maxfrsize(__ioc)        ((__ioc)->attr->maxfrsize)
+#define bfa_ioc_rx_bbcredit(__ioc)      ((__ioc)->attr->rx_bbcredit)
 #define bfa_ioc_speed_sup(__ioc)        \
         BFI_ADAPTER_GETP(SPEED, (__ioc)->attr->adapter_prop)
+#define bfa_ioc_get_nports(__ioc)       \
+        BFI_ADAPTER_GETP(NPORTS, (__ioc)->attr->adapter_prop)
+
+#define bfa_ioc_stats(_ioc, _stats)     ((_ioc)->stats._stats++)
+#define BFA_IOC_FWIMG_MINSZ     (16 * 1024)
+
+#define BFA_IOC_FLASH_CHUNK_NO(off)             (off / BFI_FLASH_CHUNK_SZ_WORDS)
+#define BFA_IOC_FLASH_OFFSET_IN_CHUNK(off)      (off % BFI_FLASH_CHUNK_SZ_WORDS)
+#define BFA_IOC_FLASH_CHUNK_ADDR(chunkno)  (chunkno * BFI_FLASH_CHUNK_SZ_WORDS)
 
 /**
  * IOC mailbox interface
@@ -207,6 +234,14 @@ void bfa_ioc_mbox_regisr(struct bfa_ioc_s *ioc, enum bfi_mclass mc,
 /**
  * IOC interfaces
  */
+#define bfa_ioc_pll_init(__ioc) ((__ioc)->ioc_hwif->ioc_pll_init(__ioc))
+#define bfa_ioc_isr_mode_set(__ioc, __msix)                     \
+                        ((__ioc)->ioc_hwif->ioc_isr_mode_set(__ioc, __msix))
+#define bfa_ioc_ownership_reset(__ioc)                          \
+                        ((__ioc)->ioc_hwif->ioc_ownership_reset(__ioc))
+
+void bfa_ioc_set_ct_hwif(struct bfa_ioc_s *ioc);
+void bfa_ioc_set_cb_hwif(struct bfa_ioc_s *ioc);
 void bfa_ioc_attach(struct bfa_ioc_s *ioc, void *bfa,
                 struct bfa_ioc_cbfn_s *cbfn, struct bfa_timer_mod_s *timer_mod,
                 struct bfa_trc_mod_s *trcmod,
@@ -223,13 +258,21 @@ bfa_boolean_t bfa_ioc_intx_claim(struct bfa_ioc_s *ioc);
 void bfa_ioc_boot(struct bfa_ioc_s *ioc, u32 boot_type, u32 boot_param);
 void bfa_ioc_isr(struct bfa_ioc_s *ioc, struct bfi_mbmsg_s *msg);
 void bfa_ioc_error_isr(struct bfa_ioc_s *ioc);
-void bfa_ioc_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t intx);
-bfa_status_t bfa_ioc_pll_init(struct bfa_ioc_s *ioc);
 bfa_boolean_t bfa_ioc_is_operational(struct bfa_ioc_s *ioc);
 bfa_boolean_t bfa_ioc_is_disabled(struct bfa_ioc_s *ioc);
 bfa_boolean_t bfa_ioc_fw_mismatch(struct bfa_ioc_s *ioc);
 bfa_boolean_t bfa_ioc_adapter_is_disabled(struct bfa_ioc_s *ioc);
 void bfa_ioc_cfg_complete(struct bfa_ioc_s *ioc);
+enum bfa_ioc_type_e bfa_ioc_get_type(struct bfa_ioc_s *ioc);
+void bfa_ioc_get_adapter_serial_num(struct bfa_ioc_s *ioc, char *serial_num);
+void bfa_ioc_get_adapter_fw_ver(struct bfa_ioc_s *ioc, char *fw_ver);
+void bfa_ioc_get_adapter_optrom_ver(struct bfa_ioc_s *ioc, char *optrom_ver);
+void bfa_ioc_get_adapter_model(struct bfa_ioc_s *ioc, char *model);
+void bfa_ioc_get_adapter_manufacturer(struct bfa_ioc_s *ioc,
+        char *manufacturer);
+void bfa_ioc_get_pci_chip_rev(struct bfa_ioc_s *ioc, char *chip_rev);
+enum bfa_ioc_state bfa_ioc_get_state(struct bfa_ioc_s *ioc);
+
 void bfa_ioc_get_attr(struct bfa_ioc_s *ioc, struct bfa_ioc_attr_s *ioc_attr);
 void bfa_ioc_get_adapter_attr(struct bfa_ioc_s *ioc,
                 struct bfa_adapter_attr_s *ad_attr);
@@ -237,6 +280,7 @@ int bfa_ioc_debug_trcsz(bfa_boolean_t auto_recover);
 void bfa_ioc_debug_memclaim(struct bfa_ioc_s *ioc, void *dbg_fwsave);
 bfa_status_t bfa_ioc_debug_fwsave(struct bfa_ioc_s *ioc, void *trcdata,
                 int *trclen);
+void bfa_ioc_debug_fwsave_clear(struct bfa_ioc_s *ioc);
 bfa_status_t bfa_ioc_debug_fwtrc(struct bfa_ioc_s *ioc, void *trcdata,
                                  int *trclen);
 u32 bfa_ioc_smem_pgnum(struct bfa_ioc_s *ioc, u32 fmaddr);
@@ -245,6 +289,13 @@ void bfa_ioc_set_fcmode(struct bfa_ioc_s *ioc);
 bfa_boolean_t bfa_ioc_get_fcmode(struct bfa_ioc_s *ioc);
 void bfa_ioc_hbfail_register(struct bfa_ioc_s *ioc,
         struct bfa_ioc_hbfail_notify_s *notify);
+bfa_boolean_t bfa_ioc_sem_get(bfa_os_addr_t sem_reg);
+void bfa_ioc_sem_release(bfa_os_addr_t sem_reg);
+void bfa_ioc_hw_sem_release(struct bfa_ioc_s *ioc);
+void bfa_ioc_fwver_get(struct bfa_ioc_s *ioc,
+                        struct bfi_ioc_image_hdr_s *fwhdr);
+bfa_boolean_t bfa_ioc_fwver_cmp(struct bfa_ioc_s *ioc,
+                        struct bfi_ioc_image_hdr_s *fwhdr);
 
 /*
  * bfa mfg wwn API functions
diff --git a/drivers/scsi/bfa/bfa_ioc_cb.c b/drivers/scsi/bfa/bfa_ioc_cb.c
new file mode 100644
index 000000000000..3ce85319f739
--- /dev/null
+++ b/drivers/scsi/bfa/bfa_ioc_cb.c
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
+ * All rights reserved
+ * www.brocade.com
+ *
+ * Linux driver for Brocade Fibre Channel Host Bus Adapter.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License (GPL) Version 2 as
+ * published by the Free Software Foundation
+ *
+ * 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 <bfa.h>
+#include <bfa_ioc.h>
+#include <bfa_fwimg_priv.h>
+#include <cna/bfa_cna_trcmod.h>
+#include <cs/bfa_debug.h>
+#include <bfi/bfi_ioc.h>
+#include <bfi/bfi_cbreg.h>
+#include <log/bfa_log_hal.h>
+#include <defs/bfa_defs_pci.h>
+
+BFA_TRC_FILE(CNA, IOC_CB);
+
+/*
+ * forward declarations
+ */
+static bfa_status_t bfa_ioc_cb_pll_init(struct bfa_ioc_s *ioc);
+static bfa_boolean_t bfa_ioc_cb_firmware_lock(struct bfa_ioc_s *ioc);
+static void bfa_ioc_cb_firmware_unlock(struct bfa_ioc_s *ioc);
+static u32  *bfa_ioc_cb_fwimg_get_chunk(struct bfa_ioc_s *ioc, u32 off);
+static u32 bfa_ioc_cb_fwimg_get_size(struct bfa_ioc_s *ioc);
+static void bfa_ioc_cb_reg_init(struct bfa_ioc_s *ioc);
+static void bfa_ioc_cb_map_port(struct bfa_ioc_s *ioc);
+static void bfa_ioc_cb_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t msix);
+static void bfa_ioc_cb_notify_hbfail(struct bfa_ioc_s *ioc);
+static void bfa_ioc_cb_ownership_reset(struct bfa_ioc_s *ioc);
+
+struct bfa_ioc_hwif_s hwif_cb = {
+        bfa_ioc_cb_pll_init,
+        bfa_ioc_cb_firmware_lock,
+        bfa_ioc_cb_firmware_unlock,
+        bfa_ioc_cb_fwimg_get_chunk,
+        bfa_ioc_cb_fwimg_get_size,
+        bfa_ioc_cb_reg_init,
+        bfa_ioc_cb_map_port,
+        bfa_ioc_cb_isr_mode_set,
+        bfa_ioc_cb_notify_hbfail,
+        bfa_ioc_cb_ownership_reset,
+};
+
+/**
+ * Called from bfa_ioc_attach() to map asic specific calls.
+ */
+void
+bfa_ioc_set_cb_hwif(struct bfa_ioc_s *ioc)
+{
+        ioc->ioc_hwif = &hwif_cb;
+}
+
+static u32 *
+bfa_ioc_cb_fwimg_get_chunk(struct bfa_ioc_s *ioc, u32 off)
+{
+        return bfi_image_cb_get_chunk(off);
+}
+
+static u32
+bfa_ioc_cb_fwimg_get_size(struct bfa_ioc_s *ioc)
+{
+        return bfi_image_cb_size;
+}
+
+/**
+ * Return true if firmware of current driver matches the running firmware.
+ */
+static bfa_boolean_t
+bfa_ioc_cb_firmware_lock(struct bfa_ioc_s *ioc)
+{
+        return BFA_TRUE;
+}
+
+static void
+bfa_ioc_cb_firmware_unlock(struct bfa_ioc_s *ioc)
+{
+}
+
+/**
+ * Notify other functions on HB failure.
+ */
+static void
+bfa_ioc_cb_notify_hbfail(struct bfa_ioc_s *ioc)
+{
+        bfa_reg_write(ioc->ioc_regs.err_set, __PSS_ERR_STATUS_SET);
+        bfa_reg_read(ioc->ioc_regs.err_set);
+}
+
+/**
+ * Host to LPU mailbox message addresses
+ */
+static struct { u32 hfn_mbox, lpu_mbox, hfn_pgn; } iocreg_fnreg[] = {
+        { HOSTFN0_LPU_MBOX0_0, LPU_HOSTFN0_MBOX0_0, HOST_PAGE_NUM_FN0 },
+        { HOSTFN1_LPU_MBOX0_8, LPU_HOSTFN1_MBOX0_8, HOST_PAGE_NUM_FN1 }
+};
+
+/**
+ * Host <-> LPU mailbox command/status registers
+ */
+static struct { u32 hfn, lpu; } iocreg_mbcmd[] = {
+        { HOSTFN0_LPU0_CMD_STAT, LPU0_HOSTFN0_CMD_STAT },
+        { HOSTFN1_LPU1_CMD_STAT, LPU1_HOSTFN1_CMD_STAT }
+};
+
+static void
+bfa_ioc_cb_reg_init(struct bfa_ioc_s *ioc)
+{
+        bfa_os_addr_t   rb;
+        int             pcifn = bfa_ioc_pcifn(ioc);
+
+        rb = bfa_ioc_bar0(ioc);
+
+        ioc->ioc_regs.hfn_mbox = rb + iocreg_fnreg[pcifn].hfn_mbox;
+        ioc->ioc_regs.lpu_mbox = rb + iocreg_fnreg[pcifn].lpu_mbox;
+        ioc->ioc_regs.host_page_num_fn = rb + iocreg_fnreg[pcifn].hfn_pgn;
+
+        if (ioc->port_id == 0) {
+                ioc->ioc_regs.heartbeat = rb + BFA_IOC0_HBEAT_REG;
+                ioc->ioc_regs.ioc_fwstate = rb + BFA_IOC0_STATE_REG;
+        } else {
+                ioc->ioc_regs.heartbeat = (rb + BFA_IOC1_HBEAT_REG);
+                ioc->ioc_regs.ioc_fwstate = (rb + BFA_IOC1_STATE_REG);
+        }
+
+        /**
+         * Host <-> LPU mailbox command/status registers
+         */
+        ioc->ioc_regs.hfn_mbox_cmd = rb + iocreg_mbcmd[pcifn].hfn;
+        ioc->ioc_regs.lpu_mbox_cmd = rb + iocreg_mbcmd[pcifn].lpu;
+
+        /*
+         * PSS control registers
+         */
+        ioc->ioc_regs.pss_ctl_reg = (rb + PSS_CTL_REG);
+        ioc->ioc_regs.pss_err_status_reg = (rb + PSS_ERR_STATUS_REG);
+        ioc->ioc_regs.app_pll_fast_ctl_reg = (rb + APP_PLL_400_CTL_REG);
+        ioc->ioc_regs.app_pll_slow_ctl_reg = (rb + APP_PLL_212_CTL_REG);
+
+        /*
+         * IOC semaphore registers and serialization
+         */
+        ioc->ioc_regs.ioc_sem_reg = (rb + HOST_SEM0_REG);
+        ioc->ioc_regs.ioc_init_sem_reg = (rb + HOST_SEM2_REG);
+
+        /**
+         * sram memory access
+         */
+        ioc->ioc_regs.smem_page_start = (rb + PSS_SMEM_PAGE_START);
+        ioc->ioc_regs.smem_pg0 = BFI_IOC_SMEM_PG0_CB;
+
+        /*
+         * err set reg : for notification of hb failure
+         */
+        ioc->ioc_regs.err_set = (rb + ERR_SET_REG);
+}
+
+/**
+ * Initialize IOC to port mapping.
+ */
+static void
+bfa_ioc_cb_map_port(struct bfa_ioc_s *ioc)
+{
+        /**
+         * For crossbow, port id is same as pci function.
+         */
+        ioc->port_id = bfa_ioc_pcifn(ioc);
+        bfa_trc(ioc, ioc->port_id);
+}
+
+/**
+ * Set interrupt mode for a function: INTX or MSIX
+ */
+static void
+bfa_ioc_cb_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t msix)
+{
+}
+
+static bfa_status_t
+bfa_ioc_cb_pll_init(struct bfa_ioc_s *ioc)
+{
+        bfa_os_addr_t   rb = ioc->pcidev.pci_bar_kva;
+        u32     pll_sclk, pll_fclk;
+
+        /*
+         *  Hold semaphore so that nobody can access the chip during init.
+         */
+        bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg);
+
+        pll_sclk = __APP_PLL_212_ENABLE | __APP_PLL_212_LRESETN |
+                        __APP_PLL_212_P0_1(3U) |
+                        __APP_PLL_212_JITLMT0_1(3U) |
+                        __APP_PLL_212_CNTLMT0_1(3U);
+        pll_fclk = __APP_PLL_400_ENABLE | __APP_PLL_400_LRESETN |
+                        __APP_PLL_400_RSEL200500 | __APP_PLL_400_P0_1(3U) |
+                        __APP_PLL_400_JITLMT0_1(3U) |
+                        __APP_PLL_400_CNTLMT0_1(3U);
+
+        bfa_reg_write((rb + BFA_IOC0_STATE_REG), BFI_IOC_UNINIT);
+        bfa_reg_write((rb + BFA_IOC1_STATE_REG), BFI_IOC_UNINIT);
+
+        bfa_reg_write((rb + HOSTFN0_INT_MSK), 0xffffffffU);
+        bfa_reg_write((rb + HOSTFN1_INT_MSK), 0xffffffffU);
+        bfa_reg_write((rb + HOSTFN0_INT_STATUS), 0xffffffffU);
+        bfa_reg_write((rb + HOSTFN1_INT_STATUS), 0xffffffffU);
+        bfa_reg_write((rb + HOSTFN0_INT_MSK), 0xffffffffU);
+        bfa_reg_write((rb + HOSTFN1_INT_MSK), 0xffffffffU);
+
+        bfa_reg_write(ioc->ioc_regs.app_pll_slow_ctl_reg,
+                        __APP_PLL_212_LOGIC_SOFT_RESET);
+        bfa_reg_write(ioc->ioc_regs.app_pll_slow_ctl_reg,
+                        __APP_PLL_212_BYPASS |
+                        __APP_PLL_212_LOGIC_SOFT_RESET);
+        bfa_reg_write(ioc->ioc_regs.app_pll_fast_ctl_reg,
+                        __APP_PLL_400_LOGIC_SOFT_RESET);
+        bfa_reg_write(ioc->ioc_regs.app_pll_fast_ctl_reg,
+                        __APP_PLL_400_BYPASS |
+                        __APP_PLL_400_LOGIC_SOFT_RESET);
+        bfa_os_udelay(2);
+        bfa_reg_write(ioc->ioc_regs.app_pll_slow_ctl_reg,
+                        __APP_PLL_212_LOGIC_SOFT_RESET);
+        bfa_reg_write(ioc->ioc_regs.app_pll_fast_ctl_reg,
+                        __APP_PLL_400_LOGIC_SOFT_RESET);
+
+        bfa_reg_write(ioc->ioc_regs.app_pll_slow_ctl_reg,
+                        pll_sclk | __APP_PLL_212_LOGIC_SOFT_RESET);
+        bfa_reg_write(ioc->ioc_regs.app_pll_fast_ctl_reg,
+                        pll_fclk | __APP_PLL_400_LOGIC_SOFT_RESET);
+
+        /**
+         * Wait for PLLs to lock.
+         */
+        bfa_os_udelay(2000);
+        bfa_reg_write((rb + HOSTFN0_INT_STATUS), 0xffffffffU);
+        bfa_reg_write((rb + HOSTFN1_INT_STATUS), 0xffffffffU);
+
+        bfa_reg_write(ioc->ioc_regs.app_pll_slow_ctl_reg, pll_sclk);
+        bfa_reg_write(ioc->ioc_regs.app_pll_fast_ctl_reg, pll_fclk);
+
+        /*
+         *  release semaphore.
+         */
+        bfa_ioc_sem_release(ioc->ioc_regs.ioc_init_sem_reg);
+
+        return BFA_STATUS_OK;
+}
+
+/**
+ * Cleanup hw semaphore and usecnt registers
+ */
+static void
+bfa_ioc_cb_ownership_reset(struct bfa_ioc_s *ioc)
+{
+
+        /*
+         * Read the hw sem reg to make sure that it is locked
+         * before we clear it. If it is not locked, writing 1
+         * will lock it instead of clearing it.
+         */
+        bfa_reg_read(ioc->ioc_regs.ioc_sem_reg);
+        bfa_ioc_hw_sem_release(ioc);
+}
diff --git a/drivers/scsi/bfa/bfa_ioc_ct.c b/drivers/scsi/bfa/bfa_ioc_ct.c
new file mode 100644
index 000000000000..20b58ad5f95c
--- /dev/null
+++ b/drivers/scsi/bfa/bfa_ioc_ct.c
@@ -0,0 +1,423 @@
+/*
+ * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
+ * All rights reserved
+ * www.brocade.com
+ *
+ * Linux driver for Brocade Fibre Channel Host Bus Adapter.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License (GPL) Version 2 as
+ * published by the Free Software Foundation
+ *
+ * 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 <bfa.h>
+#include <bfa_ioc.h>
+#include <bfa_fwimg_priv.h>
+#include <cna/bfa_cna_trcmod.h>
+#include <cs/bfa_debug.h>
+#include <bfi/bfi_ioc.h>
+#include <bfi/bfi_ctreg.h>
+#include <log/bfa_log_hal.h>
+#include <defs/bfa_defs_pci.h>
+
+BFA_TRC_FILE(CNA, IOC_CT);
+
+/*
+ * forward declarations
+ */
+static bfa_status_t bfa_ioc_ct_pll_init(struct bfa_ioc_s *ioc);
+static bfa_boolean_t bfa_ioc_ct_firmware_lock(struct bfa_ioc_s *ioc);
+static void bfa_ioc_ct_firmware_unlock(struct bfa_ioc_s *ioc);
+static u32* bfa_ioc_ct_fwimg_get_chunk(struct bfa_ioc_s *ioc,
+                                        u32 off);
+static u32 bfa_ioc_ct_fwimg_get_size(struct bfa_ioc_s *ioc);
+static void bfa_ioc_ct_reg_init(struct bfa_ioc_s *ioc);
+static void bfa_ioc_ct_map_port(struct bfa_ioc_s *ioc);
+static void bfa_ioc_ct_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t msix);
+static void bfa_ioc_ct_notify_hbfail(struct bfa_ioc_s *ioc);
+static void bfa_ioc_ct_ownership_reset(struct bfa_ioc_s *ioc);
+
+struct bfa_ioc_hwif_s hwif_ct = {
+        bfa_ioc_ct_pll_init,
+        bfa_ioc_ct_firmware_lock,
+        bfa_ioc_ct_firmware_unlock,
+        bfa_ioc_ct_fwimg_get_chunk,
+        bfa_ioc_ct_fwimg_get_size,
+        bfa_ioc_ct_reg_init,
+        bfa_ioc_ct_map_port,
+        bfa_ioc_ct_isr_mode_set,
+        bfa_ioc_ct_notify_hbfail,
+        bfa_ioc_ct_ownership_reset,
+};
+
+/**
+ * Called from bfa_ioc_attach() to map asic specific calls.
+ */
+void
+bfa_ioc_set_ct_hwif(struct bfa_ioc_s *ioc)
+{
+        ioc->ioc_hwif = &hwif_ct;
+}
+
+static u32*
+bfa_ioc_ct_fwimg_get_chunk(struct bfa_ioc_s *ioc, u32 off)
+{
+        return bfi_image_ct_get_chunk(off);
+}
+
+static u32
+bfa_ioc_ct_fwimg_get_size(struct bfa_ioc_s *ioc)
+{
+        return bfi_image_ct_size;
+}
+
+/**
+ * Return true if firmware of current driver matches the running firmware.
+ */
+static bfa_boolean_t
+bfa_ioc_ct_firmware_lock(struct bfa_ioc_s *ioc)
+{
+        enum bfi_ioc_state ioc_fwstate;
+        u32 usecnt;
+        struct bfi_ioc_image_hdr_s fwhdr;
+
+        /**
+         * Firmware match check is relevant only for CNA.
+         */
+        if (!ioc->cna)
+                return BFA_TRUE;
+
+        /**
+         * If bios boot (flash based) -- do not increment usage count
+         */
+        if (bfa_ioc_ct_fwimg_get_size(ioc) < BFA_IOC_FWIMG_MINSZ)
+                return BFA_TRUE;
+
+        bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg);
+        usecnt = bfa_reg_read(ioc->ioc_regs.ioc_usage_reg);
+
+        /**
+         * If usage count is 0, always return TRUE.
+         */
+        if (usecnt == 0) {
+                bfa_reg_write(ioc->ioc_regs.ioc_usage_reg, 1);
+                bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg);
+                bfa_trc(ioc, usecnt);
+                return BFA_TRUE;
+        }
+
+        ioc_fwstate = bfa_reg_read(ioc->ioc_regs.ioc_fwstate);
+        bfa_trc(ioc, ioc_fwstate);
+
+        /**
+         * Use count cannot be non-zero and chip in uninitialized state.
+         */
+        bfa_assert(ioc_fwstate != BFI_IOC_UNINIT);
+
+        /**
+         * Check if another driver with a different firmware is active
+         */
+        bfa_ioc_fwver_get(ioc, &fwhdr);
+        if (!bfa_ioc_fwver_cmp(ioc, &fwhdr)) {
+                bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg);
+                bfa_trc(ioc, usecnt);
+                return BFA_FALSE;
+        }
+
+        /**
+         * Same firmware version. Increment the reference count.
+         */
+        usecnt++;
+        bfa_reg_write(ioc->ioc_regs.ioc_usage_reg, usecnt);
+        bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg);
+        bfa_trc(ioc, usecnt);
+        return BFA_TRUE;
+}
+
+static void
+bfa_ioc_ct_firmware_unlock(struct bfa_ioc_s *ioc)
+{
+        u32 usecnt;
+
+        /**
+         * Firmware lock is relevant only for CNA.
+         * If bios boot (flash based) -- do not decrement usage count
+         */
+        if (!ioc->cna || bfa_ioc_ct_fwimg_get_size(ioc) < BFA_IOC_FWIMG_MINSZ)
+                return;
+
+        /**
+         * decrement usage count
+         */
+        bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg);
+        usecnt = bfa_reg_read(ioc->ioc_regs.ioc_usage_reg);
+        bfa_assert(usecnt > 0);
+
+        usecnt--;
+        bfa_reg_write(ioc->ioc_regs.ioc_usage_reg, usecnt);
+        bfa_trc(ioc, usecnt);
+
+        bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg);
+}
+
+/**
+ * Notify other functions on HB failure.
+ */
+static void
+bfa_ioc_ct_notify_hbfail(struct bfa_ioc_s *ioc)
+{
+        if (ioc->cna) {
+                bfa_reg_write(ioc->ioc_regs.ll_halt, __FW_INIT_HALT_P);
+                /* Wait for halt to take effect */
+                bfa_reg_read(ioc->ioc_regs.ll_halt);
+        } else {
+                bfa_reg_write(ioc->ioc_regs.err_set, __PSS_ERR_STATUS_SET);
+                bfa_reg_read(ioc->ioc_regs.err_set);
+        }
+}
+
+/**
+ * Host to LPU mailbox message addresses
+ */
+static struct { u32 hfn_mbox, lpu_mbox, hfn_pgn; } iocreg_fnreg[] = {
+        { HOSTFN0_LPU_MBOX0_0, LPU_HOSTFN0_MBOX0_0, HOST_PAGE_NUM_FN0 },
+        { HOSTFN1_LPU_MBOX0_8, LPU_HOSTFN1_MBOX0_8, HOST_PAGE_NUM_FN1 },
+        { HOSTFN2_LPU_MBOX0_0, LPU_HOSTFN2_MBOX0_0, HOST_PAGE_NUM_FN2 },
+        { HOSTFN3_LPU_MBOX0_8, LPU_HOSTFN3_MBOX0_8, HOST_PAGE_NUM_FN3 }
+};
+
+/**
+ * Host <-> LPU mailbox command/status registers - port 0
+ */
+static struct { u32 hfn, lpu; } iocreg_mbcmd_p0[] = {
+        { HOSTFN0_LPU0_MBOX0_CMD_STAT, LPU0_HOSTFN0_MBOX0_CMD_STAT },
+        { HOSTFN1_LPU0_MBOX0_CMD_STAT, LPU0_HOSTFN1_MBOX0_CMD_STAT },
+        { HOSTFN2_LPU0_MBOX0_CMD_STAT, LPU0_HOSTFN2_MBOX0_CMD_STAT },
+        { HOSTFN3_LPU0_MBOX0_CMD_STAT, LPU0_HOSTFN3_MBOX0_CMD_STAT }
+};
+
+/**
+ * Host <-> LPU mailbox command/status registers - port 1
+ */
+static struct { u32 hfn, lpu; } iocreg_mbcmd_p1[] = {
+        { HOSTFN0_LPU1_MBOX0_CMD_STAT, LPU1_HOSTFN0_MBOX0_CMD_STAT },
+        { HOSTFN1_LPU1_MBOX0_CMD_STAT, LPU1_HOSTFN1_MBOX0_CMD_STAT },
+        { HOSTFN2_LPU1_MBOX0_CMD_STAT, LPU1_HOSTFN2_MBOX0_CMD_STAT },
+        { HOSTFN3_LPU1_MBOX0_CMD_STAT, LPU1_HOSTFN3_MBOX0_CMD_STAT }
+};
+
+static void
+bfa_ioc_ct_reg_init(struct bfa_ioc_s *ioc)
+{
+        bfa_os_addr_t   rb;
+        int             pcifn = bfa_ioc_pcifn(ioc);
+
+        rb = bfa_ioc_bar0(ioc);
+
+        ioc->ioc_regs.hfn_mbox = rb + iocreg_fnreg[pcifn].hfn_mbox;
+        ioc->ioc_regs.lpu_mbox = rb + iocreg_fnreg[pcifn].lpu_mbox;
+        ioc->ioc_regs.host_page_num_fn = rb + iocreg_fnreg[pcifn].hfn_pgn;
+
+        if (ioc->port_id == 0) {
+                ioc->ioc_regs.heartbeat = rb + BFA_IOC0_HBEAT_REG;
+                ioc->ioc_regs.ioc_fwstate = rb + BFA_IOC0_STATE_REG;
+                ioc->ioc_regs.hfn_mbox_cmd = rb + iocreg_mbcmd_p0[pcifn].hfn;
+                ioc->ioc_regs.lpu_mbox_cmd = rb + iocreg_mbcmd_p0[pcifn].lpu;
+                ioc->ioc_regs.ll_halt = rb + FW_INIT_HALT_P0;
+        } else {
+                ioc->ioc_regs.heartbeat = (rb + BFA_IOC1_HBEAT_REG);
+                ioc->ioc_regs.ioc_fwstate = (rb + BFA_IOC1_STATE_REG);
+                ioc->ioc_regs.hfn_mbox_cmd = rb + iocreg_mbcmd_p1[pcifn].hfn;
+                ioc->ioc_regs.lpu_mbox_cmd = rb + iocreg_mbcmd_p1[pcifn].lpu;
+                ioc->ioc_regs.ll_halt = rb + FW_INIT_HALT_P1;
+        }
+
+        /*
+         * PSS control registers
+         */
+        ioc->ioc_regs.pss_ctl_reg = (rb + PSS_CTL_REG);
+        ioc->ioc_regs.pss_err_status_reg = (rb + PSS_ERR_STATUS_REG);
+        ioc->ioc_regs.app_pll_fast_ctl_reg = (rb + APP_PLL_425_CTL_REG);
+        ioc->ioc_regs.app_pll_slow_ctl_reg = (rb + APP_PLL_312_CTL_REG);
+
+        /*
+         * IOC semaphore registers and serialization
+         */
+        ioc->ioc_regs.ioc_sem_reg = (rb + HOST_SEM0_REG);
+        ioc->ioc_regs.ioc_usage_sem_reg = (rb + HOST_SEM1_REG);
+        ioc->ioc_regs.ioc_init_sem_reg = (rb + HOST_SEM2_REG);
+        ioc->ioc_regs.ioc_usage_reg = (rb + BFA_FW_USE_COUNT);
+
+        /**
+         * sram memory access
+         */
+        ioc->ioc_regs.smem_page_start = (rb + PSS_SMEM_PAGE_START);
+        ioc->ioc_regs.smem_pg0 = BFI_IOC_SMEM_PG0_CT;
+
+        /*
+         * err set reg : for notification of hb failure in fcmode
+         */
+        ioc->ioc_regs.err_set = (rb + ERR_SET_REG);
+}
+
+/**
+ * Initialize IOC to port mapping.
+ */
+
+#define FNC_PERS_FN_SHIFT(__fn) ((__fn) * 8)
+static void
+bfa_ioc_ct_map_port(struct bfa_ioc_s *ioc)
+{
+        bfa_os_addr_t   rb = ioc->pcidev.pci_bar_kva;
+        u32     r32;
+
+        /**
+         * For catapult, base port id on personality register and IOC type
+         */
+        r32 = bfa_reg_read(rb + FNC_PERS_REG);
+        r32 >>= FNC_PERS_FN_SHIFT(bfa_ioc_pcifn(ioc));
+        ioc->port_id = (r32 & __F0_PORT_MAP_MK) >> __F0_PORT_MAP_SH;
+
+        bfa_trc(ioc, bfa_ioc_pcifn(ioc));
+        bfa_trc(ioc, ioc->port_id);
+}
+
+/**
+ * Set interrupt mode for a function: INTX or MSIX
+ */
+static void
+bfa_ioc_ct_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t msix)
+{
+        bfa_os_addr_t   rb = ioc->pcidev.pci_bar_kva;
+        u32     r32, mode;
+
+        r32 = bfa_reg_read(rb + FNC_PERS_REG);
+        bfa_trc(ioc, r32);
+
+        mode = (r32 >> FNC_PERS_FN_SHIFT(bfa_ioc_pcifn(ioc))) &
+                __F0_INTX_STATUS;
+
+        /**
+         * If already in desired mode, do not change anything
+         */
+        if (!msix && mode)
+                return;
+
+        if (msix)
+                mode = __F0_INTX_STATUS_MSIX;
+        else
+                mode = __F0_INTX_STATUS_INTA;
+
+        r32 &= ~(__F0_INTX_STATUS << FNC_PERS_FN_SHIFT(bfa_ioc_pcifn(ioc)));
+        r32 |= (mode << FNC_PERS_FN_SHIFT(bfa_ioc_pcifn(ioc)));
+        bfa_trc(ioc, r32);
+
+        bfa_reg_write(rb + FNC_PERS_REG, r32);
+}
+
+static bfa_status_t
+bfa_ioc_ct_pll_init(struct bfa_ioc_s *ioc)
+{
+        bfa_os_addr_t   rb = ioc->pcidev.pci_bar_kva;
+        u32     pll_sclk, pll_fclk, r32;
+
+        /*
+         *  Hold semaphore so that nobody can access the chip during init.
+         */
+        bfa_ioc_sem_get(ioc->ioc_regs.ioc_init_sem_reg);
+
+        pll_sclk = __APP_PLL_312_LRESETN | __APP_PLL_312_ENARST |
+                __APP_PLL_312_RSEL200500 | __APP_PLL_312_P0_1(3U) |
+                __APP_PLL_312_JITLMT0_1(3U) |
+                __APP_PLL_312_CNTLMT0_1(1U);
+        pll_fclk = __APP_PLL_425_LRESETN | __APP_PLL_425_ENARST |
+                __APP_PLL_425_RSEL200500 | __APP_PLL_425_P0_1(3U) |
+                __APP_PLL_425_JITLMT0_1(3U) |
+                __APP_PLL_425_CNTLMT0_1(1U);
+
+        /**
+         *      For catapult, choose operational mode FC/FCoE
+         */
+        if (ioc->fcmode) {
+                bfa_reg_write((rb + OP_MODE), 0);
+                bfa_reg_write((rb + ETH_MAC_SER_REG),
+                                __APP_EMS_CMLCKSEL |
+                                __APP_EMS_REFCKBUFEN2 |
+                                __APP_EMS_CHANNEL_SEL);
+        } else {
+                ioc->pllinit = BFA_TRUE;
+                bfa_reg_write((rb + OP_MODE), __GLOBAL_FCOE_MODE);
+                bfa_reg_write((rb + ETH_MAC_SER_REG),
+                                 __APP_EMS_REFCKBUFEN1);
+        }
+
+        bfa_reg_write((rb + BFA_IOC0_STATE_REG), BFI_IOC_UNINIT);
+        bfa_reg_write((rb + BFA_IOC1_STATE_REG), BFI_IOC_UNINIT);
+
+        bfa_reg_write((rb + HOSTFN0_INT_MSK), 0xffffffffU);
+        bfa_reg_write((rb + HOSTFN1_INT_MSK), 0xffffffffU);
+        bfa_reg_write((rb + HOSTFN0_INT_STATUS), 0xffffffffU);
+        bfa_reg_write((rb + HOSTFN1_INT_STATUS), 0xffffffffU);
+        bfa_reg_write((rb + HOSTFN0_INT_MSK), 0xffffffffU);
+        bfa_reg_write((rb + HOSTFN1_INT_MSK), 0xffffffffU);
+
+        bfa_reg_write(ioc->ioc_regs.app_pll_slow_ctl_reg, pll_sclk |
+                __APP_PLL_312_LOGIC_SOFT_RESET);
+        bfa_reg_write(ioc->ioc_regs.app_pll_fast_ctl_reg, pll_fclk |
+                __APP_PLL_425_LOGIC_SOFT_RESET);
+        bfa_reg_write(ioc->ioc_regs.app_pll_slow_ctl_reg, pll_sclk |
+                __APP_PLL_312_LOGIC_SOFT_RESET | __APP_PLL_312_ENABLE);
+        bfa_reg_write(ioc->ioc_regs.app_pll_fast_ctl_reg, pll_fclk |
+                __APP_PLL_425_LOGIC_SOFT_RESET | __APP_PLL_425_ENABLE);
+
+        /**
+         * Wait for PLLs to lock.
+         */
+        bfa_reg_read(rb + HOSTFN0_INT_MSK);
+        bfa_os_udelay(2000);
+        bfa_reg_write((rb + HOSTFN0_INT_STATUS), 0xffffffffU);
+        bfa_reg_write((rb + HOSTFN1_INT_STATUS), 0xffffffffU);
+
+        bfa_reg_write(ioc->ioc_regs.app_pll_slow_ctl_reg, pll_sclk |
+                __APP_PLL_312_ENABLE);
+        bfa_reg_write(ioc->ioc_regs.app_pll_fast_ctl_reg, pll_fclk |
+                __APP_PLL_425_ENABLE);
+
+        bfa_reg_write((rb + MBIST_CTL_REG), __EDRAM_BISTR_START);
+        bfa_os_udelay(1000);
+        r32 = bfa_reg_read((rb + MBIST_STAT_REG));
+        bfa_trc(ioc, r32);
+        /*
+         *  release semaphore.
+         */
+        bfa_ioc_sem_release(ioc->ioc_regs.ioc_init_sem_reg);
+
+        return BFA_STATUS_OK;
+}
+
+/**
+ * Cleanup hw semaphore and usecnt registers
+ */
+static void
+bfa_ioc_ct_ownership_reset(struct bfa_ioc_s *ioc)
+{
+
+        if (ioc->cna) {
+                bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg);
+                bfa_reg_write(ioc->ioc_regs.ioc_usage_reg, 0);
+                bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg);
+        }
+
+        /*
+         * Read the hw sem reg to make sure that it is locked
+         * before we clear it. If it is not locked, writing 1
+         * will lock it instead of clearing it.
+         */
+        bfa_reg_read(ioc->ioc_regs.ioc_sem_reg);
+        bfa_ioc_hw_sem_release(ioc);
+}
diff --git a/drivers/scsi/bfa/bfa_iocfc.c b/drivers/scsi/bfa/bfa_iocfc.c
index 12350b022d63..a76de2669bfc 100644
--- a/drivers/scsi/bfa/bfa_iocfc.c
+++ b/drivers/scsi/bfa/bfa_iocfc.c
@@ -172,6 +172,7 @@ bfa_iocfc_init_mem(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
          */
         if (bfa_ioc_devid(&bfa->ioc) == BFA_PCI_DEVICE_ID_CT) {
                 iocfc->hwif.hw_reginit = bfa_hwct_reginit;
+                iocfc->hwif.hw_reqq_ack = bfa_hwct_reqq_ack;
                 iocfc->hwif.hw_rspq_ack = bfa_hwct_rspq_ack;
                 iocfc->hwif.hw_msix_init = bfa_hwct_msix_init;
                 iocfc->hwif.hw_msix_install = bfa_hwct_msix_install;
@@ -180,6 +181,7 @@ bfa_iocfc_init_mem(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
                 iocfc->hwif.hw_msix_getvecs = bfa_hwct_msix_getvecs;
         } else {
                 iocfc->hwif.hw_reginit = bfa_hwcb_reginit;
+                iocfc->hwif.hw_reqq_ack = bfa_hwcb_reqq_ack;
                 iocfc->hwif.hw_rspq_ack = bfa_hwcb_rspq_ack;
                 iocfc->hwif.hw_msix_init = bfa_hwcb_msix_init;
                 iocfc->hwif.hw_msix_install = bfa_hwcb_msix_install;
@@ -336,8 +338,10 @@ bfa_iocfc_init_cb(void *bfa_arg, bfa_boolean_t complete)
                         bfa_cb_init(bfa->bfad, BFA_STATUS_OK);
                 else
                         bfa_cb_init(bfa->bfad, BFA_STATUS_FAILED);
-        } else
-                bfa->iocfc.action = BFA_IOCFC_ACT_NONE;
+        } else {
+                if (bfa->iocfc.cfgdone)
+                        bfa->iocfc.action = BFA_IOCFC_ACT_NONE;
+        }
 }
 
 static void
@@ -619,8 +623,6 @@ bfa_iocfc_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
 
         bfa_ioc_attach(&bfa->ioc, bfa, &bfa_iocfc_cbfn, &bfa->timer_mod,
                 bfa->trcmod, bfa->aen, bfa->logm);
-        bfa_ioc_pci_init(&bfa->ioc, pcidev, BFI_MC_IOCFC);
-        bfa_ioc_mbox_register(&bfa->ioc, bfa_mbox_isrs);
 
         /**
          * Choose FC (ssid: 0x1C) v/s FCoE (ssid: 0x14) mode.
@@ -628,6 +630,9 @@ bfa_iocfc_attach(struct bfa_s *bfa, void *bfad, struct bfa_iocfc_cfg_s *cfg,
         if (0)
                 bfa_ioc_set_fcmode(&bfa->ioc);
 
+        bfa_ioc_pci_init(&bfa->ioc, pcidev, BFI_MC_IOCFC);
+        bfa_ioc_mbox_register(&bfa->ioc, bfa_mbox_isrs);
+
         bfa_iocfc_init_mem(bfa, bfad, cfg, pcidev);
         bfa_iocfc_mem_claim(bfa, cfg, meminfo);
         bfa_timer_init(&bfa->timer_mod);
@@ -654,7 +659,6 @@ bfa_iocfc_init(struct bfa_s *bfa)
 {
         bfa->iocfc.action = BFA_IOCFC_ACT_INIT;
         bfa_ioc_enable(&bfa->ioc);
-        bfa_msix_install(bfa);
 }
 
 /**
@@ -794,7 +798,12 @@ bfa_iocfc_get_stats(struct bfa_s *bfa, struct bfa_iocfc_stats_s *stats,
 
         if (iocfc->stats_busy) {
                 bfa_trc(bfa, iocfc->stats_busy);
-                return (BFA_STATUS_DEVBUSY);
+                return BFA_STATUS_DEVBUSY;
+        }
+
+        if (!bfa_iocfc_is_operational(bfa)) {
+                bfa_trc(bfa, 0);
+                return BFA_STATUS_IOC_NON_OP;
         }
 
         iocfc->stats_busy = BFA_TRUE;
@@ -804,7 +813,7 @@ bfa_iocfc_get_stats(struct bfa_s *bfa, struct bfa_iocfc_stats_s *stats,
 
         bfa_iocfc_stats_query(bfa);
 
-        return (BFA_STATUS_OK);
+        return BFA_STATUS_OK;
 }
 
 bfa_status_t
@@ -814,7 +823,12 @@ bfa_iocfc_clear_stats(struct bfa_s *bfa, bfa_cb_ioc_t cbfn, void *cbarg)
 
         if (iocfc->stats_busy) {
                 bfa_trc(bfa, iocfc->stats_busy);
-                return (BFA_STATUS_DEVBUSY);
+                return BFA_STATUS_DEVBUSY;
+        }
+
+        if (!bfa_iocfc_is_operational(bfa)) {
+                bfa_trc(bfa, 0);
+                return BFA_STATUS_IOC_NON_OP;
         }
 
         iocfc->stats_busy = BFA_TRUE;
@@ -822,7 +836,7 @@ bfa_iocfc_clear_stats(struct bfa_s *bfa, bfa_cb_ioc_t cbfn, void *cbarg)
         iocfc->stats_cbarg = cbarg;
 
         bfa_iocfc_stats_clear(bfa);
-        return (BFA_STATUS_OK);
+        return BFA_STATUS_OK;
 }
 
 /**
diff --git a/drivers/scsi/bfa/bfa_iocfc.h b/drivers/scsi/bfa/bfa_iocfc.h
index 7ad177ed4cfc..fbb4bdc9d600 100644
--- a/drivers/scsi/bfa/bfa_iocfc.h
+++ b/drivers/scsi/bfa/bfa_iocfc.h
@@ -54,6 +54,7 @@ struct bfa_msix_s {
  */
 struct bfa_hwif_s {
         void (*hw_reginit)(struct bfa_s *bfa);
+        void (*hw_reqq_ack)(struct bfa_s *bfa, int reqq);
         void (*hw_rspq_ack)(struct bfa_s *bfa, int rspq);
         void (*hw_msix_init)(struct bfa_s *bfa, int nvecs);
         void (*hw_msix_install)(struct bfa_s *bfa);
@@ -107,13 +108,13 @@ struct bfa_iocfc_s {
 
 #define bfa_lpuid(__bfa)                bfa_ioc_portid(&(__bfa)->ioc)
 #define bfa_msix_init(__bfa, __nvecs)   \
-        (__bfa)->iocfc.hwif.hw_msix_init(__bfa, __nvecs)
+        ((__bfa)->iocfc.hwif.hw_msix_init(__bfa, __nvecs))
 #define bfa_msix_install(__bfa) \
-        (__bfa)->iocfc.hwif.hw_msix_install(__bfa)
+        ((__bfa)->iocfc.hwif.hw_msix_install(__bfa))
 #define bfa_msix_uninstall(__bfa)       \
-        (__bfa)->iocfc.hwif.hw_msix_uninstall(__bfa)
+        ((__bfa)->iocfc.hwif.hw_msix_uninstall(__bfa))
 #define bfa_isr_mode_set(__bfa, __msix) \
-        (__bfa)->iocfc.hwif.hw_isr_mode_set(__bfa, __msix)
+        ((__bfa)->iocfc.hwif.hw_isr_mode_set(__bfa, __msix))
 #define bfa_msix_getvecs(__bfa, __vecmap, __nvecs, __maxvec)    \
         (__bfa)->iocfc.hwif.hw_msix_getvecs(__bfa, __vecmap, __nvecs, __maxvec)
 
@@ -143,6 +144,7 @@ void bfa_msix_rspq(struct bfa_s *bfa, int vec);
 void bfa_msix_lpu_err(struct bfa_s *bfa, int vec);
 
 void bfa_hwcb_reginit(struct bfa_s *bfa);
+void bfa_hwcb_reqq_ack(struct bfa_s *bfa, int rspq);
 void bfa_hwcb_rspq_ack(struct bfa_s *bfa, int rspq);
 void bfa_hwcb_msix_init(struct bfa_s *bfa, int nvecs);
 void bfa_hwcb_msix_install(struct bfa_s *bfa);
@@ -151,6 +153,7 @@ void bfa_hwcb_isr_mode_set(struct bfa_s *bfa, bfa_boolean_t msix);
 void bfa_hwcb_msix_getvecs(struct bfa_s *bfa, u32 *vecmap,
                         u32 *nvecs, u32 *maxvec);
 void bfa_hwct_reginit(struct bfa_s *bfa);
+void bfa_hwct_reqq_ack(struct bfa_s *bfa, int rspq);
 void bfa_hwct_rspq_ack(struct bfa_s *bfa, int rspq);
 void bfa_hwct_msix_init(struct bfa_s *bfa, int nvecs);
 void bfa_hwct_msix_install(struct bfa_s *bfa);
diff --git a/drivers/scsi/bfa/bfa_ioim.c b/drivers/scsi/bfa/bfa_ioim.c
index 7ae2552e1e14..5b107abe46e5 100644
--- a/drivers/scsi/bfa/bfa_ioim.c
+++ b/drivers/scsi/bfa/bfa_ioim.c
@@ -105,13 +105,13 @@ bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                                 bfa_sm_set_state(ioim, bfa_ioim_sm_hcb);
                                 list_del(&ioim->qe);
                                 list_add_tail(&ioim->qe,
-                                        &ioim->fcpim->ioim_comp_q);
+                                                &ioim->fcpim->ioim_comp_q);
                                 bfa_cb_queue(ioim->bfa, &ioim->hcb_qe,
                                                 __bfa_cb_ioim_pathtov, ioim);
                         } else {
                                 list_del(&ioim->qe);
                                 list_add_tail(&ioim->qe,
-                                        &ioim->itnim->pending_q);
+                                                &ioim->itnim->pending_q);
                         }
                         break;
                 }
@@ -149,7 +149,7 @@ bfa_ioim_sm_uninit(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ioim->bfa, event);
         }
 }
 
@@ -194,7 +194,7 @@ bfa_ioim_sm_sgalloc(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ioim->bfa, event);
         }
 }
 
@@ -259,7 +259,7 @@ bfa_ioim_sm_active(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ioim->bfa, event);
         }
 }
 
@@ -317,7 +317,7 @@ bfa_ioim_sm_abort(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ioim->bfa, event);
         }
 }
 
@@ -377,7 +377,7 @@ bfa_ioim_sm_cleanup(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ioim->bfa, event);
         }
 }
 
@@ -419,7 +419,7 @@ bfa_ioim_sm_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ioim->bfa, event);
         }
 }
 
@@ -467,7 +467,7 @@ bfa_ioim_sm_abort_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ioim->bfa, event);
         }
 }
 
@@ -516,7 +516,7 @@ bfa_ioim_sm_cleanup_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ioim->bfa, event);
         }
 }
 
@@ -544,7 +544,7 @@ bfa_ioim_sm_hcb(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ioim->bfa, event);
         }
 }
 
@@ -577,7 +577,7 @@ bfa_ioim_sm_hcb_free(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ioim->bfa, event);
         }
 }
 
@@ -605,7 +605,7 @@ bfa_ioim_sm_resfree(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ioim->bfa, event);
         }
 }
 
diff --git a/drivers/scsi/bfa/bfa_itnim.c b/drivers/scsi/bfa/bfa_itnim.c
index 4d5c61a4f85c..a914ff255135 100644
--- a/drivers/scsi/bfa/bfa_itnim.c
+++ b/drivers/scsi/bfa/bfa_itnim.c
@@ -144,7 +144,7 @@ bfa_itnim_sm_uninit(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -175,7 +175,7 @@ bfa_itnim_sm_created(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -212,7 +212,7 @@ bfa_itnim_sm_fwcreate(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -247,7 +247,7 @@ bfa_itnim_sm_fwcreate_qfull(struct bfa_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -275,7 +275,7 @@ bfa_itnim_sm_delete_pending(struct bfa_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -317,7 +317,7 @@ bfa_itnim_sm_online(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -348,7 +348,7 @@ bfa_itnim_sm_sler(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -385,7 +385,7 @@ bfa_itnim_sm_cleanup_offline(struct bfa_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -413,7 +413,7 @@ bfa_itnim_sm_cleanup_delete(struct bfa_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -442,7 +442,7 @@ bfa_itnim_sm_fwdelete(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -470,7 +470,7 @@ bfa_itnim_sm_fwdelete_qfull(struct bfa_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -502,7 +502,7 @@ bfa_itnim_sm_offline(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -538,7 +538,7 @@ bfa_itnim_sm_iocdisable(struct bfa_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -559,7 +559,7 @@ bfa_itnim_sm_deleting(struct bfa_itnim_s *itnim, enum bfa_itnim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -583,7 +583,7 @@ bfa_itnim_sm_deleting_qfull(struct bfa_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->bfa, event);
         }
 }
 
@@ -1029,7 +1029,7 @@ bfa_itnim_create(struct bfa_s *bfa, struct bfa_rport_s *rport, void *ditn)
         bfa_stats(itnim, creates);
         bfa_sm_send_event(itnim, BFA_ITNIM_SM_CREATE);
 
-        return (itnim);
+        return itnim;
 }
 
 void
@@ -1061,7 +1061,7 @@ bfa_itnim_offline(struct bfa_itnim_s *itnim)
 bfa_boolean_t
 bfa_itnim_hold_io(struct bfa_itnim_s *itnim)
 {
-        return (
+        return
                 itnim->fcpim->path_tov && itnim->iotov_active &&
                 (bfa_sm_cmp_state(itnim, bfa_itnim_sm_fwcreate) ||
                  bfa_sm_cmp_state(itnim, bfa_itnim_sm_sler) ||
@@ -1069,7 +1069,7 @@ bfa_itnim_hold_io(struct bfa_itnim_s *itnim)
                  bfa_sm_cmp_state(itnim, bfa_itnim_sm_fwdelete) ||
                  bfa_sm_cmp_state(itnim, bfa_itnim_sm_offline) ||
                  bfa_sm_cmp_state(itnim, bfa_itnim_sm_iocdisable))
-);
+        ;
 }
 
 void
diff --git a/drivers/scsi/bfa/bfa_log.c b/drivers/scsi/bfa/bfa_log.c
index c2735e55cf03..e7514016c9c6 100644
--- a/drivers/scsi/bfa/bfa_log.c
+++ b/drivers/scsi/bfa/bfa_log.c
@@ -231,9 +231,9 @@ bfa_log_get_level(struct bfa_log_mod_s *log_mod, int mod_id)
                 return BFA_LOG_INVALID;
 
         if (log_mod)
-                return (log_mod->log_level[mod_id]);
+                return log_mod->log_level[mod_id];
         else
-                return (bfa_log_info[mod_id].level);
+                return bfa_log_info[mod_id].level;
 }
 
 enum bfa_log_severity
diff --git a/drivers/scsi/bfa/bfa_lps.c b/drivers/scsi/bfa/bfa_lps.c
index 9844b45412b6..ad06f6189092 100644
--- a/drivers/scsi/bfa/bfa_lps.c
+++ b/drivers/scsi/bfa/bfa_lps.c
@@ -18,6 +18,7 @@
 #include <bfa.h>
 #include <bfi/bfi_lps.h>
 #include <cs/bfa_debug.h>
+#include <defs/bfa_defs_pci.h>
 
 BFA_TRC_FILE(HAL, LPS);
 BFA_MODULE(lps);
@@ -25,6 +26,12 @@ BFA_MODULE(lps);
 #define BFA_LPS_MIN_LPORTS      (1)
 #define BFA_LPS_MAX_LPORTS      (256)
 
+/*
+ * Maximum Vports supported per physical port or vf.
+ */
+#define BFA_LPS_MAX_VPORTS_SUPP_CB  255
+#define BFA_LPS_MAX_VPORTS_SUPP_CT  190
+
 /**
  * forward declarations
  */
@@ -49,7 +56,7 @@ static void bfa_lps_send_login(struct bfa_lps_s *lps);
 static void bfa_lps_send_logout(struct bfa_lps_s *lps);
 static void bfa_lps_login_comp(struct bfa_lps_s *lps);
 static void bfa_lps_logout_comp(struct bfa_lps_s *lps);
-
+static void bfa_lps_cvl_event(struct bfa_lps_s *lps);
 
 /**
  *  lps_pvt BFA LPS private functions
@@ -62,6 +69,7 @@ enum bfa_lps_event {
         BFA_LPS_SM_RESUME       = 4,    /* space present in reqq queue  */
         BFA_LPS_SM_DELETE       = 5,    /* lps delete from user         */
         BFA_LPS_SM_OFFLINE      = 6,    /* Link is offline              */
+        BFA_LPS_SM_RX_CVL       = 7,    /* Rx clear virtual link        */
 };
 
 static void bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event);
@@ -91,6 +99,12 @@ bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event)
                         bfa_sm_set_state(lps, bfa_lps_sm_login);
                         bfa_lps_send_login(lps);
                 }
+                if (lps->fdisc)
+                        bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
+                        BFA_PL_EID_LOGIN, 0, "FDISC Request");
+                else
+                        bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
+                        BFA_PL_EID_LOGIN, 0, "FLOGI Request");
                 break;
 
         case BFA_LPS_SM_LOGOUT:
@@ -101,6 +115,7 @@ bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event)
                 bfa_lps_free(lps);
                 break;
 
+        case BFA_LPS_SM_RX_CVL:
         case BFA_LPS_SM_OFFLINE:
                 break;
 
@@ -112,7 +127,7 @@ bfa_lps_sm_init(struct bfa_lps_s *lps, enum bfa_lps_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(lps->bfa, event);
         }
 }
 
@@ -127,10 +142,25 @@ bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event)
 
         switch (event) {
         case BFA_LPS_SM_FWRSP:
-                if (lps->status == BFA_STATUS_OK)
+                if (lps->status == BFA_STATUS_OK) {
                         bfa_sm_set_state(lps, bfa_lps_sm_online);
-                else
+                        if (lps->fdisc)
+                                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
+                                BFA_PL_EID_LOGIN, 0, "FDISC Accept");
+                        else
+                                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
+                                BFA_PL_EID_LOGIN, 0, "FLOGI Accept");
+                } else {
                         bfa_sm_set_state(lps, bfa_lps_sm_init);
+                        if (lps->fdisc)
+                                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
+                                BFA_PL_EID_LOGIN, 0,
+                                "FDISC Fail (RJT or timeout)");
+                        else
+                                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
+                                BFA_PL_EID_LOGIN, 0,
+                                "FLOGI Fail (RJT or timeout)");
+                }
                 bfa_lps_login_comp(lps);
                 break;
 
@@ -139,7 +169,7 @@ bfa_lps_sm_login(struct bfa_lps_s *lps, enum bfa_lps_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(lps->bfa, event);
         }
 }
 
@@ -162,8 +192,16 @@ bfa_lps_sm_loginwait(struct bfa_lps_s *lps, enum bfa_lps_event event)
                 bfa_reqq_wcancel(&lps->wqe);
                 break;
 
+        case BFA_LPS_SM_RX_CVL:
+                /*
+                 * Login was not even sent out; so when getting out
+                 * of this state, it will appear like a login retry
+                 * after Clear virtual link
+                 */
+                break;
+
         default:
-                bfa_assert(0);
+                bfa_sm_fault(lps->bfa, event);
         }
 }
 
@@ -185,6 +223,17 @@ bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event)
                         bfa_sm_set_state(lps, bfa_lps_sm_logout);
                         bfa_lps_send_logout(lps);
                 }
+                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
+                        BFA_PL_EID_LOGO, 0, "Logout");
+                break;
+
+        case BFA_LPS_SM_RX_CVL:
+                bfa_sm_set_state(lps, bfa_lps_sm_init);
+
+                /* Let the vport module know about this event */
+                bfa_lps_cvl_event(lps);
+                bfa_plog_str(lps->bfa->plog, BFA_PL_MID_LPS,
+                        BFA_PL_EID_FIP_FCF_CVL, 0, "FCF Clear Virt. Link Rx");
                 break;
 
         case BFA_LPS_SM_OFFLINE:
@@ -193,7 +242,7 @@ bfa_lps_sm_online(struct bfa_lps_s *lps, enum bfa_lps_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(lps->bfa, event);
         }
 }
 
@@ -217,7 +266,7 @@ bfa_lps_sm_logout(struct bfa_lps_s *lps, enum bfa_lps_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(lps->bfa, event);
         }
 }
 
@@ -242,7 +291,7 @@ bfa_lps_sm_logowait(struct bfa_lps_s *lps, enum bfa_lps_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(lps->bfa, event);
         }
 }
 
@@ -396,6 +445,20 @@ bfa_lps_logout_rsp(struct bfa_s *bfa, struct bfi_lps_logout_rsp_s *rsp)
 }
 
 /**
+ * Firmware received a Clear virtual link request (for FCoE)
+ */
+static void
+bfa_lps_rx_cvl_event(struct bfa_s *bfa, struct bfi_lps_cvl_event_s *cvl)
+{
+        struct bfa_lps_mod_s    *mod = BFA_LPS_MOD(bfa);
+        struct bfa_lps_s        *lps;
+
+        lps = BFA_LPS_FROM_TAG(mod, cvl->lp_tag);
+
+        bfa_sm_send_event(lps, BFA_LPS_SM_RX_CVL);
+}
+
+/**
  * Space is available in request queue, resume queueing request to firmware.
  */
 static void
@@ -531,7 +594,48 @@ bfa_lps_logout_comp(struct bfa_lps_s *lps)
                 bfa_cb_lps_flogo_comp(lps->bfa->bfad, lps->uarg);
 }
 
+/**
+ * Clear virtual link completion handler for non-fcs
+ */
+static void
+bfa_lps_cvl_event_cb(void *arg, bfa_boolean_t complete)
+{
+        struct bfa_lps_s *lps   = arg;
+
+        if (!complete)
+                return;
+
+        /* Clear virtual link to base port will result in link down */
+        if (lps->fdisc)
+                bfa_cb_lps_cvl_event(lps->bfa->bfad, lps->uarg);
+}
+
+/**
+ * Received Clear virtual link event --direct call for fcs,
+ * queue for others
+ */
+static void
+bfa_lps_cvl_event(struct bfa_lps_s *lps)
+{
+        if (!lps->bfa->fcs) {
+                bfa_cb_queue(lps->bfa, &lps->hcb_qe, bfa_lps_cvl_event_cb,
+                                lps);
+                return;
+        }
+
+        /* Clear virtual link to base port will result in link down */
+        if (lps->fdisc)
+                bfa_cb_lps_cvl_event(lps->bfa->bfad, lps->uarg);
+}
 
+u32
+bfa_lps_get_max_vport(struct bfa_s *bfa)
+{
+        if (bfa_ioc_devid(&bfa->ioc) == BFA_PCI_DEVICE_ID_CT)
+                return BFA_LPS_MAX_VPORTS_SUPP_CT;
+        else
+                return BFA_LPS_MAX_VPORTS_SUPP_CB;
+}
 
 /**
  *  lps_public BFA LPS public functions
@@ -752,6 +856,14 @@ bfa_lps_get_lsrjt_expl(struct bfa_lps_s *lps)
         return lps->lsrjt_expl;
 }
 
+/**
+ * Return fpma/spma MAC for lport
+ */
+struct mac_s
+bfa_lps_get_lp_mac(struct bfa_lps_s *lps)
+{
+        return lps->lp_mac;
+}
 
 /**
  * LPS firmware message class handler.
@@ -773,6 +885,10 @@ bfa_lps_isr(struct bfa_s *bfa, struct bfi_msg_s *m)
                 bfa_lps_logout_rsp(bfa, msg.logout_rsp);
                 break;
 
+        case BFI_LPS_H2I_CVL_EVENT:
+                bfa_lps_rx_cvl_event(bfa, msg.cvl_event);
+                break;
+
         default:
                 bfa_trc(bfa, m->mhdr.msg_id);
                 bfa_assert(0);
diff --git a/drivers/scsi/bfa/bfa_module.c b/drivers/scsi/bfa/bfa_module.c
index 32eda8e1ec65..a7fcc80c177e 100644
--- a/drivers/scsi/bfa/bfa_module.c
+++ b/drivers/scsi/bfa/bfa_module.c
@@ -24,7 +24,7 @@
  */
 struct bfa_module_s *hal_mods[] = {
         &hal_mod_sgpg,
-        &hal_mod_pport,
+        &hal_mod_fcport,
         &hal_mod_fcxp,
         &hal_mod_lps,
         &hal_mod_uf,
@@ -45,7 +45,7 @@ bfa_isr_func_t  bfa_isrs[BFI_MC_MAX] = {
         bfa_isr_unhandled,      /* BFI_MC_DIAG */
         bfa_isr_unhandled,      /* BFI_MC_FLASH */
         bfa_isr_unhandled,      /* BFI_MC_CEE */
-        bfa_pport_isr,          /* BFI_MC_PORT */
+        bfa_fcport_isr,         /* BFI_MC_FCPORT */
         bfa_isr_unhandled,      /* BFI_MC_IOCFC */
         bfa_isr_unhandled,      /* BFI_MC_LL */
         bfa_uf_isr,             /* BFI_MC_UF */
diff --git a/drivers/scsi/bfa/bfa_modules_priv.h b/drivers/scsi/bfa/bfa_modules_priv.h
index 96f70534593c..f554c2fad6a9 100644
--- a/drivers/scsi/bfa/bfa_modules_priv.h
+++ b/drivers/scsi/bfa/bfa_modules_priv.h
@@ -29,7 +29,7 @@
 
 
 struct bfa_modules_s {
-        struct bfa_pport_s      pport;  /*  physical port module        */
+        struct bfa_fcport_s     fcport; /*  fc port module      */
         struct bfa_fcxp_mod_s fcxp_mod; /*  fcxp module         */
         struct bfa_lps_mod_s lps_mod;   /*  fcxp module         */
         struct bfa_uf_mod_s uf_mod;     /*  unsolicited frame module    */
diff --git a/drivers/scsi/bfa/bfa_port_priv.h b/drivers/scsi/bfa/bfa_port_priv.h
index 4b97e2759908..40e256ec67ff 100644
--- a/drivers/scsi/bfa/bfa_port_priv.h
+++ b/drivers/scsi/bfa/bfa_port_priv.h
@@ -23,9 +23,19 @@
 #include "bfa_intr_priv.h"
 
 /**
- * BFA physical port data structure
+ * Link notification data structure
  */
-struct bfa_pport_s {
+struct bfa_fcport_ln_s {
+        struct bfa_fcport_s     *fcport;
+        bfa_sm_t                sm;
+        struct bfa_cb_qe_s      ln_qe;  /*  BFA callback queue elem for ln */
+        enum bfa_pport_linkstate ln_event; /*  ln event for callback */
+};
+
+/**
+ * BFA FC port data structure
+ */
+struct bfa_fcport_s {
         struct bfa_s            *bfa;   /*  parent BFA instance */
         bfa_sm_t                sm;     /*  port state machine */
         wwn_t                   nwwn;   /*  node wwn of physical port */
@@ -36,6 +46,8 @@ struct bfa_pport_s {
         enum bfa_pport_topology topology;       /*  current topology */
         u8                      myalpa; /*  my ALPA in LOOP topology */
         u8                      rsvd[3];
+        u32             mypid:24;
+        u32             rsvd_b:8;
         struct bfa_pport_cfg_s  cfg;    /*  current port configuration */
         struct bfa_qos_attr_s  qos_attr;   /* QoS Attributes */
         struct bfa_qos_vc_attr_s qos_vc_attr;  /*  VC info from ELP */
@@ -49,42 +61,31 @@ struct bfa_pport_s {
         void                    (*event_cbfn) (void *cbarg,
                                                 bfa_pport_event_t event);
         union {
-                union bfi_pport_i2h_msg_u i2hmsg;
+                union bfi_fcport_i2h_msg_u i2hmsg;
         } event_arg;
         void                    *bfad;  /*  BFA driver handle */
+        struct bfa_fcport_ln_s   ln; /* Link Notification */
         struct bfa_cb_qe_s              hcb_qe; /*  BFA callback queue elem */
-        enum bfa_pport_linkstate        hcb_event;
-                                        /*  link event for callback */
+        struct bfa_timer_s      timer;  /*  timer */
         u32             msgtag; /*  fimrware msg tag for reply */
         u8                      *stats_kva;
         u64             stats_pa;
-        union bfa_pport_stats_u *stats; /*  pport stats */
-        u32             mypid : 24;
-        u32             rsvd_b : 8;
-        struct bfa_timer_s      timer;  /*  timer */
-        union bfa_pport_stats_u         *stats_ret;
-                                        /*  driver stats location */
-        bfa_status_t            stats_status;
-                                        /*  stats/statsclr status */
-        bfa_boolean_t           stats_busy;
-                                        /*  outstanding stats/statsclr */
-        bfa_boolean_t           stats_qfull;
-        bfa_boolean_t           diag_busy;
-                                        /*  diag busy status */
-        bfa_boolean_t           beacon;
-                                        /*  port beacon status */
-        bfa_boolean_t           link_e2e_beacon;
-                                        /*  link beacon status */
-        bfa_cb_pport_t          stats_cbfn;
-                                        /*  driver callback function */
-        void                    *stats_cbarg;
-                                        /* *!< user callback arg */
+        union bfa_fcport_stats_u *stats;
+        union bfa_fcport_stats_u *stats_ret; /*  driver stats location */
+        bfa_status_t            stats_status; /*  stats/statsclr status */
+        bfa_boolean_t           stats_busy; /*  outstanding stats/statsclr */
+        bfa_boolean_t           stats_qfull;
+        bfa_cb_pport_t          stats_cbfn; /*  driver callback function */
+        void                    *stats_cbarg; /* *!< user callback arg */
+        bfa_boolean_t           diag_busy; /*  diag busy status */
+        bfa_boolean_t           beacon; /*  port beacon status */
+        bfa_boolean_t           link_e2e_beacon; /*  link beacon status */
 };
 
-#define BFA_PORT_MOD(__bfa)     (&(__bfa)->modules.pport)
+#define BFA_FCPORT_MOD(__bfa)   (&(__bfa)->modules.fcport)
 
 /*
  * public functions
  */
-void    bfa_pport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg);
+void    bfa_fcport_isr(struct bfa_s *bfa, struct bfi_msg_s *msg);
 #endif /* __BFA_PORT_PRIV_H__ */
diff --git a/drivers/scsi/bfa/bfa_priv.h b/drivers/scsi/bfa/bfa_priv.h
index 0747a6b26f7b..be80fc7e1b0e 100644
--- a/drivers/scsi/bfa/bfa_priv.h
+++ b/drivers/scsi/bfa/bfa_priv.h
@@ -101,7 +101,7 @@ extern bfa_boolean_t bfa_auto_recover;
 extern struct bfa_module_s hal_mod_flash;
 extern struct bfa_module_s hal_mod_fcdiag;
 extern struct bfa_module_s hal_mod_sgpg;
-extern struct bfa_module_s hal_mod_pport;
+extern struct bfa_module_s hal_mod_fcport;
 extern struct bfa_module_s hal_mod_fcxp;
 extern struct bfa_module_s hal_mod_lps;
 extern struct bfa_module_s hal_mod_uf;
diff --git a/drivers/scsi/bfa/bfa_rport.c b/drivers/scsi/bfa/bfa_rport.c
index 16da77a8db28..7c509fa244e4 100644
--- a/drivers/scsi/bfa/bfa_rport.c
+++ b/drivers/scsi/bfa/bfa_rport.c
@@ -114,7 +114,7 @@ bfa_rport_sm_uninit(struct bfa_rport_s *rp, enum bfa_rport_event event)
 
         default:
                 bfa_stats(rp, sm_un_unexp);
-                bfa_assert(0);
+                bfa_sm_fault(rp->bfa, event);
         }
 }
 
@@ -146,7 +146,7 @@ bfa_rport_sm_created(struct bfa_rport_s *rp, enum bfa_rport_event event)
 
         default:
                 bfa_stats(rp, sm_cr_unexp);
-                bfa_assert(0);
+                bfa_sm_fault(rp->bfa, event);
         }
 }
 
@@ -183,7 +183,7 @@ bfa_rport_sm_fwcreate(struct bfa_rport_s *rp, enum bfa_rport_event event)
 
         default:
                 bfa_stats(rp, sm_fwc_unexp);
-                bfa_assert(0);
+                bfa_sm_fault(rp->bfa, event);
         }
 }
 
@@ -224,7 +224,7 @@ bfa_rport_sm_fwcreate_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
 
         default:
                 bfa_stats(rp, sm_fwc_unexp);
-                bfa_assert(0);
+                bfa_sm_fault(rp->bfa, event);
         }
 }
 
@@ -296,7 +296,7 @@ bfa_rport_sm_online(struct bfa_rport_s *rp, enum bfa_rport_event event)
 
         default:
                 bfa_stats(rp, sm_on_unexp);
-                bfa_assert(0);
+                bfa_sm_fault(rp->bfa, event);
         }
 }
 
@@ -329,7 +329,7 @@ bfa_rport_sm_fwdelete(struct bfa_rport_s *rp, enum bfa_rport_event event)
 
         default:
                 bfa_stats(rp, sm_fwd_unexp);
-                bfa_assert(0);
+                bfa_sm_fault(rp->bfa, event);
         }
 }
 
@@ -359,7 +359,7 @@ bfa_rport_sm_fwdelete_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
 
         default:
                 bfa_stats(rp, sm_fwd_unexp);
-                bfa_assert(0);
+                bfa_sm_fault(rp->bfa, event);
         }
 }
 
@@ -394,7 +394,7 @@ bfa_rport_sm_offline(struct bfa_rport_s *rp, enum bfa_rport_event event)
 
         default:
                 bfa_stats(rp, sm_off_unexp);
-                bfa_assert(0);
+                bfa_sm_fault(rp->bfa, event);
         }
 }
 
@@ -421,7 +421,7 @@ bfa_rport_sm_deleting(struct bfa_rport_s *rp, enum bfa_rport_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rp->bfa, event);
         }
 }
 
@@ -446,7 +446,7 @@ bfa_rport_sm_deleting_qfull(struct bfa_rport_s *rp, enum bfa_rport_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rp->bfa, event);
         }
 }
 
@@ -477,7 +477,7 @@ bfa_rport_sm_delete_pending(struct bfa_rport_s *rp,
 
         default:
                 bfa_stats(rp, sm_delp_unexp);
-                bfa_assert(0);
+                bfa_sm_fault(rp->bfa, event);
         }
 }
 
@@ -512,7 +512,7 @@ bfa_rport_sm_offline_pending(struct bfa_rport_s *rp,
 
         default:
                 bfa_stats(rp, sm_offp_unexp);
-                bfa_assert(0);
+                bfa_sm_fault(rp->bfa, event);
         }
 }
 
@@ -550,7 +550,7 @@ bfa_rport_sm_iocdisable(struct bfa_rport_s *rp, enum bfa_rport_event event)
 
         default:
                 bfa_stats(rp, sm_iocd_unexp);
-                bfa_assert(0);
+                bfa_sm_fault(rp->bfa, event);
         }
 }
 
@@ -677,7 +677,7 @@ bfa_rport_alloc(struct bfa_rport_mod_s *mod)
         if (rport)
                 list_add_tail(&rport->qe, &mod->rp_active_q);
 
-        return (rport);
+        return rport;
 }
 
 static void
@@ -834,7 +834,7 @@ bfa_rport_create(struct bfa_s *bfa, void *rport_drv)
         rp = bfa_rport_alloc(BFA_RPORT_MOD(bfa));
 
         if (rp == NULL)
-                return (NULL);
+                return NULL;
 
         rp->bfa = bfa;
         rp->rport_drv = rport_drv;
@@ -843,7 +843,7 @@ bfa_rport_create(struct bfa_s *bfa, void *rport_drv)
         bfa_assert(bfa_sm_cmp_state(rp, bfa_rport_sm_uninit));
         bfa_sm_send_event(rp, BFA_RPORT_SM_CREATE);
 
-        return (rp);
+        return rp;
 }
 
 void
diff --git a/drivers/scsi/bfa/bfa_trcmod_priv.h b/drivers/scsi/bfa/bfa_trcmod_priv.h
index b3562dce7e9f..a7a82610db85 100644
--- a/drivers/scsi/bfa/bfa_trcmod_priv.h
+++ b/drivers/scsi/bfa/bfa_trcmod_priv.h
@@ -29,38 +29,36 @@
  * !!! needed between trace utility and driver version
  */
 enum {
-        BFA_TRC_HAL_IOC         = 1,
-        BFA_TRC_HAL_INTR        = 2,
-        BFA_TRC_HAL_FCXP        = 3,
-        BFA_TRC_HAL_UF          = 4,
-        BFA_TRC_HAL_DIAG        = 5,
-        BFA_TRC_HAL_RPORT       = 6,
-        BFA_TRC_HAL_FCPIM       = 7,
-        BFA_TRC_HAL_IOIM        = 8,
-        BFA_TRC_HAL_TSKIM       = 9,
-        BFA_TRC_HAL_ITNIM       = 10,
-        BFA_TRC_HAL_PPORT       = 11,
-        BFA_TRC_HAL_SGPG        = 12,
-        BFA_TRC_HAL_FLASH       = 13,
-        BFA_TRC_HAL_DEBUG       = 14,
-        BFA_TRC_HAL_WWN         = 15,
-        BFA_TRC_HAL_FLASH_RAW   = 16,
-        BFA_TRC_HAL_SBOOT       = 17,
-        BFA_TRC_HAL_SBOOT_IO    = 18,
-        BFA_TRC_HAL_SBOOT_INTR  = 19,
-        BFA_TRC_HAL_SBTEST      = 20,
-        BFA_TRC_HAL_IPFC        = 21,
-        BFA_TRC_HAL_IOCFC       = 22,
-        BFA_TRC_HAL_FCPTM       = 23,
-        BFA_TRC_HAL_IOTM        = 24,
-        BFA_TRC_HAL_TSKTM       = 25,
-        BFA_TRC_HAL_TIN         = 26,
-        BFA_TRC_HAL_LPS         = 27,
-        BFA_TRC_HAL_FCDIAG      = 28,
-        BFA_TRC_HAL_PBIND       = 29,
-        BFA_TRC_HAL_IOCFC_CT    = 30,
-        BFA_TRC_HAL_IOCFC_CB    = 31,
-        BFA_TRC_HAL_IOCFC_Q     = 32,
+        BFA_TRC_HAL_INTR        = 1,
+        BFA_TRC_HAL_FCXP        = 2,
+        BFA_TRC_HAL_UF          = 3,
+        BFA_TRC_HAL_RPORT       = 4,
+        BFA_TRC_HAL_FCPIM       = 5,
+        BFA_TRC_HAL_IOIM        = 6,
+        BFA_TRC_HAL_TSKIM       = 7,
+        BFA_TRC_HAL_ITNIM       = 8,
+        BFA_TRC_HAL_FCPORT      = 9,
+        BFA_TRC_HAL_SGPG        = 10,
+        BFA_TRC_HAL_FLASH       = 11,
+        BFA_TRC_HAL_DEBUG       = 12,
+        BFA_TRC_HAL_WWN         = 13,
+        BFA_TRC_HAL_FLASH_RAW   = 14,
+        BFA_TRC_HAL_SBOOT       = 15,
+        BFA_TRC_HAL_SBOOT_IO    = 16,
+        BFA_TRC_HAL_SBOOT_INTR  = 17,
+        BFA_TRC_HAL_SBTEST      = 18,
+        BFA_TRC_HAL_IPFC        = 19,
+        BFA_TRC_HAL_IOCFC       = 20,
+        BFA_TRC_HAL_FCPTM       = 21,
+        BFA_TRC_HAL_IOTM        = 22,
+        BFA_TRC_HAL_TSKTM       = 23,
+        BFA_TRC_HAL_TIN         = 24,
+        BFA_TRC_HAL_LPS         = 25,
+        BFA_TRC_HAL_FCDIAG      = 26,
+        BFA_TRC_HAL_PBIND       = 27,
+        BFA_TRC_HAL_IOCFC_CT    = 28,
+        BFA_TRC_HAL_IOCFC_CB    = 29,
+        BFA_TRC_HAL_IOCFC_Q     = 30,
 };
 
 #endif /* __BFA_TRCMOD_PRIV_H__ */
diff --git a/drivers/scsi/bfa/bfa_tskim.c b/drivers/scsi/bfa/bfa_tskim.c
index 010d40d1e5d3..ad9aaaedd3f1 100644
--- a/drivers/scsi/bfa/bfa_tskim.c
+++ b/drivers/scsi/bfa/bfa_tskim.c
@@ -23,13 +23,14 @@ BFA_TRC_FILE(HAL, TSKIM);
 /**
  * task management completion handling
  */
-#define bfa_tskim_qcomp(__tskim, __cbfn) do {                        \
-        bfa_cb_queue((__tskim)->bfa, &(__tskim)->hcb_qe, __cbfn, (__tskim)); \
+#define bfa_tskim_qcomp(__tskim, __cbfn) do {                   \
+        bfa_cb_queue((__tskim)->bfa, &(__tskim)->hcb_qe,        \
+                         __cbfn, (__tskim));      \
         bfa_tskim_notify_comp(__tskim);      \
 } while (0)
 
-#define bfa_tskim_notify_comp(__tskim) do {                                  \
-        if ((__tskim)->notify)                                               \
+#define bfa_tskim_notify_comp(__tskim) do {                      \
+        if ((__tskim)->notify)                                   \
                 bfa_itnim_tskdone((__tskim)->itnim);      \
 } while (0)
 
@@ -109,7 +110,7 @@ bfa_tskim_sm_uninit(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(tskim->bfa, event);
         }
 }
 
@@ -145,7 +146,7 @@ bfa_tskim_sm_active(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(tskim->bfa, event);
         }
 }
 
@@ -177,7 +178,7 @@ bfa_tskim_sm_cleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(tskim->bfa, event);
         }
 }
 
@@ -206,7 +207,7 @@ bfa_tskim_sm_iocleanup(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(tskim->bfa, event);
         }
 }
 
@@ -241,7 +242,7 @@ bfa_tskim_sm_qfull(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(tskim->bfa, event);
         }
 }
 
@@ -276,7 +277,7 @@ bfa_tskim_sm_cleanup_qfull(struct bfa_tskim_s *tskim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(tskim->bfa, event);
         }
 }
 
@@ -302,7 +303,7 @@ bfa_tskim_sm_hcb(struct bfa_tskim_s *tskim, enum bfa_tskim_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(tskim->bfa, event);
         }
 }
 
diff --git a/drivers/scsi/bfa/bfa_uf.c b/drivers/scsi/bfa/bfa_uf.c
index ff5f9deb1b22..4b3c2417d180 100644
--- a/drivers/scsi/bfa/bfa_uf.c
+++ b/drivers/scsi/bfa/bfa_uf.c
@@ -185,7 +185,7 @@ bfa_uf_get(struct bfa_uf_mod_s *uf_mod)
         struct bfa_uf_s   *uf;
 
         bfa_q_deq(&uf_mod->uf_free_q, &uf);
-        return (uf);
+        return uf;
 }
 
 static void
diff --git a/drivers/scsi/bfa/bfad.c b/drivers/scsi/bfa/bfad.c
index 6f2be5abf561..13f5feb308c2 100644
--- a/drivers/scsi/bfa/bfad.c
+++ b/drivers/scsi/bfa/bfad.c
@@ -19,7 +19,9 @@
  *  bfad.c Linux driver PCI interface module.
  */
 
+#include <linux/slab.h>
 #include <linux/module.h>
+#include <linux/kthread.h>
 #include "bfad_drv.h"
 #include "bfad_im.h"
 #include "bfad_tm.h"
@@ -53,6 +55,7 @@ static int      log_level = BFA_LOG_WARNING;
 static int      ioc_auto_recover = BFA_TRUE;
 static int      ipfc_enable = BFA_FALSE;
 static int      ipfc_mtu = -1;
+static int      fdmi_enable = BFA_TRUE;
 int             bfa_lun_queue_depth = BFAD_LUN_QUEUE_DEPTH;
 int             bfa_linkup_delay = -1;
 
@@ -74,6 +77,7 @@ module_param(log_level, int, S_IRUGO | S_IWUSR);
 module_param(ioc_auto_recover, int, S_IRUGO | S_IWUSR);
 module_param(ipfc_enable, int, S_IRUGO | S_IWUSR);
 module_param(ipfc_mtu, int, S_IRUGO | S_IWUSR);
+module_param(fdmi_enable, int, S_IRUGO | S_IWUSR);
 module_param(bfa_linkup_delay, int, S_IRUGO | S_IWUSR);
 
 /*
@@ -95,6 +99,8 @@ bfad_fc4_probe(struct bfad_s *bfad)
 
         if (ipfc_enable)
                 bfad_ipfc_probe(bfad);
+
+        bfad->bfad_flags |= BFAD_FC4_PROBE_DONE;
 ext:
         return rc;
 }
@@ -106,6 +112,7 @@ bfad_fc4_probe_undo(struct bfad_s *bfad)
         bfad_tm_probe_undo(bfad);
         if (ipfc_enable)
                 bfad_ipfc_probe_undo(bfad);
+        bfad->bfad_flags &= ~BFAD_FC4_PROBE_DONE;
 }
 
 static void
@@ -173,9 +180,19 @@ bfa_cb_init(void *drv, bfa_status_t init_status)
 {
         struct bfad_s  *bfad = drv;
 
-        if (init_status == BFA_STATUS_OK)
+        if (init_status == BFA_STATUS_OK) {
                 bfad->bfad_flags |= BFAD_HAL_INIT_DONE;
 
+                /* If BFAD_HAL_INIT_FAIL flag is set:
+                 * Wake up the kernel thread to start
+                 * the bfad operations after HAL init done
+                 */
+                if ((bfad->bfad_flags & BFAD_HAL_INIT_FAIL)) {
+                        bfad->bfad_flags &= ~BFAD_HAL_INIT_FAIL;
+                        wake_up_process(bfad->bfad_tsk);
+                }
+        }
+
         complete(&bfad->comp);
 }
 
@@ -188,8 +205,8 @@ static struct bfad_port_s *
 bfad_get_drv_port(struct bfad_s *bfad, struct bfad_vf_s *vf_drv,
                   struct bfad_vport_s *vp_drv)
 {
-        return ((vp_drv) ? (&(vp_drv)->drv_port)
-                : ((vf_drv) ? (&(vf_drv)->base_port) : (&(bfad)->pport)));
+        return (vp_drv) ? (&(vp_drv)->drv_port)
+                : ((vf_drv) ? (&(vf_drv)->base_port) : (&(bfad)->pport));
 }
 
 struct bfad_port_s *
@@ -648,7 +665,7 @@ bfad_fcs_port_cfg(struct bfad_s *bfad)
 
         sprintf(symname, "%s-%d", BFAD_DRIVER_NAME, bfad->inst_no);
         memcpy(port_cfg.sym_name.symname, symname, strlen(symname));
-        bfa_pport_get_attr(&bfad->bfa, &attr);
+        bfa_fcport_get_attr(&bfad->bfa, &attr);
         port_cfg.nwwn = attr.nwwn;
         port_cfg.pwwn = attr.pwwn;
 
@@ -661,7 +678,6 @@ bfad_drv_init(struct bfad_s *bfad)
         bfa_status_t    rc;
         unsigned long   flags;
         struct bfa_fcs_driver_info_s driver_info;
-        int             i;
 
         bfad->cfg_data.rport_del_timeout = rport_del_timeout;
         bfad->cfg_data.lun_queue_depth = bfa_lun_queue_depth;
@@ -681,12 +697,7 @@ bfad_drv_init(struct bfad_s *bfad)
         bfa_init_log(&bfad->bfa, bfad->logmod);
         bfa_init_trc(&bfad->bfa, bfad->trcmod);
         bfa_init_aen(&bfad->bfa, bfad->aen);
-        INIT_LIST_HEAD(&bfad->file_q);
-        INIT_LIST_HEAD(&bfad->file_free_q);
-        for (i = 0; i < BFAD_AEN_MAX_APPS; i++) {
-                bfa_q_qe_init(&bfad->file_buf[i].qe);
-                list_add_tail(&bfad->file_buf[i].qe, &bfad->file_free_q);
-        }
+        memset(bfad->file_map, 0, sizeof(bfad->file_map));
         bfa_init_plog(&bfad->bfa, &bfad->plog_buf);
         bfa_plog_init(&bfad->plog_buf);
         bfa_plog_str(&bfad->plog_buf, BFA_PL_MID_DRVR, BFA_PL_EID_DRIVER_START,
@@ -716,7 +727,7 @@ bfad_drv_init(struct bfad_s *bfad)
         if ((bfad->bfad_flags & BFAD_MSIX_ON)
             && bfad_install_msix_handler(bfad)) {
                 printk(KERN_WARNING "%s: install_msix failed, bfad%d\n",
-                       __FUNCTION__, bfad->inst_no);
+                       __func__, bfad->inst_no);
         }
 
         bfad_init_timer(bfad);
@@ -746,8 +757,16 @@ bfad_drv_init(struct bfad_s *bfad)
         bfa_fcs_log_init(&bfad->bfa_fcs, bfad->logmod);
         bfa_fcs_trc_init(&bfad->bfa_fcs, bfad->trcmod);
         bfa_fcs_aen_init(&bfad->bfa_fcs, bfad->aen);
-        bfa_fcs_init(&bfad->bfa_fcs, &bfad->bfa, bfad, BFA_FALSE);
+        bfa_fcs_attach(&bfad->bfa_fcs, &bfad->bfa, bfad, BFA_FALSE);
+
+        /* Do FCS init only when HAL init is done */
+        if ((bfad->bfad_flags & BFAD_HAL_INIT_DONE)) {
+                bfa_fcs_init(&bfad->bfa_fcs);
+                bfad->bfad_flags |= BFAD_FCS_INIT_DONE;
+        }
+
         bfa_fcs_driver_info_init(&bfad->bfa_fcs, &driver_info);
+        bfa_fcs_set_fdmi_param(&bfad->bfa_fcs, fdmi_enable);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 
         bfad->bfad_flags |= BFAD_DRV_INIT_DONE;
@@ -763,12 +782,21 @@ out_hal_mem_alloc_failure:
 void
 bfad_drv_uninit(struct bfad_s *bfad)
 {
+        unsigned long   flags;
+
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        init_completion(&bfad->comp);
+        bfa_stop(&bfad->bfa);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+        wait_for_completion(&bfad->comp);
+
         del_timer_sync(&bfad->hal_tmo);
         bfa_isr_disable(&bfad->bfa);
         bfa_detach(&bfad->bfa);
         bfad_remove_intr(bfad);
-        bfa_assert(list_empty(&bfad->file_q));
         bfad_hal_mem_release(bfad);
+
+        bfad->bfad_flags &= ~BFAD_DRV_INIT_DONE;
 }
 
 void
@@ -859,6 +887,86 @@ bfad_drv_log_level_set(struct bfad_s *bfad)
                 bfa_log_set_level_all(&bfad->log_data, log_level);
 }
 
+bfa_status_t
+bfad_start_ops(struct bfad_s *bfad)
+{
+        int retval;
+
+        /* PPORT FCS config */
+        bfad_fcs_port_cfg(bfad);
+
+        retval = bfad_cfg_pport(bfad, BFA_PORT_ROLE_FCP_IM);
+        if (retval != BFA_STATUS_OK)
+                goto out_cfg_pport_failure;
+
+        /* BFAD level FC4 (IM/TM/IPFC) specific resource allocation */
+        retval = bfad_fc4_probe(bfad);
+        if (retval != BFA_STATUS_OK) {
+                printk(KERN_WARNING "bfad_fc4_probe failed\n");
+                goto out_fc4_probe_failure;
+        }
+
+        bfad_drv_start(bfad);
+
+        /*
+         * If bfa_linkup_delay is set to -1 default; try to retrive the
+         * value using the bfad_os_get_linkup_delay(); else use the
+         * passed in module param value as the bfa_linkup_delay.
+         */
+        if (bfa_linkup_delay < 0) {
+
+                bfa_linkup_delay = bfad_os_get_linkup_delay(bfad);
+                bfad_os_rport_online_wait(bfad);
+                bfa_linkup_delay = -1;
+
+        } else {
+                bfad_os_rport_online_wait(bfad);
+        }
+
+        bfa_log(bfad->logmod, BFA_LOG_LINUX_DEVICE_CLAIMED, bfad->pci_name);
+
+        return BFA_STATUS_OK;
+
+out_fc4_probe_failure:
+        bfad_fc4_probe_undo(bfad);
+        bfad_uncfg_pport(bfad);
+out_cfg_pport_failure:
+        return BFA_STATUS_FAILED;
+}
+
+int
+bfad_worker (void *ptr)
+{
+        struct bfad_s *bfad;
+        unsigned long   flags;
+
+        bfad = (struct bfad_s *)ptr;
+
+        while (!kthread_should_stop()) {
+
+                /* Check if the FCS init is done from bfad_drv_init;
+                 * if not done do FCS init and set the flag.
+                 */
+                if (!(bfad->bfad_flags & BFAD_FCS_INIT_DONE)) {
+                        spin_lock_irqsave(&bfad->bfad_lock, flags);
+                        bfa_fcs_init(&bfad->bfa_fcs);
+                        bfad->bfad_flags |= BFAD_FCS_INIT_DONE;
+                        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                }
+
+                /* Start the bfad operations after HAL init done */
+                bfad_start_ops(bfad);
+
+                spin_lock_irqsave(&bfad->bfad_lock, flags);
+                bfad->bfad_tsk = NULL;
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
+                break;
+        }
+
+        return 0;
+}
+
  /*
   *  PCI_entry PCI driver entries * {
   */
@@ -871,7 +979,6 @@ bfad_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pid)
 {
         struct bfad_s  *bfad;
         int             error = -ENODEV, retval;
-        char            buf[16];
 
         /*
          * For single port cards - only claim function 0
@@ -902,8 +1009,7 @@ bfad_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pid)
         bfa_trc(bfad, bfad_inst);
 
         bfad->logmod = &bfad->log_data;
-        sprintf(buf, "%d", bfad_inst);
-        bfa_log_init(bfad->logmod, buf, bfa_os_printf);
+        bfa_log_init(bfad->logmod, (char *)pci_name(pdev), bfa_os_printf);
 
         bfad_drv_log_level_set(bfad);
 
@@ -933,57 +1039,39 @@ bfad_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pid)
         bfad->ref_count = 0;
         bfad->pport.bfad = bfad;
 
+        bfad->bfad_tsk = kthread_create(bfad_worker, (void *) bfad, "%s",
+                                        "bfad_worker");
+        if (IS_ERR(bfad->bfad_tsk)) {
+                printk(KERN_INFO "bfad[%d]: Kernel thread"
+                        " creation failed!\n",
+                        bfad->inst_no);
+                goto out_kthread_create_failure;
+        }
+
         retval = bfad_drv_init(bfad);
         if (retval != BFA_STATUS_OK)
                 goto out_drv_init_failure;
         if (!(bfad->bfad_flags & BFAD_HAL_INIT_DONE)) {
+                bfad->bfad_flags |= BFAD_HAL_INIT_FAIL;
                 printk(KERN_WARNING "bfad%d: hal init failed\n", bfad->inst_no);
                 goto ok;
         }
 
-        /*
-         * PPORT FCS config
-         */
-        bfad_fcs_port_cfg(bfad);
-
-        retval = bfad_cfg_pport(bfad, BFA_PORT_ROLE_FCP_IM);
+        retval = bfad_start_ops(bfad);
         if (retval != BFA_STATUS_OK)
-                goto out_cfg_pport_failure;
-
-        /*
-         * BFAD level FC4 (IM/TM/IPFC) specific resource allocation
-         */
-        retval = bfad_fc4_probe(bfad);
-        if (retval != BFA_STATUS_OK) {
-                printk(KERN_WARNING "bfad_fc4_probe failed\n");
-                goto out_fc4_probe_failure;
-        }
+                goto out_start_ops_failure;
 
-        bfad_drv_start(bfad);
-
-        /*
-         * If bfa_linkup_delay is set to -1 default; try to retrive the
-         * value using the bfad_os_get_linkup_delay(); else use the
-         * passed in module param value as the bfa_linkup_delay.
-         */
-        if (bfa_linkup_delay < 0) {
-                bfa_linkup_delay = bfad_os_get_linkup_delay(bfad);
-                bfad_os_rport_online_wait(bfad);
-                bfa_linkup_delay = -1;
-        } else {
-                bfad_os_rport_online_wait(bfad);
-        }
+        kthread_stop(bfad->bfad_tsk);
+        bfad->bfad_tsk = NULL;
 
-        bfa_log(bfad->logmod, BFA_LOG_LINUX_DEVICE_CLAIMED, bfad->pci_name);
 ok:
         return 0;
 
-out_fc4_probe_failure:
-        bfad_fc4_probe_undo(bfad);
-        bfad_uncfg_pport(bfad);
-out_cfg_pport_failure:
+out_start_ops_failure:
         bfad_drv_uninit(bfad);
 out_drv_init_failure:
+        kthread_stop(bfad->bfad_tsk);
+out_kthread_create_failure:
         mutex_lock(&bfad_mutex);
         bfad_inst--;
         list_del(&bfad->list_entry);
@@ -1008,6 +1096,11 @@ bfad_pci_remove(struct pci_dev *pdev)
 
         bfa_trc(bfad, bfad->inst_no);
 
+        spin_lock_irqsave(&bfad->bfad_lock, flags);
+        if (bfad->bfad_tsk != NULL)
+                kthread_stop(bfad->bfad_tsk);
+        spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+
         if ((bfad->bfad_flags & BFAD_DRV_INIT_DONE)
             && !(bfad->bfad_flags & BFAD_HAL_INIT_DONE)) {
 
@@ -1024,13 +1117,25 @@ bfad_pci_remove(struct pci_dev *pdev)
                 goto remove_sysfs;
         }
 
-        if (bfad->bfad_flags & BFAD_HAL_START_DONE)
+        if (bfad->bfad_flags & BFAD_HAL_START_DONE) {
                 bfad_drv_stop(bfad);
+        } else if (bfad->bfad_flags & BFAD_DRV_INIT_DONE) {
+                /* Invoking bfa_stop() before bfa_detach
+                 * when HAL and DRV init are success
+                 * but HAL start did not occur.
+                 */
+                spin_lock_irqsave(&bfad->bfad_lock, flags);
+                init_completion(&bfad->comp);
+                bfa_stop(&bfad->bfa);
+                spin_unlock_irqrestore(&bfad->bfad_lock, flags);
+                wait_for_completion(&bfad->comp);
+        }
 
         bfad_remove_intr(bfad);
-
         del_timer_sync(&bfad->hal_tmo);
-        bfad_fc4_probe_undo(bfad);
+
+        if (bfad->bfad_flags & BFAD_FC4_PROBE_DONE)
+                bfad_fc4_probe_undo(bfad);
 
         if (bfad->bfad_flags & BFAD_CFG_PPORT_DONE)
                 bfad_uncfg_pport(bfad);
diff --git a/drivers/scsi/bfa/bfad_attr.c b/drivers/scsi/bfa/bfad_attr.c
index 9129ae3040ff..6a2efdd5ef24 100644
--- a/drivers/scsi/bfa/bfad_attr.c
+++ b/drivers/scsi/bfa/bfad_attr.c
@@ -19,6 +19,7 @@
  *  bfa_attr.c Linux driver configuration interface module.
  */
 
+#include <linux/slab.h>
 #include "bfad_drv.h"
 #include "bfad_im.h"
 #include "bfad_trcmod.h"
@@ -141,7 +142,7 @@ bfad_im_get_host_port_type(struct Scsi_Host *shost)
         struct bfad_s         *bfad = im_port->bfad;
         struct bfa_pport_attr_s attr;
 
-        bfa_pport_get_attr(&bfad->bfa, &attr);
+        bfa_fcport_get_attr(&bfad->bfa, &attr);
 
         switch (attr.port_type) {
         case BFA_PPORT_TYPE_NPORT:
@@ -173,7 +174,7 @@ bfad_im_get_host_port_state(struct Scsi_Host *shost)
         struct bfad_s         *bfad = im_port->bfad;
         struct bfa_pport_attr_s attr;
 
-        bfa_pport_get_attr(&bfad->bfa, &attr);
+        bfa_fcport_get_attr(&bfad->bfa, &attr);
 
         switch (attr.port_state) {
         case BFA_PPORT_ST_LINKDOWN:
@@ -229,8 +230,10 @@ bfad_im_get_host_speed(struct Scsi_Host *shost)
                         (struct bfad_im_port_s *) shost->hostdata[0];
         struct bfad_s         *bfad = im_port->bfad;
         struct bfa_pport_attr_s attr;
+        unsigned long   flags;
 
-        bfa_pport_get_attr(&bfad->bfa, &attr);
+        spin_lock_irqsave(shost->host_lock, flags);
+        bfa_fcport_get_attr(&bfad->bfa, &attr);
         switch (attr.speed) {
         case BFA_PPORT_SPEED_8GBPS:
                 fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
@@ -248,6 +251,7 @@ bfad_im_get_host_speed(struct Scsi_Host *shost)
                 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
                 break;
         }
+        spin_unlock_irqrestore(shost->host_lock, flags);
 }
 
 /**
@@ -285,7 +289,7 @@ bfad_im_get_stats(struct Scsi_Host *shost)
         init_completion(&fcomp.comp);
         spin_lock_irqsave(&bfad->bfad_lock, flags);
         memset(hstats, 0, sizeof(struct fc_host_statistics));
-        rc = bfa_pport_get_stats(&bfad->bfa,
+        rc =  bfa_port_get_stats(BFA_FCPORT(&bfad->bfa),
                                      (union bfa_pport_stats_u *) hstats,
                                      bfad_hcb_comp, &fcomp);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
@@ -312,7 +316,8 @@ bfad_im_reset_stats(struct Scsi_Host *shost)
 
         init_completion(&fcomp.comp);
         spin_lock_irqsave(&bfad->bfad_lock, flags);
-        rc = bfa_pport_clear_stats(&bfad->bfa, bfad_hcb_comp, &fcomp);
+        rc = bfa_port_clear_stats(BFA_FCPORT(&bfad->bfa), bfad_hcb_comp,
+                &fcomp);
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
 
         if (rc != BFA_STATUS_OK)
@@ -421,12 +426,10 @@ bfad_im_serial_num_show(struct device *dev, struct device_attribute *attr,
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
         struct bfad_s         *bfad = im_port->bfad;
-        struct bfa_ioc_attr_s  ioc_attr;
+        char serial_num[BFA_ADAPTER_SERIAL_NUM_LEN];
 
-        memset(&ioc_attr, 0, sizeof(ioc_attr));
-        bfa_get_attr(&bfad->bfa, &ioc_attr);
-        return snprintf(buf, PAGE_SIZE, "%s\n",
-                        ioc_attr.adapter_attr.serial_num);
+        bfa_get_adapter_serial_num(&bfad->bfa, serial_num);
+        return snprintf(buf, PAGE_SIZE, "%s\n", serial_num);
 }
 
 static ssize_t
@@ -437,11 +440,10 @@ bfad_im_model_show(struct device *dev, struct device_attribute *attr,
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
         struct bfad_s         *bfad = im_port->bfad;
-        struct bfa_ioc_attr_s  ioc_attr;
+        char model[BFA_ADAPTER_MODEL_NAME_LEN];
 
-        memset(&ioc_attr, 0, sizeof(ioc_attr));
-        bfa_get_attr(&bfad->bfa, &ioc_attr);
-        return snprintf(buf, PAGE_SIZE, "%s\n", ioc_attr.adapter_attr.model);
+        bfa_get_adapter_model(&bfad->bfa, model);
+        return snprintf(buf, PAGE_SIZE, "%s\n", model);
 }
 
 static ssize_t
@@ -452,12 +454,10 @@ bfad_im_model_desc_show(struct device *dev, struct device_attribute *attr,
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
         struct bfad_s         *bfad = im_port->bfad;
-        struct bfa_ioc_attr_s  ioc_attr;
+        char model_descr[BFA_ADAPTER_MODEL_DESCR_LEN];
 
-        memset(&ioc_attr, 0, sizeof(ioc_attr));
-        bfa_get_attr(&bfad->bfa, &ioc_attr);
-        return snprintf(buf, PAGE_SIZE, "%s\n",
-                        ioc_attr.adapter_attr.model_descr);
+        bfa_get_adapter_model(&bfad->bfa, model_descr);
+        return snprintf(buf, PAGE_SIZE, "%s\n", model_descr);
 }
 
 static ssize_t
@@ -482,14 +482,13 @@ bfad_im_symbolic_name_show(struct device *dev, struct device_attribute *attr,
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
         struct bfad_s         *bfad = im_port->bfad;
-        struct bfa_ioc_attr_s  ioc_attr;
-
-        memset(&ioc_attr, 0, sizeof(ioc_attr));
-        bfa_get_attr(&bfad->bfa, &ioc_attr);
+        char model[BFA_ADAPTER_MODEL_NAME_LEN];
+        char fw_ver[BFA_VERSION_LEN];
 
+        bfa_get_adapter_model(&bfad->bfa, model);
+        bfa_get_adapter_fw_ver(&bfad->bfa, fw_ver);
         return snprintf(buf, PAGE_SIZE, "Brocade %s FV%s DV%s\n",
-                        ioc_attr.adapter_attr.model,
-                        ioc_attr.adapter_attr.fw_ver, BFAD_DRIVER_VERSION);
+                model, fw_ver, BFAD_DRIVER_VERSION);
 }
 
 static ssize_t
@@ -500,11 +499,10 @@ bfad_im_hw_version_show(struct device *dev, struct device_attribute *attr,
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
         struct bfad_s         *bfad = im_port->bfad;
-        struct bfa_ioc_attr_s  ioc_attr;
+        char hw_ver[BFA_VERSION_LEN];
 
-        memset(&ioc_attr, 0, sizeof(ioc_attr));
-        bfa_get_attr(&bfad->bfa, &ioc_attr);
-        return snprintf(buf, PAGE_SIZE, "%s\n", ioc_attr.adapter_attr.hw_ver);
+        bfa_get_pci_chip_rev(&bfad->bfa, hw_ver);
+        return snprintf(buf, PAGE_SIZE, "%s\n", hw_ver);
 }
 
 static ssize_t
@@ -522,12 +520,10 @@ bfad_im_optionrom_version_show(struct device *dev,
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
         struct bfad_s         *bfad = im_port->bfad;
-        struct bfa_ioc_attr_s  ioc_attr;
+        char optrom_ver[BFA_VERSION_LEN];
 
-        memset(&ioc_attr, 0, sizeof(ioc_attr));
-        bfa_get_attr(&bfad->bfa, &ioc_attr);
-        return snprintf(buf, PAGE_SIZE, "%s\n",
-                        ioc_attr.adapter_attr.optrom_ver);
+        bfa_get_adapter_optrom_ver(&bfad->bfa, optrom_ver);
+        return snprintf(buf, PAGE_SIZE, "%s\n", optrom_ver);
 }
 
 static ssize_t
@@ -538,11 +534,10 @@ bfad_im_fw_version_show(struct device *dev, struct device_attribute *attr,
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
         struct bfad_s         *bfad = im_port->bfad;
-        struct bfa_ioc_attr_s  ioc_attr;
+        char fw_ver[BFA_VERSION_LEN];
 
-        memset(&ioc_attr, 0, sizeof(ioc_attr));
-        bfa_get_attr(&bfad->bfa, &ioc_attr);
-        return snprintf(buf, PAGE_SIZE, "%s\n", ioc_attr.adapter_attr.fw_ver);
+        bfa_get_adapter_fw_ver(&bfad->bfa, fw_ver);
+        return snprintf(buf, PAGE_SIZE, "%s\n", fw_ver);
 }
 
 static ssize_t
@@ -553,11 +548,9 @@ bfad_im_num_of_ports_show(struct device *dev, struct device_attribute *attr,
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
         struct bfad_s         *bfad = im_port->bfad;
-        struct bfa_ioc_attr_s  ioc_attr;
 
-        memset(&ioc_attr, 0, sizeof(ioc_attr));
-        bfa_get_attr(&bfad->bfa, &ioc_attr);
-        return snprintf(buf, PAGE_SIZE, "%d\n", ioc_attr.adapter_attr.nports);
+        return snprintf(buf, PAGE_SIZE, "%d\n",
+                bfa_get_nports(&bfad->bfa));
 }
 
 static ssize_t
diff --git a/drivers/scsi/bfa/bfad_attr.h b/drivers/scsi/bfa/bfad_attr.h
index 4d3312da6a81..bf0102076508 100644
--- a/drivers/scsi/bfa/bfad_attr.h
+++ b/drivers/scsi/bfa/bfad_attr.h
@@ -17,9 +17,6 @@
 
 #ifndef __BFAD_ATTR_H__
 #define __BFAD_ATTR_H__
-/**
- *  bfad_attr.h VMware driver configuration interface module.
- */
 
 /**
  *  FC_transport_template FC transport template
@@ -52,12 +49,6 @@ bfad_im_get_starget_port_name(struct scsi_target *starget);
 void
 bfad_im_get_host_port_id(struct Scsi_Host *shost);
 
-/**
- * FC transport template entry, issue a LIP.
- */
-int
-bfad_im_issue_fc_host_lip(struct Scsi_Host *shost);
-
 struct Scsi_Host*
 bfad_os_starget_to_shost(struct scsi_target *starget);
 
diff --git a/drivers/scsi/bfa/bfad_drv.h b/drivers/scsi/bfa/bfad_drv.h
index 172c81e25c1c..107848cd3b6d 100644
--- a/drivers/scsi/bfa/bfad_drv.h
+++ b/drivers/scsi/bfa/bfad_drv.h
@@ -46,7 +46,7 @@
 #ifdef BFA_DRIVER_VERSION
 #define BFAD_DRIVER_VERSION    BFA_DRIVER_VERSION
 #else
-#define BFAD_DRIVER_VERSION    "2.0.0.0"
+#define BFAD_DRIVER_VERSION    "2.1.2.1"
 #endif
 
 
@@ -62,7 +62,9 @@
 #define BFAD_HAL_START_DONE                     0x00000010
 #define BFAD_PORT_ONLINE                        0x00000020
 #define BFAD_RPORT_ONLINE                       0x00000040
-
+#define BFAD_FCS_INIT_DONE                      0x00000080
+#define BFAD_HAL_INIT_FAIL                      0x00000100
+#define BFAD_FC4_PROBE_DONE                     0x00000200
 #define BFAD_PORT_DELETE                        0x00000001
 
 /*
@@ -137,12 +139,16 @@ struct bfad_cfg_param_s {
         u32        binding_method;
 };
 
-#define BFAD_AEN_MAX_APPS 8
-struct bfad_aen_file_s {
-        struct list_head  qe;
-        struct bfad_s *bfad;
-        s32 ri;
-        s32 app_id;
+union bfad_tmp_buf {
+        /* From struct bfa_adapter_attr_s */
+        char            manufacturer[BFA_ADAPTER_MFG_NAME_LEN];
+        char            serial_num[BFA_ADAPTER_SERIAL_NUM_LEN];
+        char            model[BFA_ADAPTER_MODEL_NAME_LEN];
+        char            fw_ver[BFA_VERSION_LEN];
+        char            optrom_ver[BFA_VERSION_LEN];
+
+        /* From struct bfa_ioc_pci_attr_s */
+        u8         chip_rev[BFA_IOC_CHIP_REV_LEN];  /*  chip revision */
 };
 
 /*
@@ -168,6 +174,7 @@ struct bfad_s {
         u32        inst_no;     /* BFAD instance number */
         u32        bfad_flags;
         spinlock_t      bfad_lock;
+        struct task_struct *bfad_tsk;
         struct bfad_cfg_param_s cfg_data;
         struct bfad_msix_s msix_tab[MAX_MSIX_ENTRY];
         int             nvec;
@@ -183,18 +190,12 @@ struct bfad_s {
         struct bfa_log_mod_s  *logmod;
         struct bfa_aen_s      *aen;
         struct bfa_aen_s       aen_buf;
-        struct bfad_aen_file_s file_buf[BFAD_AEN_MAX_APPS];
-        struct list_head         file_q;
-        struct list_head         file_free_q;
+        void            *file_map[BFA_AEN_MAX_APP];
         struct bfa_plog_s      plog_buf;
         int             ref_count;
         bfa_boolean_t   ipfc_enabled;
+        union bfad_tmp_buf tmp_buf;
         struct fc_host_statistics link_stats;
-
-        struct kobject *bfa_kobj;
-        struct kobject *ioc_kobj;
-        struct kobject *pport_kobj;
-        struct kobject *lport_kobj;
 };
 
 /*
@@ -258,6 +259,7 @@ bfa_status_t    bfad_vf_create(struct bfad_s *bfad, u16 vf_id,
                                struct bfa_port_cfg_s *port_cfg);
 bfa_status_t    bfad_cfg_pport(struct bfad_s *bfad, enum bfa_port_role role);
 bfa_status_t    bfad_drv_init(struct bfad_s *bfad);
+bfa_status_t    bfad_start_ops(struct bfad_s *bfad);
 void            bfad_drv_start(struct bfad_s *bfad);
 void            bfad_uncfg_pport(struct bfad_s *bfad);
 void            bfad_drv_stop(struct bfad_s *bfad);
@@ -279,6 +281,7 @@ void		bfad_drv_uninit(struct bfad_s *bfad);
 void            bfad_drv_log_level_set(struct bfad_s *bfad);
 bfa_status_t    bfad_fc4_module_init(void);
 void            bfad_fc4_module_exit(void);
+int             bfad_worker (void *ptr);
 
 void bfad_pci_remove(struct pci_dev *pdev);
 int bfad_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pid);
diff --git a/drivers/scsi/bfa/bfad_fwimg.c b/drivers/scsi/bfa/bfad_fwimg.c
index bd34b0db2d6b..2ad65f275a92 100644
--- a/drivers/scsi/bfa/bfad_fwimg.c
+++ b/drivers/scsi/bfa/bfad_fwimg.c
@@ -65,10 +65,10 @@ bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
         memcpy(*bfi_image, fw->data, fw->size);
         *bfi_image_size = fw->size/sizeof(u32);
 
-        return(*bfi_image);
+        return *bfi_image;
 
 error:
-        return(NULL);
+        return NULL;
 }
 
 u32 *
@@ -78,12 +78,12 @@ bfad_get_firmware_buf(struct pci_dev *pdev)
                 if (bfi_image_ct_size == 0)
                         bfad_read_firmware(pdev, &bfi_image_ct,
                                 &bfi_image_ct_size, BFAD_FW_FILE_CT);
-                return(bfi_image_ct);
+                return bfi_image_ct;
         } else {
                 if (bfi_image_cb_size == 0)
                         bfad_read_firmware(pdev, &bfi_image_cb,
                                 &bfi_image_cb_size, BFAD_FW_FILE_CB);
-                return(bfi_image_cb);
+                return bfi_image_cb;
         }
 }
 
diff --git a/drivers/scsi/bfa/bfad_im.c b/drivers/scsi/bfa/bfad_im.c
index 55d012a9a668..78f42aa57369 100644
--- a/drivers/scsi/bfa/bfad_im.c
+++ b/drivers/scsi/bfa/bfad_im.c
@@ -19,6 +19,7 @@
  *  bfad_im.c Linux driver IM module.
  */
 
+#include <linux/slab.h>
 #include "bfad_drv.h"
 #include "bfad_im.h"
 #include "bfad_trcmod.h"
@@ -43,11 +44,11 @@ bfa_cb_ioim_done(void *drv, struct bfad_ioim_s *dio,
         struct bfad_s         *bfad = drv;
         struct bfad_itnim_data_s *itnim_data;
         struct bfad_itnim_s *itnim;
+        u8         host_status = DID_OK;
 
         switch (io_status) {
         case BFI_IOIM_STS_OK:
                 bfa_trc(bfad, scsi_status);
-                cmnd->result = ScsiResult(DID_OK, scsi_status);
                 scsi_set_resid(cmnd, 0);
 
                 if (sns_len > 0) {
@@ -56,8 +57,18 @@ bfa_cb_ioim_done(void *drv, struct bfad_ioim_s *dio,
                                 sns_len = SCSI_SENSE_BUFFERSIZE;
                         memcpy(cmnd->sense_buffer, sns_info, sns_len);
                 }
-                if (residue > 0)
+                if (residue > 0) {
+                        bfa_trc(bfad, residue);
                         scsi_set_resid(cmnd, residue);
+                        if (!sns_len && (scsi_status == SAM_STAT_GOOD) &&
+                                (scsi_bufflen(cmnd) - residue) <
+                                        cmnd->underflow) {
+                                bfa_trc(bfad, 0);
+                                host_status = DID_ERROR;
+                        }
+                }
+                cmnd->result = ScsiResult(host_status, scsi_status);
+
                 break;
 
         case BFI_IOIM_STS_ABORTED:
@@ -167,17 +178,15 @@ bfad_im_info(struct Scsi_Host *shost)
         static char     bfa_buf[256];
         struct bfad_im_port_s *im_port =
                         (struct bfad_im_port_s *) shost->hostdata[0];
-        struct bfa_ioc_attr_s  ioc_attr;
         struct bfad_s         *bfad = im_port->bfad;
+        char model[BFA_ADAPTER_MODEL_NAME_LEN];
 
-        memset(&ioc_attr, 0, sizeof(ioc_attr));
-        bfa_get_attr(&bfad->bfa, &ioc_attr);
+        bfa_get_adapter_model(&bfad->bfa, model);
 
         memset(bfa_buf, 0, sizeof(bfa_buf));
         snprintf(bfa_buf, sizeof(bfa_buf),
-                 "Brocade FC/FCOE Adapter, " "model: %s hwpath: %s driver: %s",
-                 ioc_attr.adapter_attr.model, bfad->pci_name,
-                 BFAD_DRIVER_VERSION);
+                "Brocade FC/FCOE Adapter, " "model: %s hwpath: %s driver: %s",
+                model, bfad->pci_name, BFAD_DRIVER_VERSION);
         return bfa_buf;
 }
 
@@ -501,16 +510,6 @@ void bfa_fcb_itnim_tov(struct bfad_itnim_s *itnim)
 }
 
 /**
- * Path TOV processing begin notification -- dummy for linux
- */
-void
-bfa_fcb_itnim_tov_begin(struct bfad_itnim_s *itnim)
-{
-}
-
-
-
-/**
  * Allocate a Scsi_Host for a port.
  */
 int
@@ -931,10 +930,9 @@ bfad_os_fc_host_init(struct bfad_im_port_s *im_port)
         struct Scsi_Host *host = im_port->shost;
         struct bfad_s         *bfad = im_port->bfad;
         struct bfad_port_s    *port = im_port->port;
-        union attr {
-                struct bfa_pport_attr_s pattr;
-                struct bfa_ioc_attr_s  ioc_attr;
-        } attr;
+        struct bfa_pport_attr_s pattr;
+        char model[BFA_ADAPTER_MODEL_NAME_LEN];
+        char fw_ver[BFA_VERSION_LEN];
 
         fc_host_node_name(host) =
                 bfa_os_htonll((bfa_fcs_port_get_nwwn(port->fcs_port)));
@@ -954,20 +952,18 @@ bfad_os_fc_host_init(struct bfad_im_port_s *im_port)
         /* For fibre channel services type 0x20 */
         fc_host_supported_fc4s(host)[7] = 1;
 
-        memset(&attr.ioc_attr, 0, sizeof(attr.ioc_attr));
-        bfa_get_attr(&bfad->bfa, &attr.ioc_attr);
+        bfa_get_adapter_model(&bfad->bfa, model);
+        bfa_get_adapter_fw_ver(&bfad->bfa, fw_ver);
         sprintf(fc_host_symbolic_name(host), "Brocade %s FV%s DV%s",
-                attr.ioc_attr.adapter_attr.model,
-                attr.ioc_attr.adapter_attr.fw_ver, BFAD_DRIVER_VERSION);
+                model, fw_ver, BFAD_DRIVER_VERSION);
 
         fc_host_supported_speeds(host) = 0;
         fc_host_supported_speeds(host) |=
                 FC_PORTSPEED_8GBIT | FC_PORTSPEED_4GBIT | FC_PORTSPEED_2GBIT |
                 FC_PORTSPEED_1GBIT;
 
-        memset(&attr.pattr, 0, sizeof(attr.pattr));
-        bfa_pport_get_attr(&bfad->bfa, &attr.pattr);
-        fc_host_maxframe_size(host) = attr.pattr.pport_cfg.maxfrsize;
+        bfa_fcport_get_attr(&bfad->bfa, &pattr);
+        fc_host_maxframe_size(host) = pattr.pport_cfg.maxfrsize;
 }
 
 static void
@@ -1050,7 +1046,7 @@ bfad_im_itnim_work_handler(struct work_struct *work)
                 } else {
                         printk(KERN_WARNING
                                 "%s: itnim %llx is already in online state\n",
-                                __FUNCTION__,
+                                __func__,
                                 bfa_fcs_itnim_get_pwwn(&itnim->fcs_itnim));
                 }
 
diff --git a/drivers/scsi/bfa/bfad_im.h b/drivers/scsi/bfa/bfad_im.h
index 189a5b29e21a..85ab2da21321 100644
--- a/drivers/scsi/bfa/bfad_im.h
+++ b/drivers/scsi/bfa/bfad_im.h
@@ -23,7 +23,6 @@
 
 #define FCPI_NAME " fcpim"
 
-void bfad_flags_set(struct bfad_s *bfad, u32 flags);
 bfa_status_t bfad_im_module_init(void);
 void bfad_im_module_exit(void);
 bfa_status_t bfad_im_probe(struct bfad_s *bfad);
@@ -126,7 +125,6 @@ bfa_status_t bfad_os_thread_workq(struct bfad_s *bfad);
 void bfad_os_destroy_workq(struct bfad_im_s *im);
 void bfad_os_itnim_process(struct bfad_itnim_s *itnim_drv);
 void bfad_os_fc_host_init(struct bfad_im_port_s *im_port);
-void bfad_os_init_work(struct bfad_im_port_s *im_port);
 void bfad_os_scsi_host_free(struct bfad_s *bfad,
                                  struct bfad_im_port_s *im_port);
 void bfad_os_ramp_up_qdepth(struct bfad_itnim_s *itnim,
@@ -136,9 +134,6 @@ struct bfad_itnim_s *bfad_os_get_itnim(struct bfad_im_port_s *im_port, int id);
 int bfad_os_scsi_add_host(struct Scsi_Host *shost,
                 struct bfad_im_port_s *im_port, struct bfad_s *bfad);
 
-/*
- * scsi_host_template entries
- */
 void bfad_im_itnim_unmap(struct bfad_im_port_s  *im_port,
                          struct bfad_itnim_s *itnim);
 
diff --git a/drivers/scsi/bfa/bfad_im_compat.h b/drivers/scsi/bfa/bfad_im_compat.h
index 1d3e74ec338c..b36be15044a4 100644
--- a/drivers/scsi/bfa/bfad_im_compat.h
+++ b/drivers/scsi/bfa/bfad_im_compat.h
@@ -31,7 +31,7 @@ u32 *bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
 static inline u32 *
 bfad_load_fwimg(struct pci_dev *pdev)
 {
-        return(bfad_get_firmware_buf(pdev));
+        return bfad_get_firmware_buf(pdev);
 }
 
 static inline void
diff --git a/drivers/scsi/bfa/bfad_intr.c b/drivers/scsi/bfa/bfad_intr.c
index f104e029cac9..2b7dbecbebca 100644
--- a/drivers/scsi/bfa/bfad_intr.c
+++ b/drivers/scsi/bfa/bfad_intr.c
@@ -23,13 +23,14 @@ BFA_TRC_FILE(LDRV, INTR);
 /**
  *  bfa_isr BFA driver interrupt functions
  */
-irqreturn_t bfad_intx(int irq, void *dev_id);
-static int msix_disable;
-module_param(msix_disable, int, S_IRUGO | S_IWUSR);
+static int msix_disable_cb;
+static int msix_disable_ct;
+module_param(msix_disable_cb, int, S_IRUGO | S_IWUSR);
+module_param(msix_disable_ct, int, S_IRUGO | S_IWUSR);
 /**
  * Line based interrupt handler.
  */
-irqreturn_t
+static irqreturn_t
 bfad_intx(int irq, void *dev_id)
 {
         struct bfad_s         *bfad = dev_id;
@@ -142,6 +143,7 @@ bfad_setup_intr(struct bfad_s *bfad)
         int error = 0;
         u32 mask = 0, i, num_bit = 0, max_bit = 0;
         struct msix_entry msix_entries[MAX_MSIX_ENTRY];
+        struct pci_dev *pdev = bfad->pcidev;
 
         /* Call BFA to get the msix map for this PCI function.  */
         bfa_msix_getvecs(&bfad->bfa, &mask, &num_bit, &max_bit);
@@ -149,7 +151,9 @@ bfad_setup_intr(struct bfad_s *bfad)
         /* Set up the msix entry table */
         bfad_init_msix_entry(bfad, msix_entries, mask, max_bit);
 
-        if (!msix_disable) {
+        if ((pdev->device == BFA_PCI_DEVICE_ID_CT && !msix_disable_ct) ||
+            (pdev->device != BFA_PCI_DEVICE_ID_CT && !msix_disable_cb)) {
+
                 error = pci_enable_msix(bfad->pcidev, msix_entries, bfad->nvec);
                 if (error) {
                         /*
diff --git a/drivers/scsi/bfa/fabric.c b/drivers/scsi/bfa/fabric.c
index a8b14c47b009..8166e9745ec0 100644
--- a/drivers/scsi/bfa/fabric.c
+++ b/drivers/scsi/bfa/fabric.c
@@ -36,12 +36,12 @@ BFA_TRC_FILE(FCS, FABRIC);
 #define BFA_FCS_FABRIC_RETRY_DELAY      (2000)  /* Milliseconds */
 #define BFA_FCS_FABRIC_CLEANUP_DELAY    (10000) /* Milliseconds */
 
-#define bfa_fcs_fabric_set_opertype(__fabric) do {          \
-    if (bfa_pport_get_topology((__fabric)->fcs->bfa)    \
-                                == BFA_PPORT_TOPOLOGY_P2P)   \
-            (__fabric)->oper_type = BFA_PPORT_TYPE_NPORT;       \
-    else                                                    \
-            (__fabric)->oper_type = BFA_PPORT_TYPE_NLPORT;      \
+#define bfa_fcs_fabric_set_opertype(__fabric) do {             \
+        if (bfa_fcport_get_topology((__fabric)->fcs->bfa)       \
+                                == BFA_PPORT_TOPOLOGY_P2P)     \
+                (__fabric)->oper_type = BFA_PPORT_TYPE_NPORT;  \
+        else                                                   \
+                (__fabric)->oper_type = BFA_PPORT_TYPE_NLPORT; \
 } while (0)
 
 /*
@@ -136,8 +136,7 @@ bfa_fcs_fabric_sm_uninit(struct bfa_fcs_fabric_s *fabric,
         case BFA_FCS_FABRIC_SM_CREATE:
                 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_created);
                 bfa_fcs_fabric_init(fabric);
-                bfa_fcs_lport_init(&fabric->bport, fabric->fcs, FC_VF_ID_NULL,
-                                   &fabric->bport.port_cfg, NULL);
+                bfa_fcs_lport_init(&fabric->bport, &fabric->bport.port_cfg);
                 break;
 
         case BFA_FCS_FABRIC_SM_LINK_UP:
@@ -161,7 +160,7 @@ bfa_fcs_fabric_sm_created(struct bfa_fcs_fabric_s *fabric,
 
         switch (event) {
         case BFA_FCS_FABRIC_SM_START:
-                if (bfa_pport_is_linkup(fabric->fcs->bfa)) {
+                if (bfa_fcport_is_linkup(fabric->fcs->bfa)) {
                         bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_flogi);
                         bfa_fcs_fabric_login(fabric);
                 } else
@@ -225,7 +224,7 @@ bfa_fcs_fabric_sm_flogi(struct bfa_fcs_fabric_s *fabric,
         switch (event) {
         case BFA_FCS_FABRIC_SM_CONT_OP:
 
-                bfa_pport_set_tx_bbcredit(fabric->fcs->bfa, fabric->bb_credit);
+                bfa_fcport_set_tx_bbcredit(fabric->fcs->bfa, fabric->bb_credit);
                 fabric->fab_type = BFA_FCS_FABRIC_SWITCHED;
 
                 if (fabric->auth_reqd && fabric->is_auth) {
@@ -252,7 +251,7 @@ bfa_fcs_fabric_sm_flogi(struct bfa_fcs_fabric_s *fabric,
 
         case BFA_FCS_FABRIC_SM_NO_FABRIC:
                 fabric->fab_type = BFA_FCS_FABRIC_N2N;
-                bfa_pport_set_tx_bbcredit(fabric->fcs->bfa, fabric->bb_credit);
+                bfa_fcport_set_tx_bbcredit(fabric->fcs->bfa, fabric->bb_credit);
                 bfa_fcs_fabric_notify_online(fabric);
                 bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_nofabric);
                 break;
@@ -419,7 +418,7 @@ bfa_fcs_fabric_sm_nofabric(struct bfa_fcs_fabric_s *fabric,
 
         case BFA_FCS_FABRIC_SM_NO_FABRIC:
                 bfa_trc(fabric->fcs, fabric->bb_credit);
-                bfa_pport_set_tx_bbcredit(fabric->fcs->bfa, fabric->bb_credit);
+                bfa_fcport_set_tx_bbcredit(fabric->fcs->bfa, fabric->bb_credit);
                 break;
 
         default:
@@ -563,17 +562,15 @@ void
 bfa_fcs_fabric_psymb_init(struct bfa_fcs_fabric_s *fabric)
 {
         struct bfa_port_cfg_s *port_cfg = &fabric->bport.port_cfg;
-        struct bfa_adapter_attr_s adapter_attr;
+        char            model[BFA_ADAPTER_MODEL_NAME_LEN] = {0};
         struct bfa_fcs_driver_info_s *driver_info = &fabric->fcs->driver_info;
 
-        bfa_os_memset((void *)&adapter_attr, 0,
-                      sizeof(struct bfa_adapter_attr_s));
-        bfa_ioc_get_adapter_attr(&fabric->fcs->bfa->ioc, &adapter_attr);
+        bfa_ioc_get_adapter_model(&fabric->fcs->bfa->ioc, model);
 
         /*
          * Model name/number
          */
-        strncpy((char *)&port_cfg->sym_name, adapter_attr.model,
+        strncpy((char *)&port_cfg->sym_name, model,
                 BFA_FCS_PORT_SYMBNAME_MODEL_SZ);
         strncat((char *)&port_cfg->sym_name, BFA_FCS_PORT_SYMBNAME_SEPARATOR,
                 sizeof(BFA_FCS_PORT_SYMBNAME_SEPARATOR));
@@ -719,10 +716,10 @@ bfa_fcs_fabric_login(struct bfa_fcs_fabric_s *fabric)
         struct bfa_port_cfg_s *pcfg = &fabric->bport.port_cfg;
         u8         alpa = 0;
 
-        if (bfa_pport_get_topology(bfa) == BFA_PPORT_TOPOLOGY_LOOP)
-                alpa = bfa_pport_get_myalpa(bfa);
+        if (bfa_fcport_get_topology(bfa) == BFA_PPORT_TOPOLOGY_LOOP)
+                alpa = bfa_fcport_get_myalpa(bfa);
 
-        bfa_lps_flogi(fabric->lps, fabric, alpa, bfa_pport_get_maxfrsize(bfa),
+        bfa_lps_flogi(fabric->lps, fabric, alpa, bfa_fcport_get_maxfrsize(bfa),
                       pcfg->pwwn, pcfg->nwwn, fabric->auth_reqd);
 
         fabric->stats.flogi_sent++;
@@ -814,10 +811,10 @@ bfa_fcs_fabric_delete_comp(void *cbarg)
  */
 
 /**
- *   Module initialization
+ *   Attach time initialization
  */
 void
-bfa_fcs_fabric_modinit(struct bfa_fcs_s *fcs)
+bfa_fcs_fabric_attach(struct bfa_fcs_s *fcs)
 {
         struct bfa_fcs_fabric_s *fabric;
 
@@ -841,7 +838,13 @@ bfa_fcs_fabric_modinit(struct bfa_fcs_s *fcs)
         bfa_wc_up(&fabric->wc); /* For the base port */
 
         bfa_sm_set_state(fabric, bfa_fcs_fabric_sm_uninit);
-        bfa_sm_send_event(fabric, BFA_FCS_FABRIC_SM_CREATE);
+        bfa_fcs_lport_attach(&fabric->bport, fabric->fcs, FC_VF_ID_NULL, NULL);
+}
+
+void
+bfa_fcs_fabric_modinit(struct bfa_fcs_s *fcs)
+{
+        bfa_sm_send_event(&fcs->fabric, BFA_FCS_FABRIC_SM_CREATE);
         bfa_trc(fcs, 0);
 }
 
@@ -887,7 +890,13 @@ bfa_fcs_fabric_modsusp(struct bfa_fcs_s *fcs)
 bfa_boolean_t
 bfa_fcs_fabric_is_loopback(struct bfa_fcs_fabric_s *fabric)
 {
-        return (bfa_sm_cmp_state(fabric, bfa_fcs_fabric_sm_loopback));
+        return bfa_sm_cmp_state(fabric, bfa_fcs_fabric_sm_loopback);
+}
+
+bfa_boolean_t
+bfa_fcs_fabric_is_auth_failed(struct bfa_fcs_fabric_s *fabric)
+{
+        return bfa_sm_cmp_state(fabric, bfa_fcs_fabric_sm_auth_failed);
 }
 
 enum bfa_pport_type
@@ -974,7 +983,7 @@ bfa_fcs_fabric_port_delete_comp(struct bfa_fcs_fabric_s *fabric)
 int
 bfa_fcs_fabric_is_online(struct bfa_fcs_fabric_s *fabric)
 {
-        return (bfa_sm_cmp_state(fabric, bfa_fcs_fabric_sm_online));
+        return bfa_sm_cmp_state(fabric, bfa_fcs_fabric_sm_online);
 }
 
 
@@ -1015,7 +1024,7 @@ bfa_fcs_fabric_vport_lookup(struct bfa_fcs_fabric_s *fabric, wwn_t pwwn)
 u16
 bfa_fcs_fabric_vport_count(struct bfa_fcs_fabric_s *fabric)
 {
-        return (fabric->num_vports);
+        return fabric->num_vports;
 }
 
 /**
@@ -1165,8 +1174,8 @@ bfa_fcs_fabric_send_flogi_acc(struct bfa_fcs_fabric_s *fabric)
         reqlen = fc_flogi_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
                                     bfa_os_hton3b(FC_FABRIC_PORT),
                                     n2n_port->reply_oxid, pcfg->pwwn,
-                                    pcfg->nwwn, bfa_pport_get_maxfrsize(bfa),
-                                    bfa_pport_get_rx_bbcredit(bfa));
+                                    pcfg->nwwn, bfa_fcport_get_maxfrsize(bfa),
+                                    bfa_fcport_get_rx_bbcredit(bfa));
 
         bfa_fcxp_send(fcxp, NULL, fabric->vf_id, bfa_lps_get_tag(fabric->lps),
                         BFA_FALSE, FC_CLASS_3, reqlen, &fchs,
@@ -1224,14 +1233,8 @@ bfa_fcs_fabric_aen_post(struct bfa_fcs_port_s *port,
         wwn2str(pwwn_ptr, pwwn);
         wwn2str(fwwn_ptr, fwwn);
 
-        switch (event) {
-        case BFA_PORT_AEN_FABRIC_NAME_CHANGE:
-                bfa_log(logmod, BFA_AEN_PORT_FABRIC_NAME_CHANGE, pwwn_ptr,
-                        fwwn_ptr);
-                break;
-        default:
-                break;
-        }
+        bfa_log(logmod, BFA_LOG_CREATE_ID(BFA_AEN_CAT_PORT, event),
+                pwwn_ptr, fwwn_ptr);
 
         aen_data.port.pwwn = pwwn;
         aen_data.port.fwwn = fwwn;
diff --git a/drivers/scsi/bfa/fcbuild.c b/drivers/scsi/bfa/fcbuild.c
index d174706b9caa..fee5456451cb 100644
--- a/drivers/scsi/bfa/fcbuild.c
+++ b/drivers/scsi/bfa/fcbuild.c
@@ -188,14 +188,14 @@ fc_els_rsp_parse(struct fchs_s *fchs, int len)
         switch (els_cmd->els_code) {
         case FC_ELS_LS_RJT:
                 if (ls_rjt->reason_code == FC_LS_RJT_RSN_LOGICAL_BUSY)
-                        return (FC_PARSE_BUSY);
+                        return FC_PARSE_BUSY;
                 else
-                        return (FC_PARSE_FAILURE);
+                        return FC_PARSE_FAILURE;
 
         case FC_ELS_ACC:
-                return (FC_PARSE_OK);
+                return FC_PARSE_OK;
         }
-        return (FC_PARSE_OK);
+        return FC_PARSE_OK;
 }
 
 static void
@@ -228,7 +228,7 @@ fc_plogi_x_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id,
         bfa_os_memcpy(&plogi->port_name, &port_name, sizeof(wwn_t));
         bfa_os_memcpy(&plogi->node_name, &node_name, sizeof(wwn_t));
 
-        return (sizeof(struct fc_logi_s));
+        return sizeof(struct fc_logi_s);
 }
 
 u16
@@ -267,7 +267,7 @@ fc_flogi_build(struct fchs_s *fchs, struct fc_logi_s *flogi, u32 s_id,
         flogi->csp.npiv_supp    = 1; /* @todo. field name is not correct */
         vvl_info[0]     = bfa_os_htonl(FLOGI_VVL_BRCD);
 
-        return (sizeof(struct fc_logi_s));
+        return sizeof(struct fc_logi_s);
 }
 
 u16
@@ -287,7 +287,7 @@ fc_flogi_acc_build(struct fchs_s *fchs, struct fc_logi_s *flogi, u32 s_id,
 
         flogi->csp.bbcred = bfa_os_htons(local_bb_credits);
 
-        return (sizeof(struct fc_logi_s));
+        return sizeof(struct fc_logi_s);
 }
 
 u16
@@ -306,7 +306,7 @@ fc_fdisc_build(struct fchs_s *fchs, struct fc_logi_s *flogi, u32 s_id,
         flogi->port_name = port_name;
         flogi->node_name = node_name;
 
-        return (sizeof(struct fc_logi_s));
+        return sizeof(struct fc_logi_s);
 }
 
 u16
@@ -338,26 +338,26 @@ fc_plogi_rsp_parse(struct fchs_s *fchs, int len, wwn_t port_name)
         case FC_ELS_LS_RJT:
                 ls_rjt = (struct fc_ls_rjt_s *) (fchs + 1);
                 if (ls_rjt->reason_code == FC_LS_RJT_RSN_LOGICAL_BUSY)
-                        return (FC_PARSE_BUSY);
+                        return FC_PARSE_BUSY;
                 else
-                        return (FC_PARSE_FAILURE);
+                        return FC_PARSE_FAILURE;
         case FC_ELS_ACC:
                 plogi = (struct fc_logi_s *) (fchs + 1);
                 if (len < sizeof(struct fc_logi_s))
-                        return (FC_PARSE_FAILURE);
+                        return FC_PARSE_FAILURE;
 
                 if (!wwn_is_equal(plogi->port_name, port_name))
-                        return (FC_PARSE_FAILURE);
+                        return FC_PARSE_FAILURE;
 
                 if (!plogi->class3.class_valid)
-                        return (FC_PARSE_FAILURE);
+                        return FC_PARSE_FAILURE;
 
                 if (bfa_os_ntohs(plogi->class3.rxsz) < (FC_MIN_PDUSZ))
-                        return (FC_PARSE_FAILURE);
+                        return FC_PARSE_FAILURE;
 
-                return (FC_PARSE_OK);
+                return FC_PARSE_OK;
         default:
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
         }
 }
 
@@ -372,7 +372,7 @@ fc_plogi_parse(struct fchs_s *fchs)
         if ((bfa_os_ntohs(plogi->class3.rxsz) < FC_MIN_PDUSZ)
             || (bfa_os_ntohs(plogi->class3.rxsz) > FC_MAX_PDUSZ)
             || (plogi->class3.rxsz == 0))
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
         return FC_PARSE_OK;
 }
@@ -393,7 +393,7 @@ fc_prli_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id,
         prli->parampage.servparams.task_retry_id = 0;
         prli->parampage.servparams.confirm       = 1;
 
-        return (sizeof(struct fc_prli_s));
+        return sizeof(struct fc_prli_s);
 }
 
 u16
@@ -414,41 +414,41 @@ fc_prli_acc_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id,
 
         prli->parampage.rspcode = FC_PRLI_ACC_XQTD;
 
-        return (sizeof(struct fc_prli_s));
+        return sizeof(struct fc_prli_s);
 }
 
 enum fc_parse_status
 fc_prli_rsp_parse(struct fc_prli_s *prli, int len)
 {
         if (len < sizeof(struct fc_prli_s))
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
         if (prli->command != FC_ELS_ACC)
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
         if ((prli->parampage.rspcode != FC_PRLI_ACC_XQTD)
             && (prli->parampage.rspcode != FC_PRLI_ACC_PREDEF_IMG))
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
         if (prli->parampage.servparams.target != 1)
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
-        return (FC_PARSE_OK);
+        return FC_PARSE_OK;
 }
 
 enum fc_parse_status
 fc_prli_parse(struct fc_prli_s *prli)
 {
         if (prli->parampage.type != FC_TYPE_FCP)
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
         if (!prli->parampage.imagepair)
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
         if (!prli->parampage.servparams.initiator)
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
-        return (FC_PARSE_OK);
+        return FC_PARSE_OK;
 }
 
 u16
@@ -462,7 +462,7 @@ fc_logo_build(struct fchs_s *fchs, struct fc_logo_s *logo, u32 d_id,
         logo->nport_id = (s_id);
         logo->orig_port_name = port_name;
 
-        return (sizeof(struct fc_logo_s));
+        return sizeof(struct fc_logo_s);
 }
 
 static          u16
@@ -484,7 +484,7 @@ fc_adisc_x_build(struct fchs_s *fchs, struct fc_adisc_s *adisc, u32 d_id,
         adisc->orig_node_name = node_name;
         adisc->nport_id = (s_id);
 
-        return (sizeof(struct fc_adisc_s));
+        return sizeof(struct fc_adisc_s);
 }
 
 u16
@@ -511,15 +511,15 @@ fc_adisc_rsp_parse(struct fc_adisc_s *adisc, int len, wwn_t port_name,
 {
 
         if (len < sizeof(struct fc_adisc_s))
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
         if (adisc->els_cmd.els_code != FC_ELS_ACC)
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
         if (!wwn_is_equal(adisc->orig_port_name, port_name))
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
-        return (FC_PARSE_OK);
+        return FC_PARSE_OK;
 }
 
 enum fc_parse_status
@@ -529,14 +529,14 @@ fc_adisc_parse(struct fchs_s *fchs, void *pld, u32 host_dap,
         struct fc_adisc_s     *adisc = (struct fc_adisc_s *) pld;
 
         if (adisc->els_cmd.els_code != FC_ELS_ACC)
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
         if ((adisc->nport_id == (host_dap))
             && wwn_is_equal(adisc->orig_port_name, port_name)
             && wwn_is_equal(adisc->orig_node_name, node_name))
-                return (FC_PARSE_OK);
+                return FC_PARSE_OK;
 
-        return (FC_PARSE_FAILURE);
+        return FC_PARSE_FAILURE;
 }
 
 enum fc_parse_status
@@ -550,13 +550,13 @@ fc_pdisc_parse(struct fchs_s *fchs, wwn_t node_name, wwn_t port_name)
         if ((bfa_os_ntohs(pdisc->class3.rxsz) <
                  (FC_MIN_PDUSZ - sizeof(struct fchs_s)))
             || (pdisc->class3.rxsz == 0))
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
         if (!wwn_is_equal(pdisc->port_name, port_name))
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
         if (!wwn_is_equal(pdisc->node_name, node_name))
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
         return FC_PARSE_OK;
 }
@@ -570,7 +570,7 @@ fc_abts_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id)
         fchs->s_id = (s_id);
         fchs->ox_id = bfa_os_htons(ox_id);
 
-        return (sizeof(struct fchs_s));
+        return sizeof(struct fchs_s);
 }
 
 enum fc_parse_status
@@ -578,9 +578,9 @@ fc_abts_rsp_parse(struct fchs_s *fchs, int len)
 {
         if ((fchs->cat_info == FC_CAT_BA_ACC)
             || (fchs->cat_info == FC_CAT_BA_RJT))
-                return (FC_PARSE_OK);
+                return FC_PARSE_OK;
 
-        return (FC_PARSE_FAILURE);
+        return FC_PARSE_FAILURE;
 }
 
 u16
@@ -597,7 +597,7 @@ fc_rrq_build(struct fchs_s *fchs, struct fc_rrq_s *rrq, u32 d_id,
         rrq->ox_id = bfa_os_htons(rrq_oxid);
         rrq->rx_id = FC_RXID_ANY;
 
-        return (sizeof(struct fc_rrq_s));
+        return sizeof(struct fc_rrq_s);
 }
 
 u16
@@ -611,7 +611,7 @@ fc_logo_acc_build(struct fchs_s *fchs, void *pld, u32 d_id, u32 s_id,
         memset(acc, 0, sizeof(struct fc_els_cmd_s));
         acc->els_code = FC_ELS_ACC;
 
-        return (sizeof(struct fc_els_cmd_s));
+        return sizeof(struct fc_els_cmd_s);
 }
 
 u16
@@ -627,7 +627,7 @@ fc_ls_rjt_build(struct fchs_s *fchs, struct fc_ls_rjt_s *ls_rjt, u32 d_id,
         ls_rjt->reason_code_expl = reason_code_expl;
         ls_rjt->vendor_unique = 0x00;
 
-        return (sizeof(struct fc_ls_rjt_s));
+        return sizeof(struct fc_ls_rjt_s);
 }
 
 u16
@@ -643,7 +643,7 @@ fc_ba_acc_build(struct fchs_s *fchs, struct fc_ba_acc_s *ba_acc, u32 d_id,
         ba_acc->ox_id = fchs->ox_id;
         ba_acc->rx_id = fchs->rx_id;
 
-        return (sizeof(struct fc_ba_acc_s));
+        return sizeof(struct fc_ba_acc_s);
 }
 
 u16
@@ -654,7 +654,7 @@ fc_ls_acc_build(struct fchs_s *fchs, struct fc_els_cmd_s *els_cmd,
         memset(els_cmd, 0, sizeof(struct fc_els_cmd_s));
         els_cmd->els_code = FC_ELS_ACC;
 
-        return (sizeof(struct fc_els_cmd_s));
+        return sizeof(struct fc_els_cmd_s);
 }
 
 int
@@ -696,7 +696,7 @@ fc_tprlo_acc_build(struct fchs_s *fchs, struct fc_tprlo_acc_s *tprlo_acc,
                 tprlo_acc->tprlo_acc_params[page].orig_process_assc = 0;
                 tprlo_acc->tprlo_acc_params[page].resp_process_assc = 0;
         }
-        return (bfa_os_ntohs(tprlo_acc->payload_len));
+        return bfa_os_ntohs(tprlo_acc->payload_len);
 }
 
 u16
@@ -721,7 +721,7 @@ fc_prlo_acc_build(struct fchs_s *fchs, struct fc_prlo_acc_s *prlo_acc,
                 prlo_acc->prlo_acc_params[page].resp_process_assc = 0;
         }
 
-        return (bfa_os_ntohs(prlo_acc->payload_len));
+        return bfa_os_ntohs(prlo_acc->payload_len);
 }
 
 u16
@@ -735,7 +735,7 @@ fc_rnid_build(struct fchs_s *fchs, struct fc_rnid_cmd_s *rnid, u32 d_id,
         rnid->els_cmd.els_code = FC_ELS_RNID;
         rnid->node_id_data_format = data_format;
 
-        return (sizeof(struct fc_rnid_cmd_s));
+        return sizeof(struct fc_rnid_cmd_s);
 }
 
 u16
@@ -759,10 +759,10 @@ fc_rnid_acc_build(struct fchs_s *fchs, struct fc_rnid_acc_s *rnid_acc,
                 rnid_acc->specific_id_data_length =
                         sizeof(struct fc_rnid_general_topology_data_s);
                 bfa_os_assign(rnid_acc->gen_topology_data, *gen_topo_data);
-                return (sizeof(struct fc_rnid_acc_s));
+                return sizeof(struct fc_rnid_acc_s);
         } else {
-                return (sizeof(struct fc_rnid_acc_s) -
-                        sizeof(struct fc_rnid_general_topology_data_s));
+                return sizeof(struct fc_rnid_acc_s) -
+                        sizeof(struct fc_rnid_general_topology_data_s);
         }
 
 }
@@ -776,7 +776,7 @@ fc_rpsc_build(struct fchs_s *fchs, struct fc_rpsc_cmd_s *rpsc, u32 d_id,
         memset(rpsc, 0, sizeof(struct fc_rpsc_cmd_s));
 
         rpsc->els_cmd.els_code = FC_ELS_RPSC;
-        return (sizeof(struct fc_rpsc_cmd_s));
+        return sizeof(struct fc_rpsc_cmd_s);
 }
 
 u16
@@ -797,8 +797,8 @@ fc_rpsc2_build(struct fchs_s *fchs, struct fc_rpsc2_cmd_s *rpsc2,
         for (i = 0; i < npids; i++)
                 rpsc2->pid_list[i].pid = pid_list[i];
 
-        return (sizeof(struct fc_rpsc2_cmd_s) + ((npids - 1) *
-                        (sizeof(u32))));
+        return sizeof(struct fc_rpsc2_cmd_s) + ((npids - 1) *
+                        (sizeof(u32)));
 }
 
 u16
@@ -819,7 +819,7 @@ fc_rpsc_acc_build(struct fchs_s *fchs, struct fc_rpsc_acc_s *rpsc_acc,
         rpsc_acc->speed_info[0].port_op_speed =
                 bfa_os_htons(oper_speed->port_op_speed);
 
-        return (sizeof(struct fc_rpsc_acc_s));
+        return sizeof(struct fc_rpsc_acc_s);
 
 }
 
@@ -856,7 +856,7 @@ fc_pdisc_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
         pdisc->port_name = port_name;
         pdisc->node_name = node_name;
 
-        return (sizeof(struct fc_logi_s));
+        return sizeof(struct fc_logi_s);
 }
 
 u16
@@ -865,21 +865,21 @@ fc_pdisc_rsp_parse(struct fchs_s *fchs, int len, wwn_t port_name)
         struct fc_logi_s     *pdisc = (struct fc_logi_s *) (fchs + 1);
 
         if (len < sizeof(struct fc_logi_s))
-                return (FC_PARSE_LEN_INVAL);
+                return FC_PARSE_LEN_INVAL;
 
         if (pdisc->els_cmd.els_code != FC_ELS_ACC)
-                return (FC_PARSE_ACC_INVAL);
+                return FC_PARSE_ACC_INVAL;
 
         if (!wwn_is_equal(pdisc->port_name, port_name))
-                return (FC_PARSE_PWWN_NOT_EQUAL);
+                return FC_PARSE_PWWN_NOT_EQUAL;
 
         if (!pdisc->class3.class_valid)
-                return (FC_PARSE_NWWN_NOT_EQUAL);
+                return FC_PARSE_NWWN_NOT_EQUAL;
 
         if (bfa_os_ntohs(pdisc->class3.rxsz) < (FC_MIN_PDUSZ))
-                return (FC_PARSE_RXSZ_INVAL);
+                return FC_PARSE_RXSZ_INVAL;
 
-        return (FC_PARSE_OK);
+        return FC_PARSE_OK;
 }
 
 u16
@@ -903,7 +903,7 @@ fc_prlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id, u16 ox_id,
                 prlo->prlo_params[page].resp_process_assc = 0;
         }
 
-        return (bfa_os_ntohs(prlo->payload_len));
+        return bfa_os_ntohs(prlo->payload_len);
 }
 
 u16
@@ -916,7 +916,7 @@ fc_prlo_rsp_parse(struct fchs_s *fchs, int len)
         len = len;
 
         if (prlo->command != FC_ELS_ACC)
-                return (FC_PARSE_FAILURE);
+                return FC_PARSE_FAILURE;
 
         num_pages = ((bfa_os_ntohs(prlo->payload_len)) - 4) / 16;
 
@@ -936,7 +936,7 @@ fc_prlo_rsp_parse(struct fchs_s *fchs, int len)
                 if (prlo->prlo_acc_params[page].resp_process_assc != 0)
                         return FC_PARSE_FAILURE;
         }
-        return (FC_PARSE_OK);
+        return FC_PARSE_OK;
 
 }
 
@@ -968,7 +968,7 @@ fc_tprlo_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
                 }
         }
 
-        return (bfa_os_ntohs(tprlo->payload_len));
+        return bfa_os_ntohs(tprlo->payload_len);
 }
 
 u16
@@ -981,23 +981,23 @@ fc_tprlo_rsp_parse(struct fchs_s *fchs, int len)
         len = len;
 
         if (tprlo->command != FC_ELS_ACC)
-                return (FC_PARSE_ACC_INVAL);
+                return FC_PARSE_ACC_INVAL;
 
         num_pages = (bfa_os_ntohs(tprlo->payload_len) - 4) / 16;
 
         for (page = 0; page < num_pages; page++) {
                 if (tprlo->tprlo_acc_params[page].type != FC_TYPE_FCP)
-                        return (FC_PARSE_NOT_FCP);
+                        return FC_PARSE_NOT_FCP;
                 if (tprlo->tprlo_acc_params[page].opa_valid != 0)
-                        return (FC_PARSE_OPAFLAG_INVAL);
+                        return FC_PARSE_OPAFLAG_INVAL;
                 if (tprlo->tprlo_acc_params[page].rpa_valid != 0)
-                        return (FC_PARSE_RPAFLAG_INVAL);
+                        return FC_PARSE_RPAFLAG_INVAL;
                 if (tprlo->tprlo_acc_params[page].orig_process_assc != 0)
-                        return (FC_PARSE_OPA_INVAL);
+                        return FC_PARSE_OPA_INVAL;
                 if (tprlo->tprlo_acc_params[page].resp_process_assc != 0)
-                        return (FC_PARSE_RPA_INVAL);
+                        return FC_PARSE_RPA_INVAL;
         }
-        return (FC_PARSE_OK);
+        return FC_PARSE_OK;
 }
 
 enum fc_parse_status
@@ -1024,7 +1024,7 @@ fc_ba_rjt_build(struct fchs_s *fchs, u32 d_id, u32 s_id,
         fchs->cat_info = FC_CAT_BA_RJT;
         ba_rjt->reason_code = reason_code;
         ba_rjt->reason_expl = reason_expl;
-        return (sizeof(struct fc_ba_rjt_s));
+        return sizeof(struct fc_ba_rjt_s);
 }
 
 static void
@@ -1073,7 +1073,7 @@ fc_gidpn_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
 
         bfa_os_memset(gidpn, 0, sizeof(struct fcgs_gidpn_req_s));
         gidpn->port_name = port_name;
-        return (sizeof(struct fcgs_gidpn_req_s) + sizeof(struct ct_hdr_s));
+        return sizeof(struct fcgs_gidpn_req_s) + sizeof(struct ct_hdr_s);
 }
 
 u16
@@ -1090,7 +1090,7 @@ fc_gpnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
 
         bfa_os_memset(gpnid, 0, sizeof(fcgs_gpnid_req_t));
         gpnid->dap = port_id;
-        return (sizeof(fcgs_gpnid_req_t) + sizeof(struct ct_hdr_s));
+        return sizeof(fcgs_gpnid_req_t) + sizeof(struct ct_hdr_s);
 }
 
 u16
@@ -1107,7 +1107,7 @@ fc_gnnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
 
         bfa_os_memset(gnnid, 0, sizeof(fcgs_gnnid_req_t));
         gnnid->dap = port_id;
-        return (sizeof(fcgs_gnnid_req_t) + sizeof(struct ct_hdr_s));
+        return sizeof(fcgs_gnnid_req_t) + sizeof(struct ct_hdr_s);
 }
 
 u16
@@ -1137,7 +1137,7 @@ fc_scr_build(struct fchs_s *fchs, struct fc_scr_s *scr, u8 set_br_reg,
         if (set_br_reg)
                 scr->vu_reg_func = FC_VU_SCR_REG_FUNC_FABRIC_NAME_CHANGE;
 
-        return (sizeof(struct fc_scr_s));
+        return sizeof(struct fc_scr_s);
 }
 
 u16
@@ -1157,7 +1157,7 @@ fc_rscn_build(struct fchs_s *fchs, struct fc_rscn_pl_s *rscn, u32 s_id,
         rscn->event[0].format = FC_RSCN_FORMAT_PORTID;
         rscn->event[0].portid = s_id;
 
-        return (sizeof(struct fc_rscn_pl_s));
+        return sizeof(struct fc_rscn_pl_s);
 }
 
 u16
@@ -1188,7 +1188,7 @@ fc_rftid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
                 rftid->fc4_type[index] |= bfa_os_htonl(type_value);
         }
 
-        return (sizeof(struct fcgs_rftid_req_s) + sizeof(struct ct_hdr_s));
+        return sizeof(struct fcgs_rftid_req_s) + sizeof(struct ct_hdr_s);
 }
 
 u16
@@ -1210,7 +1210,7 @@ fc_rftid_build_sol(struct fchs_s *fchs, void *pyld, u32 s_id,
         bfa_os_memcpy((void *)rftid->fc4_type, (void *)fc4_bitmap,
                         (bitmap_size < 32 ? bitmap_size : 32));
 
-        return (sizeof(struct fcgs_rftid_req_s) + sizeof(struct ct_hdr_s));
+        return sizeof(struct fcgs_rftid_req_s) + sizeof(struct ct_hdr_s);
 }
 
 u16
@@ -1231,7 +1231,7 @@ fc_rffid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
         rffid->fc4ftr_bits  = fc4_ftrs;
         rffid->fc4_type         = fc4_type;
 
-        return (sizeof(struct fcgs_rffid_req_s) + sizeof(struct ct_hdr_s));
+        return sizeof(struct fcgs_rffid_req_s) + sizeof(struct ct_hdr_s);
 }
 
 u16
@@ -1253,7 +1253,7 @@ fc_rspnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u16 ox_id,
         rspnid->spn_len = (u8) strlen((char *)name);
         strncpy((char *)rspnid->spn, (char *)name, rspnid->spn_len);
 
-        return (sizeof(struct fcgs_rspnid_req_s) + sizeof(struct ct_hdr_s));
+        return sizeof(struct fcgs_rspnid_req_s) + sizeof(struct ct_hdr_s);
 }
 
 u16
@@ -1275,7 +1275,7 @@ fc_gid_ft_build(struct fchs_s *fchs, void *pyld, u32 s_id,
         gidft->domain_id = 0;
         gidft->area_id = 0;
 
-        return (sizeof(struct fcgs_gidft_req_s) + sizeof(struct ct_hdr_s));
+        return sizeof(struct fcgs_gidft_req_s) + sizeof(struct ct_hdr_s);
 }
 
 u16
@@ -1294,7 +1294,7 @@ fc_rpnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
         rpnid->port_id = port_id;
         rpnid->port_name = port_name;
 
-        return (sizeof(struct fcgs_rpnid_req_s) + sizeof(struct ct_hdr_s));
+        return sizeof(struct fcgs_rpnid_req_s) + sizeof(struct ct_hdr_s);
 }
 
 u16
@@ -1313,7 +1313,7 @@ fc_rnnid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
         rnnid->port_id = port_id;
         rnnid->node_name = node_name;
 
-        return (sizeof(struct fcgs_rnnid_req_s) + sizeof(struct ct_hdr_s));
+        return sizeof(struct fcgs_rnnid_req_s) + sizeof(struct ct_hdr_s);
 }
 
 u16
@@ -1332,7 +1332,7 @@ fc_rcsid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
         rcsid->port_id = port_id;
         rcsid->cos = cos;
 
-        return (sizeof(struct fcgs_rcsid_req_s) + sizeof(struct ct_hdr_s));
+        return sizeof(struct fcgs_rcsid_req_s) + sizeof(struct ct_hdr_s);
 }
 
 u16
@@ -1351,7 +1351,7 @@ fc_rptid_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id,
         rptid->port_id = port_id;
         rptid->port_type = port_type;
 
-        return (sizeof(struct fcgs_rptid_req_s) + sizeof(struct ct_hdr_s));
+        return sizeof(struct fcgs_rptid_req_s) + sizeof(struct ct_hdr_s);
 }
 
 u16
@@ -1368,7 +1368,7 @@ fc_ganxt_build(struct fchs_s *fchs, void *pyld, u32 s_id, u32 port_id)
         bfa_os_memset(ganxt, 0, sizeof(struct fcgs_ganxt_req_s));
         ganxt->port_id = port_id;
 
-        return (sizeof(struct ct_hdr_s) + sizeof(struct fcgs_ganxt_req_s));
+        return sizeof(struct ct_hdr_s) + sizeof(struct fcgs_ganxt_req_s);
 }
 
 /*
@@ -1385,7 +1385,7 @@ fc_fdmi_reqhdr_build(struct fchs_s *fchs, void *pyld, u32 s_id,
         fc_gs_fchdr_build(fchs, d_id, s_id, 0);
         fc_gs_fdmi_cthdr_build(cthdr, s_id, cmd_code);
 
-        return (sizeof(struct ct_hdr_s));
+        return sizeof(struct ct_hdr_s);
 }
 
 /*
@@ -1425,7 +1425,7 @@ fc_gmal_req_build(struct fchs_s *fchs, void *pyld, u32 s_id, wwn_t wwn)
         bfa_os_memset(gmal, 0, sizeof(fcgs_gmal_req_t));
         gmal->wwn = wwn;
 
-        return (sizeof(struct ct_hdr_s) + sizeof(fcgs_gmal_req_t));
+        return sizeof(struct ct_hdr_s) + sizeof(fcgs_gmal_req_t);
 }
 
 /*
@@ -1445,5 +1445,5 @@ fc_gfn_req_build(struct fchs_s *fchs, void *pyld, u32 s_id, wwn_t wwn)
         bfa_os_memset(gfn, 0, sizeof(fcgs_gfn_req_t));
         gfn->wwn = wwn;
 
-        return (sizeof(struct ct_hdr_s) + sizeof(fcgs_gfn_req_t));
+        return sizeof(struct ct_hdr_s) + sizeof(fcgs_gfn_req_t);
 }
diff --git a/drivers/scsi/bfa/fcbuild.h b/drivers/scsi/bfa/fcbuild.h
index 4d248424f7b3..981d98d542b9 100644
--- a/drivers/scsi/bfa/fcbuild.h
+++ b/drivers/scsi/bfa/fcbuild.h
@@ -32,8 +32,8 @@
  * Utility Macros/functions
  */
 
-#define fcif_sof_set(_ifhdr, _sof)      (_ifhdr)->sof = FC_ ## _sof
-#define fcif_eof_set(_ifhdr, _eof)      (_ifhdr)->eof = FC_ ## _eof
+#define fcif_sof_set(_ifhdr, _sof)      ((_ifhdr)->sof = FC_ ## _sof)
+#define fcif_eof_set(_ifhdr, _eof)      ((_ifhdr)->eof = FC_ ## _eof)
 
 #define wwn_is_equal(_wwn1, _wwn2)              \
         (memcmp(&(_wwn1), &(_wwn2), sizeof(wwn_t)) == 0)
@@ -49,7 +49,7 @@
 static inline   u32
 fc_get_ctresp_pyld_len(u32 resp_len)
 {
-        return (resp_len - sizeof(struct ct_hdr_s));
+        return resp_len - sizeof(struct ct_hdr_s);
 }
 
 /*
@@ -72,6 +72,9 @@ fc_rpsc_operspeed_to_bfa_speed(enum fc_rpsc_op_speed_s speed)
         case RPSC_OP_SPEED_8G:
                 return BFA_PPORT_SPEED_8GBPS;
 
+        case RPSC_OP_SPEED_10G:
+                return BFA_PPORT_SPEED_10GBPS;
+
         default:
                 return BFA_PPORT_SPEED_UNKNOWN;
         }
@@ -97,6 +100,9 @@ fc_bfa_speed_to_rpsc_operspeed(enum bfa_pport_speed op_speed)
         case BFA_PPORT_SPEED_8GBPS:
                 return RPSC_OP_SPEED_8G;
 
+        case BFA_PPORT_SPEED_10GBPS:
+                return RPSC_OP_SPEED_10G;
+
         default:
                 return RPSC_OP_SPEED_NOT_EST;
         }
diff --git a/drivers/scsi/bfa/fcpim.c b/drivers/scsi/bfa/fcpim.c
index 8ce5d8934677..8ae4a2cfa85b 100644
--- a/drivers/scsi/bfa/fcpim.c
+++ b/drivers/scsi/bfa/fcpim.c
@@ -126,7 +126,7 @@ bfa_fcs_itnim_sm_offline(struct bfa_fcs_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->fcs, event);
         }
 
 }
@@ -161,7 +161,7 @@ bfa_fcs_itnim_sm_prli_send(struct bfa_fcs_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->fcs, event);
         }
 }
 
@@ -205,7 +205,7 @@ bfa_fcs_itnim_sm_prli(struct bfa_fcs_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->fcs, event);
         }
 }
 
@@ -240,7 +240,7 @@ bfa_fcs_itnim_sm_prli_retry(struct bfa_fcs_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->fcs, event);
         }
 }
 
@@ -270,7 +270,7 @@ bfa_fcs_itnim_sm_hcb_online(struct bfa_fcs_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->fcs, event);
         }
 }
 
@@ -286,11 +286,10 @@ bfa_fcs_itnim_sm_online(struct bfa_fcs_itnim_s *itnim,
                 bfa_sm_set_state(itnim, bfa_fcs_itnim_sm_hcb_offline);
                 bfa_fcb_itnim_offline(itnim->itnim_drv);
                 bfa_itnim_offline(itnim->bfa_itnim);
-                if (bfa_fcs_port_is_online(itnim->rport->port) == BFA_TRUE) {
+                if (bfa_fcs_port_is_online(itnim->rport->port) == BFA_TRUE)
                         bfa_fcs_itnim_aen_post(itnim, BFA_ITNIM_AEN_DISCONNECT);
-                } else {
+                else
                         bfa_fcs_itnim_aen_post(itnim, BFA_ITNIM_AEN_OFFLINE);
-                }
                 break;
 
         case BFA_FCS_ITNIM_SM_DELETE:
@@ -299,7 +298,7 @@ bfa_fcs_itnim_sm_online(struct bfa_fcs_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->fcs, event);
         }
 }
 
@@ -322,7 +321,7 @@ bfa_fcs_itnim_sm_hcb_offline(struct bfa_fcs_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->fcs, event);
         }
 }
 
@@ -355,7 +354,7 @@ bfa_fcs_itnim_sm_initiator(struct bfa_fcs_itnim_s *itnim,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(itnim->fcs, event);
         }
 }
 
@@ -386,19 +385,8 @@ bfa_fcs_itnim_aen_post(struct bfa_fcs_itnim_s *itnim,
         wwn2str(lpwwn_ptr, lpwwn);
         wwn2str(rpwwn_ptr, rpwwn);
 
-        switch (event) {
-        case BFA_ITNIM_AEN_ONLINE:
-                bfa_log(logmod, BFA_AEN_ITNIM_ONLINE, rpwwn_ptr, lpwwn_ptr);
-                break;
-        case BFA_ITNIM_AEN_OFFLINE:
-                bfa_log(logmod, BFA_AEN_ITNIM_OFFLINE, rpwwn_ptr, lpwwn_ptr);
-                break;
-        case BFA_ITNIM_AEN_DISCONNECT:
-                bfa_log(logmod, BFA_AEN_ITNIM_DISCONNECT, rpwwn_ptr, lpwwn_ptr);
-                break;
-        default:
-                break;
-        }
+        bfa_log(logmod, BFA_LOG_CREATE_ID(BFA_AEN_CAT_ITNIM, event),
+                rpwwn_ptr, lpwwn_ptr);
 
         aen_data.itnim.vf_id = rport->port->fabric->vf_id;
         aen_data.itnim.ppwwn =
@@ -690,7 +678,6 @@ bfa_cb_itnim_tov_begin(void *cb_arg)
         struct bfa_fcs_itnim_s *itnim = (struct bfa_fcs_itnim_s *)cb_arg;
 
         bfa_trc(itnim->fcs, itnim->rport->pwwn);
-        bfa_fcb_itnim_tov_begin(itnim->itnim_drv);
 }
 
 /**
@@ -732,7 +719,7 @@ bfa_fcs_itnim_lookup(struct bfa_fcs_port_s *port, wwn_t rpwwn)
                 return NULL;
 
         bfa_assert(rport->itnim != NULL);
-        return (rport->itnim);
+        return rport->itnim;
 }
 
 bfa_status_t
@@ -823,22 +810,3 @@ void
 bfa_fcs_itnim_resume(struct bfa_fcs_itnim_s *itnim)
 {
 }
-
-/**
- *   Module initialization
- */
-void
-bfa_fcs_fcpim_modinit(struct bfa_fcs_s *fcs)
-{
-}
-
-/**
- *   Module cleanup
- */
-void
-bfa_fcs_fcpim_modexit(struct bfa_fcs_s *fcs)
-{
-        bfa_fcs_modexit_comp(fcs);
-}
-
-
diff --git a/drivers/scsi/bfa/fcs.h b/drivers/scsi/bfa/fcs.h
index deee685e8478..8d08230e6295 100644
--- a/drivers/scsi/bfa/fcs.h
+++ b/drivers/scsi/bfa/fcs.h
@@ -23,7 +23,7 @@
 #ifndef __FCS_H__
 #define __FCS_H__
 
-#define __fcs_min_cfg(__fcs)       (__fcs)->min_cfg
+#define __fcs_min_cfg(__fcs)       ((__fcs)->min_cfg)
 
 void bfa_fcs_modexit_comp(struct bfa_fcs_s *fcs);
 
diff --git a/drivers/scsi/bfa/fcs_fabric.h b/drivers/scsi/bfa/fcs_fabric.h
index eee960820f86..244c3f00c50c 100644
--- a/drivers/scsi/bfa/fcs_fabric.h
+++ b/drivers/scsi/bfa/fcs_fabric.h
@@ -29,6 +29,7 @@
 /*
 * fcs friend functions: only between fcs modules
  */
+void            bfa_fcs_fabric_attach(struct bfa_fcs_s *fcs);
 void            bfa_fcs_fabric_modinit(struct bfa_fcs_s *fcs);
 void            bfa_fcs_fabric_modexit(struct bfa_fcs_s *fcs);
 void            bfa_fcs_fabric_modsusp(struct bfa_fcs_s *fcs);
@@ -46,6 +47,7 @@ void            bfa_fcs_fabric_uf_recv(struct bfa_fcs_fabric_s *fabric,
                         struct fchs_s *fchs, u16 len);
 u16        bfa_fcs_fabric_vport_count(struct bfa_fcs_fabric_s *fabric);
 bfa_boolean_t   bfa_fcs_fabric_is_loopback(struct bfa_fcs_fabric_s *fabric);
+bfa_boolean_t   bfa_fcs_fabric_is_auth_failed(struct bfa_fcs_fabric_s *fabric);
 enum bfa_pport_type bfa_fcs_fabric_port_type(struct bfa_fcs_fabric_s *fabric);
 void            bfa_fcs_fabric_psymb_init(struct bfa_fcs_fabric_s *fabric);
 void bfa_fcs_fabric_port_delete_comp(struct bfa_fcs_fabric_s *fabric);
diff --git a/drivers/scsi/bfa/fcs_fcpim.h b/drivers/scsi/bfa/fcs_fcpim.h
index 61e9e2687de3..11e6e7bce9f6 100644
--- a/drivers/scsi/bfa/fcs_fcpim.h
+++ b/drivers/scsi/bfa/fcs_fcpim.h
@@ -34,11 +34,6 @@ void bfa_fcs_itnim_is_initiator(struct bfa_fcs_itnim_s *itnim);
 void bfa_fcs_itnim_pause(struct bfa_fcs_itnim_s *itnim);
 void bfa_fcs_itnim_resume(struct bfa_fcs_itnim_s *itnim);
 
-/*
- * Modudle init/cleanup routines.
- */
-void bfa_fcs_fcpim_modinit(struct bfa_fcs_s *fcs);
-void bfa_fcs_fcpim_modexit(struct bfa_fcs_s *fcs);
 void bfa_fcs_fcpim_uf_recv(struct bfa_fcs_itnim_s *itnim, struct fchs_s *fchs,
                         u16 len);
 #endif /* __FCS_FCPIM_H__ */
diff --git a/drivers/scsi/bfa/fcs_lport.h b/drivers/scsi/bfa/fcs_lport.h
index ae744ba35671..a6508c8ab184 100644
--- a/drivers/scsi/bfa/fcs_lport.h
+++ b/drivers/scsi/bfa/fcs_lport.h
@@ -84,9 +84,10 @@ void bfa_fcs_port_uf_recv(struct bfa_fcs_port_s *lport, struct fchs_s *fchs,
  * Following routines will be called by Fabric to indicate port
  * online/offline to vport.
  */
-void bfa_fcs_lport_init(struct bfa_fcs_port_s *lport, struct bfa_fcs_s *fcs,
-                        u16 vf_id, struct bfa_port_cfg_s *port_cfg,
-                        struct bfa_fcs_vport_s *vport);
+void bfa_fcs_lport_attach(struct bfa_fcs_port_s *lport, struct bfa_fcs_s *fcs,
+                        uint16_t vf_id, struct bfa_fcs_vport_s *vport);
+void bfa_fcs_lport_init(struct bfa_fcs_port_s *lport,
+                        struct bfa_port_cfg_s *port_cfg);
 void bfa_fcs_port_online(struct bfa_fcs_port_s *port);
 void bfa_fcs_port_offline(struct bfa_fcs_port_s *port);
 void bfa_fcs_port_delete(struct bfa_fcs_port_s *port);
diff --git a/drivers/scsi/bfa/fcs_port.h b/drivers/scsi/bfa/fcs_port.h
index abb65191dd27..408c06a7d164 100644
--- a/drivers/scsi/bfa/fcs_port.h
+++ b/drivers/scsi/bfa/fcs_port.h
@@ -26,7 +26,6 @@
 /*
  * fcs friend functions: only between fcs modules
  */
-void bfa_fcs_pport_modinit(struct bfa_fcs_s *fcs);
-void bfa_fcs_pport_modexit(struct bfa_fcs_s *fcs);
+void bfa_fcs_pport_attach(struct bfa_fcs_s *fcs);
 
 #endif /* __FCS_PPORT_H__ */
diff --git a/drivers/scsi/bfa/fcs_rport.h b/drivers/scsi/bfa/fcs_rport.h
index f601e9d74236..9c8d1d292380 100644
--- a/drivers/scsi/bfa/fcs_rport.h
+++ b/drivers/scsi/bfa/fcs_rport.h
@@ -24,9 +24,6 @@
 
 #include <fcs/bfa_fcs_rport.h>
 
-void bfa_fcs_rport_modinit(struct bfa_fcs_s *fcs);
-void bfa_fcs_rport_modexit(struct bfa_fcs_s *fcs);
-
 void bfa_fcs_rport_uf_recv(struct bfa_fcs_rport_s *rport, struct fchs_s *fchs,
                         u16 len);
 void bfa_fcs_rport_scn(struct bfa_fcs_rport_s *rport);
diff --git a/drivers/scsi/bfa/fcs_uf.h b/drivers/scsi/bfa/fcs_uf.h
index 96f1bdcb31ed..f591072214fe 100644
--- a/drivers/scsi/bfa/fcs_uf.h
+++ b/drivers/scsi/bfa/fcs_uf.h
@@ -26,7 +26,6 @@
 /*
  * fcs friend functions: only between fcs modules
  */
-void bfa_fcs_uf_modinit(struct bfa_fcs_s *fcs);
-void bfa_fcs_uf_modexit(struct bfa_fcs_s *fcs);
+void bfa_fcs_uf_attach(struct bfa_fcs_s *fcs);
 
 #endif /* __FCS_UF_H__ */
diff --git a/drivers/scsi/bfa/fcs_vport.h b/drivers/scsi/bfa/fcs_vport.h
index 9e80b6a97b7f..13c32ebf946c 100644
--- a/drivers/scsi/bfa/fcs_vport.h
+++ b/drivers/scsi/bfa/fcs_vport.h
@@ -22,18 +22,10 @@
 #include <fcs/bfa_fcs_vport.h>
 #include <defs/bfa_defs_pci.h>
 
-/*
- * Modudle init/cleanup routines.
- */
-
-void bfa_fcs_vport_modinit(struct bfa_fcs_s *fcs);
-void bfa_fcs_vport_modexit(struct bfa_fcs_s *fcs);
-
 void bfa_fcs_vport_cleanup(struct bfa_fcs_vport_s *vport);
 void bfa_fcs_vport_online(struct bfa_fcs_vport_s *vport);
 void bfa_fcs_vport_offline(struct bfa_fcs_vport_s *vport);
 void bfa_fcs_vport_delete_comp(struct bfa_fcs_vport_s *vport);
-u32 bfa_fcs_vport_get_max(struct bfa_fcs_s *fcs);
 
 #endif /* __FCS_VPORT_H__ */
 
diff --git a/drivers/scsi/bfa/fdmi.c b/drivers/scsi/bfa/fdmi.c
index b845eb272c78..8f17076d1a87 100644
--- a/drivers/scsi/bfa/fdmi.c
+++ b/drivers/scsi/bfa/fdmi.c
@@ -72,9 +72,9 @@ static u16 bfa_fcs_port_fdmi_build_rpa_pyld(
                         struct bfa_fcs_port_fdmi_s *fdmi, u8 *pyld);
 static u16 bfa_fcs_port_fdmi_build_portattr_block(
                         struct bfa_fcs_port_fdmi_s *fdmi, u8 *pyld);
-void bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_port_fdmi_s *fdmi,
+static void bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_port_fdmi_s *fdmi,
                         struct bfa_fcs_fdmi_hba_attr_s *hba_attr);
-void bfa_fcs_fdmi_get_portattr(struct bfa_fcs_port_fdmi_s *fdmi,
+static void bfa_fcs_fdmi_get_portattr(struct bfa_fcs_port_fdmi_s *fdmi,
                         struct bfa_fcs_fdmi_port_attr_s *port_attr);
 /**
  *  fcs_fdmi_sm FCS FDMI state machine
@@ -116,6 +116,9 @@ static void     bfa_fcs_port_fdmi_sm_rpa_retry(struct bfa_fcs_port_fdmi_s *fdmi,
                         enum port_fdmi_event event);
 static void     bfa_fcs_port_fdmi_sm_online(struct bfa_fcs_port_fdmi_s *fdmi,
                         enum port_fdmi_event event);
+static void     bfa_fcs_port_fdmi_sm_disabled(struct bfa_fcs_port_fdmi_s *fdmi,
+                        enum port_fdmi_event event);
+
 /**
  *              Start in offline state - awaiting MS to send start.
  */
@@ -155,7 +158,7 @@ bfa_fcs_port_fdmi_sm_offline(struct bfa_fcs_port_fdmi_s *fdmi,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -180,7 +183,7 @@ bfa_fcs_port_fdmi_sm_sending_rhba(struct bfa_fcs_port_fdmi_s *fdmi,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -227,7 +230,7 @@ bfa_fcs_port_fdmi_sm_rhba(struct bfa_fcs_port_fdmi_s *fdmi,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -255,7 +258,7 @@ bfa_fcs_port_fdmi_sm_rhba_retry(struct bfa_fcs_port_fdmi_s *fdmi,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -283,7 +286,7 @@ bfa_fcs_port_fdmi_sm_sending_rprt(struct bfa_fcs_port_fdmi_s *fdmi,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -328,7 +331,7 @@ bfa_fcs_port_fdmi_sm_rprt(struct bfa_fcs_port_fdmi_s *fdmi,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -356,7 +359,7 @@ bfa_fcs_port_fdmi_sm_rprt_retry(struct bfa_fcs_port_fdmi_s *fdmi,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -384,7 +387,7 @@ bfa_fcs_port_fdmi_sm_sending_rpa(struct bfa_fcs_port_fdmi_s *fdmi,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -428,7 +431,7 @@ bfa_fcs_port_fdmi_sm_rpa(struct bfa_fcs_port_fdmi_s *fdmi,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -456,7 +459,7 @@ bfa_fcs_port_fdmi_sm_rpa_retry(struct bfa_fcs_port_fdmi_s *fdmi,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
@@ -475,10 +478,24 @@ bfa_fcs_port_fdmi_sm_online(struct bfa_fcs_port_fdmi_s *fdmi,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(port->fcs, event);
         }
 }
 
+/**
+ *  FDMI is disabled state.
+ */
+static void
+bfa_fcs_port_fdmi_sm_disabled(struct bfa_fcs_port_fdmi_s *fdmi,
+                                enum port_fdmi_event event)
+{
+        struct bfa_fcs_port_s *port = fdmi->ms->port;
+
+        bfa_trc(port->fcs, port->port_cfg.pwwn);
+        bfa_trc(port->fcs, event);
+
+        /* No op State. It can only be enabled at Driver Init. */
+}
 
 /**
 *   RHBA : Register HBA Attributes.
@@ -1091,42 +1108,29 @@ bfa_fcs_port_fdmi_timeout(void *arg)
         bfa_sm_send_event(fdmi, FDMISM_EVENT_TIMEOUT);
 }
 
-void
+static void
 bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_port_fdmi_s *fdmi,
                          struct bfa_fcs_fdmi_hba_attr_s *hba_attr)
 {
         struct bfa_fcs_port_s *port = fdmi->ms->port;
         struct bfa_fcs_driver_info_s *driver_info = &port->fcs->driver_info;
-        struct bfa_adapter_attr_s adapter_attr;
 
         bfa_os_memset(hba_attr, 0, sizeof(struct bfa_fcs_fdmi_hba_attr_s));
-        bfa_os_memset(&adapter_attr, 0, sizeof(struct bfa_adapter_attr_s));
-
-        bfa_ioc_get_adapter_attr(&port->fcs->bfa->ioc, &adapter_attr);
-
-        strncpy(hba_attr->manufacturer, adapter_attr.manufacturer,
-                sizeof(adapter_attr.manufacturer));
-
-        strncpy(hba_attr->serial_num, adapter_attr.serial_num,
-                sizeof(adapter_attr.serial_num));
-
-        strncpy(hba_attr->model, adapter_attr.model, sizeof(hba_attr->model));
 
-        strncpy(hba_attr->model_desc, adapter_attr.model_descr,
-                sizeof(hba_attr->model_desc));
-
-        strncpy(hba_attr->hw_version, adapter_attr.hw_ver,
-                sizeof(hba_attr->hw_version));
+        bfa_ioc_get_adapter_manufacturer(&port->fcs->bfa->ioc,
+                hba_attr->manufacturer);
+        bfa_ioc_get_adapter_serial_num(&port->fcs->bfa->ioc,
+                                                hba_attr->serial_num);
+        bfa_ioc_get_adapter_model(&port->fcs->bfa->ioc, hba_attr->model);
+        bfa_ioc_get_adapter_model(&port->fcs->bfa->ioc, hba_attr->model_desc);
+        bfa_ioc_get_pci_chip_rev(&port->fcs->bfa->ioc, hba_attr->hw_version);
+        bfa_ioc_get_adapter_optrom_ver(&port->fcs->bfa->ioc,
+                hba_attr->option_rom_ver);
+        bfa_ioc_get_adapter_fw_ver(&port->fcs->bfa->ioc, hba_attr->fw_version);
 
         strncpy(hba_attr->driver_version, (char *)driver_info->version,
                 sizeof(hba_attr->driver_version));
 
-        strncpy(hba_attr->option_rom_ver, adapter_attr.optrom_ver,
-                sizeof(hba_attr->option_rom_ver));
-
-        strncpy(hba_attr->fw_version, adapter_attr.fw_ver,
-                sizeof(hba_attr->fw_version));
-
         strncpy(hba_attr->os_name, driver_info->host_os_name,
                 sizeof(hba_attr->os_name));
 
@@ -1145,7 +1149,7 @@ bfa_fcs_fdmi_get_hbaattr(struct bfa_fcs_port_fdmi_s *fdmi,
 
 }
 
-void
+static void
 bfa_fcs_fdmi_get_portattr(struct bfa_fcs_port_fdmi_s *fdmi,
                           struct bfa_fcs_fdmi_port_attr_s *port_attr)
 {
@@ -1158,7 +1162,7 @@ bfa_fcs_fdmi_get_portattr(struct bfa_fcs_port_fdmi_s *fdmi,
         /*
          * get pport attributes from hal
          */
-        bfa_pport_get_attr(port->fcs->bfa, &pport_attr);
+        bfa_fcport_get_attr(port->fcs->bfa, &pport_attr);
 
         /*
          * get FC4 type Bitmask
@@ -1201,7 +1205,10 @@ bfa_fcs_port_fdmi_init(struct bfa_fcs_port_ms_s *ms)
         struct bfa_fcs_port_fdmi_s *fdmi = &ms->fdmi;
 
         fdmi->ms = ms;
-        bfa_sm_set_state(fdmi, bfa_fcs_port_fdmi_sm_offline);
+        if (ms->port->fcs->fdmi_enabled)
+                bfa_sm_set_state(fdmi, bfa_fcs_port_fdmi_sm_offline);
+        else
+                bfa_sm_set_state(fdmi, bfa_fcs_port_fdmi_sm_disabled);
 }
 
 void
diff --git a/drivers/scsi/bfa/include/aen/bfa_aen.h b/drivers/scsi/bfa/include/aen/bfa_aen.h
index da8cac093d3d..6abbab005db6 100644
--- a/drivers/scsi/bfa/include/aen/bfa_aen.h
+++ b/drivers/scsi/bfa/include/aen/bfa_aen.h
@@ -18,21 +18,24 @@
 #define __BFA_AEN_H__
 
 #include "defs/bfa_defs_aen.h"
+#include "defs/bfa_defs_status.h"
+#include "cs/bfa_debug.h"
 
-#define BFA_AEN_MAX_ENTRY   512
+#define BFA_AEN_MAX_ENTRY       512
 
-extern s32 bfa_aen_max_cfg_entry;
+extern int bfa_aen_max_cfg_entry;
 struct bfa_aen_s {
         void            *bfad;
-        s32             max_entry;
-        s32             write_index;
-        s32             read_index;
-        u32     bfad_num;
-        u32     seq_num;
+        int             max_entry;
+        int             write_index;
+        int             read_index;
+        int             bfad_num;
+        int             seq_num;
         void            (*aen_cb_notify)(void *bfad);
         void            (*gettimeofday)(struct bfa_timeval_s *tv);
-        struct bfa_trc_mod_s    *trcmod;
-        struct bfa_aen_entry_s  list[BFA_AEN_MAX_ENTRY]; /* Must be the last */
+        struct bfa_trc_mod_s *trcmod;
+        int             app_ri[BFA_AEN_MAX_APP]; /* For multiclient support */
+        struct bfa_aen_entry_s list[BFA_AEN_MAX_ENTRY]; /* Must be the last */
 };
 
 
@@ -45,48 +48,49 @@ bfa_aen_set_max_cfg_entry(int max_entry)
         bfa_aen_max_cfg_entry = max_entry;
 }
 
-static inline s32
+static inline int
 bfa_aen_get_max_cfg_entry(void)
 {
         return bfa_aen_max_cfg_entry;
 }
 
-static inline s32
+static inline int
 bfa_aen_get_meminfo(void)
 {
-        return (sizeof(struct bfa_aen_entry_s) * bfa_aen_get_max_cfg_entry());
+        return sizeof(struct bfa_aen_entry_s) * bfa_aen_get_max_cfg_entry();
 }
 
-static inline s32
+static inline int
 bfa_aen_get_wi(struct bfa_aen_s *aen)
 {
         return aen->write_index;
 }
 
-static inline s32
+static inline int
 bfa_aen_get_ri(struct bfa_aen_s *aen)
 {
         return aen->read_index;
 }
 
-static inline s32
-bfa_aen_fetch_count(struct bfa_aen_s *aen, s32 read_index)
+static inline int
+bfa_aen_fetch_count(struct bfa_aen_s *aen, enum bfa_aen_app  app_id)
 {
-        return ((aen->write_index + aen->max_entry) - read_index)
+        bfa_assert((app_id < BFA_AEN_MAX_APP) && (app_id >= bfa_aen_app_bcu));
+        return ((aen->write_index + aen->max_entry) - aen->app_ri[app_id])
                 % aen->max_entry;
 }
 
-s32 bfa_aen_init(struct bfa_aen_s *aen, struct bfa_trc_mod_s *trcmod,
-                void *bfad, u32 inst_id, void (*aen_cb_notify)(void *),
+int bfa_aen_init(struct bfa_aen_s *aen, struct bfa_trc_mod_s *trcmod,
+                void *bfad, int bfad_num, void (*aen_cb_notify)(void *),
                 void (*gettimeofday)(struct bfa_timeval_s *));
 
-s32 bfa_aen_post(struct bfa_aen_s *aen, enum bfa_aen_category aen_category,
+void bfa_aen_post(struct bfa_aen_s *aen, enum bfa_aen_category aen_category,
                      int aen_type, union bfa_aen_data_u *aen_data);
 
-s32 bfa_aen_fetch(struct bfa_aen_s *aen, struct bfa_aen_entry_s *aen_entry,
-                      s32 entry_space, s32 rii, s32 *ri_arr,
-                      s32 ri_arr_cnt);
+bfa_status_t bfa_aen_fetch(struct bfa_aen_s *aen,
+                        struct bfa_aen_entry_s *aen_entry,
+                        int entry_req, enum bfa_aen_app app_id, int *entry_ret);
 
-s32 bfa_aen_get_inst(struct bfa_aen_s *aen);
+int bfa_aen_get_inst(struct bfa_aen_s *aen);
 
 #endif /* __BFA_AEN_H__ */
diff --git a/drivers/scsi/bfa/include/bfa.h b/drivers/scsi/bfa/include/bfa.h
index 64c1412c5703..1f5966cfbd16 100644
--- a/drivers/scsi/bfa/include/bfa.h
+++ b/drivers/scsi/bfa/include/bfa.h
@@ -76,11 +76,11 @@ struct bfa_meminfo_s {
         struct bfa_mem_elem_s meminfo[BFA_MEM_TYPE_MAX];
 };
 #define bfa_meminfo_kva(_m)     \
-        (_m)->meminfo[BFA_MEM_TYPE_KVA - 1].kva_curp
+        ((_m)->meminfo[BFA_MEM_TYPE_KVA - 1].kva_curp)
 #define bfa_meminfo_dma_virt(_m)        \
-        (_m)->meminfo[BFA_MEM_TYPE_DMA - 1].kva_curp
+        ((_m)->meminfo[BFA_MEM_TYPE_DMA - 1].kva_curp)
 #define bfa_meminfo_dma_phys(_m)        \
-        (_m)->meminfo[BFA_MEM_TYPE_DMA - 1].dma_curp
+        ((_m)->meminfo[BFA_MEM_TYPE_DMA - 1].dma_curp)
 
 /**
  * Generic Scatter Gather Element used by driver
@@ -100,12 +100,32 @@ struct bfa_sge_s {
 /*
  * bfa stats interfaces
  */
-#define bfa_stats(_mod, _stats) (_mod)->stats._stats ++
+#define bfa_stats(_mod, _stats) ((_mod)->stats._stats++)
 
 #define bfa_ioc_get_stats(__bfa, __ioc_stats)   \
         bfa_ioc_fetch_stats(&(__bfa)->ioc, __ioc_stats)
 #define bfa_ioc_clear_stats(__bfa)      \
         bfa_ioc_clr_stats(&(__bfa)->ioc)
+#define bfa_get_nports(__bfa)   \
+        bfa_ioc_get_nports(&(__bfa)->ioc)
+#define bfa_get_adapter_manufacturer(__bfa, __manufacturer) \
+        bfa_ioc_get_adapter_manufacturer(&(__bfa)->ioc, __manufacturer)
+#define bfa_get_adapter_model(__bfa, __model)   \
+        bfa_ioc_get_adapter_model(&(__bfa)->ioc, __model)
+#define bfa_get_adapter_serial_num(__bfa, __serial_num) \
+        bfa_ioc_get_adapter_serial_num(&(__bfa)->ioc, __serial_num)
+#define bfa_get_adapter_fw_ver(__bfa, __fw_ver) \
+        bfa_ioc_get_adapter_fw_ver(&(__bfa)->ioc, __fw_ver)
+#define bfa_get_adapter_optrom_ver(__bfa, __optrom_ver) \
+        bfa_ioc_get_adapter_optrom_ver(&(__bfa)->ioc, __optrom_ver)
+#define bfa_get_pci_chip_rev(__bfa, __chip_rev) \
+        bfa_ioc_get_pci_chip_rev(&(__bfa)->ioc, __chip_rev)
+#define bfa_get_ioc_state(__bfa)    \
+        bfa_ioc_get_state(&(__bfa)->ioc)
+#define bfa_get_type(__bfa) \
+        bfa_ioc_get_type(&(__bfa)->ioc)
+#define bfa_get_mac(__bfa)  \
+        bfa_ioc_get_mac(&(__bfa)->ioc)
 
 /*
  * bfa API functions
@@ -136,7 +156,7 @@ void bfa_isr_enable(struct bfa_s *bfa);
 void bfa_isr_disable(struct bfa_s *bfa);
 void bfa_msix_getvecs(struct bfa_s *bfa, u32 *msix_vecs_bmap,
                         u32 *num_vecs, u32 *max_vec_bit);
-#define bfa_msix(__bfa, __vec) (__bfa)->msix.handler[__vec](__bfa, __vec)
+#define bfa_msix(__bfa, __vec) ((__bfa)->msix.handler[__vec](__bfa, __vec))
 
 void bfa_comp_deq(struct bfa_s *bfa, struct list_head *comp_q);
 void bfa_comp_process(struct bfa_s *bfa, struct list_head *comp_q);
@@ -161,6 +181,7 @@ bfa_status_t bfa_iocfc_israttr_set(struct bfa_s *bfa,
 void bfa_iocfc_enable(struct bfa_s *bfa);
 void bfa_iocfc_disable(struct bfa_s *bfa);
 void bfa_ioc_auto_recover(bfa_boolean_t auto_recover);
+void bfa_chip_reset(struct bfa_s *bfa);
 void bfa_cb_ioc_disable(void *bfad);
 void bfa_timer_tick(struct bfa_s *bfa);
 #define bfa_timer_start(_bfa, _timer, _timercb, _arg, _timeout) \
@@ -171,6 +192,7 @@ void bfa_timer_tick(struct bfa_s *bfa);
  */
 bfa_status_t bfa_debug_fwtrc(struct bfa_s *bfa, void *trcdata, int *trclen);
 bfa_status_t bfa_debug_fwsave(struct bfa_s *bfa, void *trcdata, int *trclen);
+void bfa_debug_fwsave_clear(struct bfa_s *bfa);
 
 #include "bfa_priv.h"
 
diff --git a/drivers/scsi/bfa/include/bfa_svc.h b/drivers/scsi/bfa/include/bfa_svc.h
index 0c80b74f72ef..1349b99a3c6d 100644
--- a/drivers/scsi/bfa/include/bfa_svc.h
+++ b/drivers/scsi/bfa/include/bfa_svc.h
@@ -26,6 +26,7 @@ struct bfa_fcxp_s;
 #include <defs/bfa_defs_pport.h>
 #include <defs/bfa_defs_rport.h>
 #include <defs/bfa_defs_qos.h>
+#include <defs/bfa_defs_fcport.h>
 #include <cs/bfa_sm.h>
 #include <bfa.h>
 
@@ -34,10 +35,10 @@ struct bfa_fcxp_s;
  */
 struct bfa_rport_info_s {
         u16        max_frmsz;   /*  max rcv pdu size               */
-        u32        pid : 24,    /*  remote port ID                 */
-                        lp_tag : 8;
-        u32        local_pid : 24,      /*  local port ID                   */
-                        cisc : 8;       /*  CIRO supported                  */
+        u32        pid:24,              /*  remote port ID                 */
+                        lp_tag:8;       /*  tag                     */
+        u32        local_pid:24,        /*  local port ID                   */
+                        cisc:8;         /*  CIRO supported                  */
         u8         fc_class;    /*  supported FC classes. enum fc_cos */
         u8         vf_en;               /*  virtual fabric enable          */
         u16        vf_id;               /*  virtual fabric ID              */
@@ -54,7 +55,7 @@ struct bfa_rport_s {
         void                  *rport_drv; /*  fcs/driver rport object */
         u16              fw_handle; /*  firmware rport handle */
         u16              rport_tag; /*  BFA rport tag */
-        struct bfa_rport_info_s rport_info; /*  rport info from *fcs/driver */
+        struct bfa_rport_info_s rport_info; /*  rport info from fcs/driver */
         struct bfa_reqq_wait_s reqq_wait; /*  to wait for room in reqq */
         struct bfa_cb_qe_s    hcb_qe;    /*  BFA callback qelem */
         struct bfa_rport_hal_stats_s stats; /*  BFA rport statistics  */
@@ -101,7 +102,7 @@ struct bfa_uf_buf_s {
 struct bfa_uf_s {
         struct list_head        qe;             /*  queue element         */
         struct bfa_s    *bfa;           /*  bfa instance          */
-        u16        uf_tag;              /*  identifying tag f/w messages */
+        u16        uf_tag;              /*  identifying tag fw msgs     */
         u16        vf_id;
         u16        src_rport_handle;
         u16        rsvd;
@@ -127,7 +128,7 @@ struct bfa_lps_s {
         u8              reqq;           /*  lport request queue */
         u8              alpa;           /*  ALPA for loop topologies    */
         u32     lp_pid;         /*  lport port ID               */
-        bfa_boolean_t   fdisc;          /*  send FDISC instead of FLOGI*/
+        bfa_boolean_t   fdisc;          /*  send FDISC instead of FLOGI  */
         bfa_boolean_t   auth_en;        /*  enable authentication       */
         bfa_boolean_t   auth_req;       /*  authentication required     */
         bfa_boolean_t   npiv_en;        /*  NPIV is allowed by peer     */
@@ -151,60 +152,69 @@ struct bfa_lps_s {
         bfa_eproto_status_t     ext_status;
 };
 
+#define BFA_FCPORT(_bfa)        (&((_bfa)->modules.port))
+
 /*
  * bfa pport API functions
  */
-bfa_status_t bfa_pport_enable(struct bfa_s *bfa);
-bfa_status_t bfa_pport_disable(struct bfa_s *bfa);
-bfa_status_t bfa_pport_cfg_speed(struct bfa_s *bfa,
+bfa_status_t bfa_fcport_enable(struct bfa_s *bfa);
+bfa_status_t bfa_fcport_disable(struct bfa_s *bfa);
+bfa_status_t bfa_fcport_cfg_speed(struct bfa_s *bfa,
                         enum bfa_pport_speed speed);
-enum bfa_pport_speed bfa_pport_get_speed(struct bfa_s *bfa);
-bfa_status_t bfa_pport_cfg_topology(struct bfa_s *bfa,
+enum bfa_pport_speed bfa_fcport_get_speed(struct bfa_s *bfa);
+bfa_status_t bfa_fcport_cfg_topology(struct bfa_s *bfa,
                         enum bfa_pport_topology topo);
-enum bfa_pport_topology bfa_pport_get_topology(struct bfa_s *bfa);
-bfa_status_t bfa_pport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa);
-bfa_boolean_t bfa_pport_get_hardalpa(struct bfa_s *bfa, u8 *alpa);
-u8 bfa_pport_get_myalpa(struct bfa_s *bfa);
-bfa_status_t bfa_pport_clr_hardalpa(struct bfa_s *bfa);
-bfa_status_t bfa_pport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxsize);
-u16 bfa_pport_get_maxfrsize(struct bfa_s *bfa);
-u32 bfa_pport_mypid(struct bfa_s *bfa);
-u8 bfa_pport_get_rx_bbcredit(struct bfa_s *bfa);
-bfa_status_t bfa_pport_trunk_enable(struct bfa_s *bfa, u8 bitmap);
-bfa_status_t bfa_pport_trunk_disable(struct bfa_s *bfa);
-bfa_boolean_t bfa_pport_trunk_query(struct bfa_s *bfa, u32 *bitmap);
-void bfa_pport_get_attr(struct bfa_s *bfa, struct bfa_pport_attr_s *attr);
-wwn_t bfa_pport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node);
-bfa_status_t bfa_pport_get_stats(struct bfa_s *bfa,
-                        union bfa_pport_stats_u *stats,
-                        bfa_cb_pport_t cbfn, void *cbarg);
-bfa_status_t bfa_pport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn,
-                        void *cbarg);
-void bfa_pport_event_register(struct bfa_s *bfa,
+enum bfa_pport_topology bfa_fcport_get_topology(struct bfa_s *bfa);
+bfa_status_t bfa_fcport_cfg_hardalpa(struct bfa_s *bfa, u8 alpa);
+bfa_boolean_t bfa_fcport_get_hardalpa(struct bfa_s *bfa, u8 *alpa);
+u8 bfa_fcport_get_myalpa(struct bfa_s *bfa);
+bfa_status_t bfa_fcport_clr_hardalpa(struct bfa_s *bfa);
+bfa_status_t bfa_fcport_cfg_maxfrsize(struct bfa_s *bfa, u16 maxsize);
+u16 bfa_fcport_get_maxfrsize(struct bfa_s *bfa);
+u32 bfa_fcport_mypid(struct bfa_s *bfa);
+u8 bfa_fcport_get_rx_bbcredit(struct bfa_s *bfa);
+bfa_status_t bfa_fcport_trunk_enable(struct bfa_s *bfa, u8 bitmap);
+bfa_status_t bfa_fcport_trunk_disable(struct bfa_s *bfa);
+bfa_boolean_t bfa_fcport_trunk_query(struct bfa_s *bfa, u32 *bitmap);
+void bfa_fcport_get_attr(struct bfa_s *bfa, struct bfa_pport_attr_s *attr);
+wwn_t bfa_fcport_get_wwn(struct bfa_s *bfa, bfa_boolean_t node);
+void bfa_fcport_event_register(struct bfa_s *bfa,
                         void (*event_cbfn) (void *cbarg,
                         bfa_pport_event_t event), void *event_cbarg);
-bfa_boolean_t bfa_pport_is_disabled(struct bfa_s *bfa);
-void bfa_pport_cfg_qos(struct bfa_s *bfa, bfa_boolean_t on_off);
-void bfa_pport_cfg_ratelim(struct bfa_s *bfa, bfa_boolean_t on_off);
-bfa_status_t bfa_pport_cfg_ratelim_speed(struct bfa_s *bfa,
+bfa_boolean_t bfa_fcport_is_disabled(struct bfa_s *bfa);
+void bfa_fcport_cfg_qos(struct bfa_s *bfa, bfa_boolean_t on_off);
+void bfa_fcport_cfg_ratelim(struct bfa_s *bfa, bfa_boolean_t on_off);
+bfa_status_t bfa_fcport_cfg_ratelim_speed(struct bfa_s *bfa,
                         enum bfa_pport_speed speed);
-enum bfa_pport_speed bfa_pport_get_ratelim_speed(struct bfa_s *bfa);
+enum bfa_pport_speed bfa_fcport_get_ratelim_speed(struct bfa_s *bfa);
 
-void bfa_pport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit);
-void bfa_pport_busy(struct bfa_s *bfa, bfa_boolean_t status);
-void bfa_pport_beacon(struct bfa_s *bfa, bfa_boolean_t beacon,
+void bfa_fcport_set_tx_bbcredit(struct bfa_s *bfa, u16 tx_bbcredit);
+void bfa_fcport_busy(struct bfa_s *bfa, bfa_boolean_t status);
+void bfa_fcport_beacon(struct bfa_s *bfa, bfa_boolean_t beacon,
                         bfa_boolean_t link_e2e_beacon);
 void bfa_cb_pport_event(void *cbarg, bfa_pport_event_t event);
-void bfa_pport_qos_get_attr(struct bfa_s *bfa, struct bfa_qos_attr_s *qos_attr);
-void bfa_pport_qos_get_vc_attr(struct bfa_s *bfa,
+void bfa_fcport_qos_get_attr(struct bfa_s *bfa,
+                        struct bfa_qos_attr_s *qos_attr);
+void bfa_fcport_qos_get_vc_attr(struct bfa_s *bfa,
                         struct bfa_qos_vc_attr_s *qos_vc_attr);
-bfa_status_t bfa_pport_get_qos_stats(struct bfa_s *bfa,
-                        union bfa_pport_stats_u *stats,
+bfa_status_t bfa_fcport_get_qos_stats(struct bfa_s *bfa,
+                        union bfa_fcport_stats_u *stats,
                         bfa_cb_pport_t cbfn, void *cbarg);
-bfa_status_t bfa_pport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn,
+bfa_status_t bfa_fcport_clear_qos_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn,
                         void *cbarg);
-bfa_boolean_t     bfa_pport_is_ratelim(struct bfa_s *bfa);
-bfa_boolean_t   bfa_pport_is_linkup(struct bfa_s *bfa);
+bfa_status_t bfa_fcport_get_fcoe_stats(struct bfa_s *bfa,
+                        union bfa_fcport_stats_u *stats,
+                        bfa_cb_pport_t cbfn, void *cbarg);
+bfa_status_t bfa_fcport_clear_fcoe_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn,
+                        void *cbarg);
+
+bfa_boolean_t     bfa_fcport_is_ratelim(struct bfa_s *bfa);
+bfa_boolean_t   bfa_fcport_is_linkup(struct bfa_s *bfa);
+bfa_status_t bfa_fcport_get_stats(struct bfa_s *bfa,
+                union bfa_fcport_stats_u *stats,
+                bfa_cb_pport_t cbfn, void *cbarg);
+bfa_status_t bfa_fcport_clear_stats(struct bfa_s *bfa, bfa_cb_pport_t cbfn,
+                void *cbarg);
 
 /*
  * bfa rport API functions
@@ -293,6 +303,7 @@ void bfa_uf_free(struct bfa_uf_s *uf);
  * bfa lport service api
  */
 
+u32     bfa_lps_get_max_vport(struct bfa_s *bfa);
 struct bfa_lps_s *bfa_lps_alloc(struct bfa_s *bfa);
 void bfa_lps_delete(struct bfa_lps_s *lps);
 void bfa_lps_discard(struct bfa_lps_s *lps);
@@ -315,10 +326,12 @@ wwn_t bfa_lps_get_peer_pwwn(struct bfa_lps_s *lps);
 wwn_t bfa_lps_get_peer_nwwn(struct bfa_lps_s *lps);
 u8 bfa_lps_get_lsrjt_rsn(struct bfa_lps_s *lps);
 u8 bfa_lps_get_lsrjt_expl(struct bfa_lps_s *lps);
+mac_t bfa_lps_get_lp_mac(struct bfa_lps_s *lps);
 void bfa_cb_lps_flogi_comp(void *bfad, void *uarg, bfa_status_t status);
 void bfa_cb_lps_flogo_comp(void *bfad, void *uarg);
 void bfa_cb_lps_fdisc_comp(void *bfad, void *uarg, bfa_status_t status);
 void bfa_cb_lps_fdisclogo_comp(void *bfad, void *uarg);
+void bfa_cb_lps_cvl_event(void *bfad, void *uarg);
 
 #endif /* __BFA_SVC_H__ */
 
diff --git a/drivers/scsi/bfa/include/bfa_timer.h b/drivers/scsi/bfa/include/bfa_timer.h
index e407103fa565..f71087448222 100644
--- a/drivers/scsi/bfa/include/bfa_timer.h
+++ b/drivers/scsi/bfa/include/bfa_timer.h
@@ -41,7 +41,7 @@ struct bfa_timer_mod_s {
         struct list_head timer_q;
 };
 
-#define BFA_TIMER_FREQ 500 /**< specified in millisecs */
+#define BFA_TIMER_FREQ 200 /**< specified in millisecs */
 
 void bfa_timer_beat(struct bfa_timer_mod_s *mod);
 void bfa_timer_init(struct bfa_timer_mod_s *mod);
diff --git a/drivers/scsi/bfa/include/bfi/bfi.h b/drivers/scsi/bfa/include/bfi/bfi.h
index 6cadfe0d4ba1..a550e80cabd2 100644
--- a/drivers/scsi/bfa/include/bfi/bfi.h
+++ b/drivers/scsi/bfa/include/bfi/bfi.h
@@ -93,13 +93,13 @@ union bfi_addr_u {
  */
 struct bfi_sge_s {
 #ifdef __BIGENDIAN
-        u32        flags        : 2,
-                        rsvd    : 2,
-                        sg_len  : 28;
+        u32        flags:2,
+                        rsvd:2,
+                        sg_len:28;
 #else
-        u32        sg_len       : 28,
-                        rsvd    : 2,
-                        flags   : 2;
+        u32        sg_len:28,
+                        rsvd:2,
+                        flags:2;
 #endif
         union bfi_addr_u sga;
 };
@@ -143,8 +143,8 @@ enum bfi_mclass {
         BFI_MC_IOC              = 1,    /*  IO Controller (IOC)     */
         BFI_MC_DIAG             = 2,    /*  Diagnostic Msgs                 */
         BFI_MC_FLASH            = 3,    /*  Flash message class     */
-        BFI_MC_CEE              = 4,
-        BFI_MC_FC_PORT          = 5,    /*  FC port                         */
+        BFI_MC_CEE              = 4,    /*  CEE                     */
+        BFI_MC_FCPORT           = 5,    /*  FC port                         */
         BFI_MC_IOCFC            = 6,    /*  FC - IO Controller (IOC)        */
         BFI_MC_LL               = 7,    /*  Link Layer                      */
         BFI_MC_UF               = 8,    /*  Unsolicited frame receive       */
diff --git a/drivers/scsi/bfa/include/bfi/bfi_cbreg.h b/drivers/scsi/bfa/include/bfi/bfi_cbreg.h
index b3bb52b565b1..a51ee61ddb19 100644
--- a/drivers/scsi/bfa/include/bfi/bfi_cbreg.h
+++ b/drivers/scsi/bfa/include/bfi/bfi_cbreg.h
@@ -177,7 +177,21 @@
 #define __PSS_LMEM_INIT_EN               0x00000100
 #define __PSS_LPU1_RESET                 0x00000002
 #define __PSS_LPU0_RESET                 0x00000001
-
+#define PSS_ERR_STATUS_REG               0x00018810
+#define __PSS_LMEM1_CORR_ERR             0x00000800
+#define __PSS_LMEM0_CORR_ERR             0x00000400
+#define __PSS_LMEM1_UNCORR_ERR           0x00000200
+#define __PSS_LMEM0_UNCORR_ERR           0x00000100
+#define __PSS_BAL_PERR                   0x00000080
+#define __PSS_DIP_IF_ERR                 0x00000040
+#define __PSS_IOH_IF_ERR                 0x00000020
+#define __PSS_TDS_IF_ERR                 0x00000010
+#define __PSS_RDS_IF_ERR                 0x00000008
+#define __PSS_SGM_IF_ERR                 0x00000004
+#define __PSS_LPU1_RAM_ERR               0x00000002
+#define __PSS_LPU0_RAM_ERR               0x00000001
+#define ERR_SET_REG                      0x00018818
+#define __PSS_ERR_STATUS_SET             0x00000fff
 
 /*
  * These definitions are either in error/missing in spec. Its auto-generated
diff --git a/drivers/scsi/bfa/include/bfi/bfi_ctreg.h b/drivers/scsi/bfa/include/bfi/bfi_ctreg.h
index d3caa58c0a0a..57a8497105af 100644
--- a/drivers/scsi/bfa/include/bfi/bfi_ctreg.h
+++ b/drivers/scsi/bfa/include/bfi/bfi_ctreg.h
@@ -430,6 +430,31 @@ enum {
 #define __PSS_LMEM_INIT_EN               0x00000100
 #define __PSS_LPU1_RESET                 0x00000002
 #define __PSS_LPU0_RESET                 0x00000001
+#define PSS_ERR_STATUS_REG               0x00018810
+#define __PSS_LPU1_TCM_READ_ERR          0x00200000
+#define __PSS_LPU0_TCM_READ_ERR          0x00100000
+#define __PSS_LMEM5_CORR_ERR             0x00080000
+#define __PSS_LMEM4_CORR_ERR             0x00040000
+#define __PSS_LMEM3_CORR_ERR             0x00020000
+#define __PSS_LMEM2_CORR_ERR             0x00010000
+#define __PSS_LMEM1_CORR_ERR             0x00008000
+#define __PSS_LMEM0_CORR_ERR             0x00004000
+#define __PSS_LMEM5_UNCORR_ERR           0x00002000
+#define __PSS_LMEM4_UNCORR_ERR           0x00001000
+#define __PSS_LMEM3_UNCORR_ERR           0x00000800
+#define __PSS_LMEM2_UNCORR_ERR           0x00000400
+#define __PSS_LMEM1_UNCORR_ERR           0x00000200
+#define __PSS_LMEM0_UNCORR_ERR           0x00000100
+#define __PSS_BAL_PERR                   0x00000080
+#define __PSS_DIP_IF_ERR                 0x00000040
+#define __PSS_IOH_IF_ERR                 0x00000020
+#define __PSS_TDS_IF_ERR                 0x00000010
+#define __PSS_RDS_IF_ERR                 0x00000008
+#define __PSS_SGM_IF_ERR                 0x00000004
+#define __PSS_LPU1_RAM_ERR               0x00000002
+#define __PSS_LPU0_RAM_ERR               0x00000001
+#define ERR_SET_REG                      0x00018818
+#define __PSS_ERR_STATUS_SET             0x003fffff
 #define HQM_QSET0_RXQ_DRBL_P0            0x00038000
 #define __RXQ0_ADD_VECTORS_P             0x80000000
 #define __RXQ0_STOP_P                    0x40000000
@@ -589,6 +614,7 @@ enum {
 #define __HFN_INT_MBOX_LPU1                0x00200000U
 #define __HFN_INT_MBOX1_LPU0               0x00400000U
 #define __HFN_INT_MBOX1_LPU1               0x00800000U
+#define __HFN_INT_LL_HALT                  0x01000000U
 #define __HFN_INT_CPE_MASK                 0x000000ffU
 #define __HFN_INT_RME_MASK                 0x0000ff00U
 
diff --git a/drivers/scsi/bfa/include/bfi/bfi_ioc.h b/drivers/scsi/bfa/include/bfi/bfi_ioc.h
index 026e9c06ae97..a0158aac0024 100644
--- a/drivers/scsi/bfa/include/bfi/bfi_ioc.h
+++ b/drivers/scsi/bfa/include/bfi/bfi_ioc.h
@@ -123,7 +123,7 @@ enum bfi_ioc_state {
         BFI_IOC_DISABLING        = 5,   /*  IOC is being disabled           */
         BFI_IOC_DISABLED         = 6,   /*  IOC is disabled                 */
         BFI_IOC_CFG_DISABLED = 7,       /*  IOC is being disabled;transient */
-        BFI_IOC_HBFAIL       = 8,       /*  IOC heart-beat failure          */
+        BFI_IOC_FAIL       = 8,         /*  IOC heart-beat failure          */
         BFI_IOC_MEMTEST      = 9,       /*  IOC is doing memtest            */
 };
 
@@ -142,7 +142,7 @@ enum {
         BFI_ADAPTER_UNSUPP    = 0x400000,       /*  unknown adapter type  */
 };
 
-#define BFI_ADAPTER_GETP(__prop,__adap_prop)                    \
+#define BFI_ADAPTER_GETP(__prop, __adap_prop)                   \
     (((__adap_prop) & BFI_ADAPTER_ ## __prop ## _MK) >>         \
      BFI_ADAPTER_ ## __prop ## _SH)
 #define BFI_ADAPTER_SETP(__prop, __val)                         \
diff --git a/drivers/scsi/bfa/include/bfi/bfi_lps.h b/drivers/scsi/bfa/include/bfi/bfi_lps.h
index 414b0e30f6ef..7ed31bbb8696 100644
--- a/drivers/scsi/bfa/include/bfi/bfi_lps.h
+++ b/drivers/scsi/bfa/include/bfi/bfi_lps.h
@@ -30,6 +30,7 @@ enum bfi_lps_h2i_msgs {
 enum bfi_lps_i2h_msgs {
         BFI_LPS_H2I_LOGIN_RSP   = BFA_I2HM(1),
         BFI_LPS_H2I_LOGOUT_RSP  = BFA_I2HM(2),
+        BFI_LPS_H2I_CVL_EVENT   = BFA_I2HM(3),
 };
 
 struct bfi_lps_login_req_s {
@@ -55,8 +56,8 @@ struct bfi_lps_login_rsp_s {
         u16     bb_credit;
         u8              f_port;
         u8              npiv_en;
-        u32     lp_pid : 24;
-        u32     auth_req : 8;
+        u32     lp_pid:24;
+        u32     auth_req:8;
         mac_t           lp_mac;
         mac_t           fcf_mac;
         u8              ext_status;
@@ -77,6 +78,12 @@ struct bfi_lps_logout_rsp_s {
         u8              rsvd[2];
 };
 
+struct bfi_lps_cvl_event_s {
+        struct bfi_mhdr_s  mh;      /* common msg header      */
+        u8              lp_tag;
+        u8              rsvd[3];
+};
+
 union bfi_lps_h2i_msg_u {
         struct bfi_mhdr_s               *msg;
         struct bfi_lps_login_req_s      *login_req;
@@ -87,6 +94,7 @@ union bfi_lps_i2h_msg_u {
         struct bfi_msg_s                *msg;
         struct bfi_lps_login_rsp_s      *login_rsp;
         struct bfi_lps_logout_rsp_s     *logout_rsp;
+        struct bfi_lps_cvl_event_s      *cvl_event;
 };
 
 #pragma pack()
diff --git a/drivers/scsi/bfa/include/bfi/bfi_pport.h b/drivers/scsi/bfa/include/bfi/bfi_pport.h
index c96d246851af..50dcf45c7470 100644
--- a/drivers/scsi/bfa/include/bfi/bfi_pport.h
+++ b/drivers/scsi/bfa/include/bfi/bfi_pport.h
@@ -22,163 +22,97 @@
 
 #pragma pack(1)
 
-enum bfi_pport_h2i {
-        BFI_PPORT_H2I_ENABLE_REQ                = (1),
-        BFI_PPORT_H2I_DISABLE_REQ               = (2),
-        BFI_PPORT_H2I_GET_STATS_REQ             = (3),
-        BFI_PPORT_H2I_CLEAR_STATS_REQ   = (4),
-        BFI_PPORT_H2I_SET_SVC_PARAMS_REQ        = (5),
-        BFI_PPORT_H2I_ENABLE_RX_VF_TAG_REQ      = (6),
-        BFI_PPORT_H2I_ENABLE_TX_VF_TAG_REQ      = (7),
-        BFI_PPORT_H2I_GET_QOS_STATS_REQ         = (8),
-        BFI_PPORT_H2I_CLEAR_QOS_STATS_REQ       = (9),
+enum bfi_fcport_h2i {
+        BFI_FCPORT_H2I_ENABLE_REQ               = (1),
+        BFI_FCPORT_H2I_DISABLE_REQ              = (2),
+        BFI_FCPORT_H2I_SET_SVC_PARAMS_REQ       = (3),
+        BFI_FCPORT_H2I_STATS_GET_REQ            = (4),
+        BFI_FCPORT_H2I_STATS_CLEAR_REQ          = (5),
 };
 
-enum bfi_pport_i2h {
-        BFI_PPORT_I2H_ENABLE_RSP                = BFA_I2HM(1),
-        BFI_PPORT_I2H_DISABLE_RSP               = BFA_I2HM(2),
-        BFI_PPORT_I2H_GET_STATS_RSP             = BFA_I2HM(3),
-        BFI_PPORT_I2H_CLEAR_STATS_RSP   = BFA_I2HM(4),
-        BFI_PPORT_I2H_SET_SVC_PARAMS_RSP        = BFA_I2HM(5),
-        BFI_PPORT_I2H_ENABLE_RX_VF_TAG_RSP      = BFA_I2HM(6),
-        BFI_PPORT_I2H_ENABLE_TX_VF_TAG_RSP      = BFA_I2HM(7),
-        BFI_PPORT_I2H_EVENT                     = BFA_I2HM(8),
-        BFI_PPORT_I2H_GET_QOS_STATS_RSP         = BFA_I2HM(9),
-        BFI_PPORT_I2H_CLEAR_QOS_STATS_RSP       = BFA_I2HM(10),
+enum bfi_fcport_i2h {
+        BFI_FCPORT_I2H_ENABLE_RSP               = BFA_I2HM(1),
+        BFI_FCPORT_I2H_DISABLE_RSP              = BFA_I2HM(2),
+        BFI_FCPORT_I2H_SET_SVC_PARAMS_RSP       = BFA_I2HM(3),
+        BFI_FCPORT_I2H_STATS_GET_RSP            = BFA_I2HM(4),
+        BFI_FCPORT_I2H_STATS_CLEAR_RSP          = BFA_I2HM(5),
+        BFI_FCPORT_I2H_EVENT                    = BFA_I2HM(6),
 };
 
 /**
  * Generic REQ type
  */
-struct bfi_pport_generic_req_s {
+struct bfi_fcport_req_s {
         struct bfi_mhdr_s  mh;          /*  msg header                      */
-        u32        msgtag;              /*  msgtag for reply                */
+        u32        msgtag;      /*  msgtag for reply                */
 };
 
 /**
  * Generic RSP type
  */
-struct bfi_pport_generic_rsp_s {
+struct bfi_fcport_rsp_s {
         struct bfi_mhdr_s  mh;          /*  common msg header               */
-        u8         status;              /*  port enable status              */
-        u8         rsvd[3];
-        u32        msgtag;              /*  msgtag for reply                */
+        u8                 status;      /*  port enable status              */
+        u8                 rsvd[3];
+        u32        msgtag;      /*  msgtag for reply                */
 };
 
 /**
- * BFI_PPORT_H2I_ENABLE_REQ
+ * BFI_FCPORT_H2I_ENABLE_REQ
  */
-struct bfi_pport_enable_req_s {
+struct bfi_fcport_enable_req_s {
         struct bfi_mhdr_s  mh;          /*  msg header                      */
-        u32        rsvd1;
-        wwn_t           nwwn;           /*  node wwn of physical port       */
-        wwn_t           pwwn;           /*  port wwn of physical port       */
-        struct bfa_pport_cfg_s port_cfg;        /*  port configuration      */
-        union bfi_addr_u  stats_dma_addr;       /*  DMA address for stats  */
-        u32        msgtag;              /*  msgtag for reply                */
-        u32        rsvd2;
+        u32        rsvd1;
+        wwn_t              nwwn;        /*  node wwn of physical port       */
+        wwn_t              pwwn;        /*  port wwn of physical port       */
+        struct bfa_pport_cfg_s port_cfg; /*  port configuration     */
+        union bfi_addr_u   stats_dma_addr; /*  DMA address for stats        */
+        u32        msgtag;      /*  msgtag for reply                */
+        u32        rsvd2;
 };
 
 /**
- * BFI_PPORT_I2H_ENABLE_RSP
+ * BFI_FCPORT_H2I_SET_SVC_PARAMS_REQ
  */
-#define bfi_pport_enable_rsp_t struct bfi_pport_generic_rsp_s
-
-/**
- * BFI_PPORT_H2I_DISABLE_REQ
- */
-#define bfi_pport_disable_req_t struct bfi_pport_generic_req_s
-
-/**
- * BFI_PPORT_I2H_DISABLE_RSP
- */
-#define bfi_pport_disable_rsp_t struct bfi_pport_generic_rsp_s
-
-/**
- * BFI_PPORT_H2I_GET_STATS_REQ
- */
-#define bfi_pport_get_stats_req_t struct bfi_pport_generic_req_s
-
-/**
- * BFI_PPORT_I2H_GET_STATS_RSP
- */
-#define bfi_pport_get_stats_rsp_t struct bfi_pport_generic_rsp_s
-
-/**
- * BFI_PPORT_H2I_CLEAR_STATS_REQ
- */
-#define bfi_pport_clear_stats_req_t struct bfi_pport_generic_req_s
-
-/**
- * BFI_PPORT_I2H_CLEAR_STATS_RSP
- */
-#define bfi_pport_clear_stats_rsp_t struct bfi_pport_generic_rsp_s
-
-/**
- * BFI_PPORT_H2I_GET_QOS_STATS_REQ
- */
-#define bfi_pport_get_qos_stats_req_t struct bfi_pport_generic_req_s
-
-/**
- * BFI_PPORT_H2I_GET_QOS_STATS_RSP
- */
-#define bfi_pport_get_qos_stats_rsp_t struct bfi_pport_generic_rsp_s
-
-/**
- * BFI_PPORT_H2I_CLEAR_QOS_STATS_REQ
- */
-#define bfi_pport_clear_qos_stats_req_t struct bfi_pport_generic_req_s
-
-/**
- * BFI_PPORT_H2I_CLEAR_QOS_STATS_RSP
- */
-#define bfi_pport_clear_qos_stats_rsp_t struct bfi_pport_generic_rsp_s
-
-/**
- * BFI_PPORT_H2I_SET_SVC_PARAMS_REQ
- */
-struct bfi_pport_set_svc_params_req_s {
+struct bfi_fcport_set_svc_params_req_s {
         struct bfi_mhdr_s  mh;          /*  msg header */
-        u16        tx_bbcredit; /*  Tx credits */
-        u16        rsvd;
+        u16        tx_bbcredit; /*  Tx credits */
+        u16        rsvd;
 };
 
 /**
- * BFI_PPORT_I2H_SET_SVC_PARAMS_RSP
- */
-
-/**
- * BFI_PPORT_I2H_EVENT
+ * BFI_FCPORT_I2H_EVENT
  */
-struct bfi_pport_event_s {
+struct bfi_fcport_event_s {
         struct bfi_mhdr_s       mh;     /*  common msg header */
         struct bfa_pport_link_s link_state;
 };
 
-union bfi_pport_h2i_msg_u {
+/**
+ * fcport H2I message
+ */
+union bfi_fcport_h2i_msg_u {
         struct bfi_mhdr_s                       *mhdr;
-        struct bfi_pport_enable_req_s           *penable;
-        struct bfi_pport_generic_req_s          *pdisable;
-        struct bfi_pport_generic_req_s          *pgetstats;
-        struct bfi_pport_generic_req_s          *pclearstats;
-        struct bfi_pport_set_svc_params_req_s   *psetsvcparams;
-        struct bfi_pport_get_qos_stats_req_s    *pgetqosstats;
-        struct bfi_pport_generic_req_s          *pclearqosstats;
+        struct bfi_fcport_enable_req_s          *penable;
+        struct bfi_fcport_req_s                 *pdisable;
+        struct bfi_fcport_set_svc_params_req_s  *psetsvcparams;
+        struct bfi_fcport_req_s                 *pstatsget;
+        struct bfi_fcport_req_s                 *pstatsclear;
 };
 
-union bfi_pport_i2h_msg_u {
+/**
+ * fcport I2H message
+ */
+union bfi_fcport_i2h_msg_u {
         struct bfi_msg_s                        *msg;
-        struct bfi_pport_generic_rsp_s          *enable_rsp;
-        struct bfi_pport_disable_rsp_s          *disable_rsp;
-        struct bfi_pport_generic_rsp_s          *getstats_rsp;
-        struct bfi_pport_clear_stats_rsp_s      *clearstats_rsp;
-        struct bfi_pport_set_svc_params_rsp_s   *setsvcparasm_rsp;
-        struct bfi_pport_get_qos_stats_rsp_s    *getqosstats_rsp;
-        struct bfi_pport_clear_qos_stats_rsp_s  *clearqosstats_rsp;
-        struct bfi_pport_event_s                *event;
+        struct bfi_fcport_rsp_s                 *penable_rsp;
+        struct bfi_fcport_rsp_s                 *pdisable_rsp;
+        struct bfi_fcport_rsp_s                 *psetsvcparams_rsp;
+        struct bfi_fcport_rsp_s                 *pstatsget_rsp;
+        struct bfi_fcport_rsp_s                 *pstatsclear_rsp;
+        struct bfi_fcport_event_s               *event;
 };
 
 #pragma pack()
 
 #endif /* __BFI_PPORT_H__ */
-
diff --git a/drivers/scsi/bfa/include/bfi/bfi_rport.h b/drivers/scsi/bfa/include/bfi/bfi_rport.h
index 3520f55f09d7..e1cd83b56ec6 100644
--- a/drivers/scsi/bfa/include/bfi/bfi_rport.h
+++ b/drivers/scsi/bfa/include/bfi/bfi_rport.h
@@ -38,10 +38,10 @@ struct bfi_rport_create_req_s {
         struct bfi_mhdr_s  mh;          /*  common msg header           */
         u16        bfa_handle;  /*  host rport handle           */
         u16        max_frmsz;   /*  max rcv pdu size            */
-        u32        pid       : 24,      /*  remote port ID              */
-                        lp_tag    : 8;  /*  local port tag              */
-        u32        local_pid : 24,      /*  local port ID               */
-                        cisc      : 8;
+        u32        pid:24,              /*  remote port ID              */
+                        lp_tag:8;       /*  local port tag              */
+        u32        local_pid:24,        /*  local port ID               */
+                        cisc:8;
         u8         fc_class;    /*  supported FC classes        */
         u8         vf_en;               /*  virtual fabric enable       */
         u16        vf_id;               /*  virtual fabric ID           */
diff --git a/drivers/scsi/bfa/include/cna/bfa_cna_trcmod.h b/drivers/scsi/bfa/include/cna/bfa_cna_trcmod.h
index 43ba7064e81a..a75a1f3be315 100644
--- a/drivers/scsi/bfa/include/cna/bfa_cna_trcmod.h
+++ b/drivers/scsi/bfa/include/cna/bfa_cna_trcmod.h
@@ -31,6 +31,10 @@
 enum {
         BFA_TRC_CNA_CEE         = 1,
         BFA_TRC_CNA_PORT        = 2,
+        BFA_TRC_CNA_IOC     = 3,
+        BFA_TRC_CNA_DIAG    = 4,
+        BFA_TRC_CNA_IOC_CB  = 5,
+        BFA_TRC_CNA_IOC_CT  = 6,
 };
 
 #endif /* __BFA_CNA_TRCMOD_H__ */
diff --git a/drivers/scsi/bfa/include/cs/bfa_checksum.h b/drivers/scsi/bfa/include/cs/bfa_checksum.h
index af8c1d533ba8..650f8d0aaff9 100644
--- a/drivers/scsi/bfa/include/cs/bfa_checksum.h
+++ b/drivers/scsi/bfa/include/cs/bfa_checksum.h
@@ -31,7 +31,7 @@ bfa_checksum_u32(u32 *buf, int sz)
         for (i = 0; i < m; i++)
                 sum ^= buf[i];
 
-        return (sum);
+        return sum;
 }
 
 static inline u16
@@ -43,7 +43,7 @@ bfa_checksum_u16(u16 *buf, int sz)
         for (i = 0; i < m; i++)
                 sum ^= buf[i];
 
-        return (sum);
+        return sum;
 }
 
 static inline u8
@@ -55,6 +55,6 @@ bfa_checksum_u8(u8 *buf, int sz)
         for (i = 0; i < sz; i++)
                 sum ^= buf[i];
 
-        return (sum);
+        return sum;
 }
 #endif
diff --git a/drivers/scsi/bfa/include/cs/bfa_log.h b/drivers/scsi/bfa/include/cs/bfa_log.h
index 761cbe22130a..bc334e0a93fa 100644
--- a/drivers/scsi/bfa/include/cs/bfa_log.h
+++ b/drivers/scsi/bfa/include/cs/bfa_log.h
@@ -157,7 +157,7 @@ typedef void (*bfa_log_cb_t)(struct bfa_log_mod_s *log_mod, u32 msg_id,
 
 
 struct bfa_log_mod_s {
-        char            instance_info[16];      /*  instance info */
+        char            instance_info[BFA_STRING_32];   /*  instance info */
         int             log_level[BFA_LOG_MODULE_ID_MAX + 1];
                                                 /*  log level for modules */
         bfa_log_cb_t    cbfn;                   /*  callback function */
diff --git a/drivers/scsi/bfa/include/cs/bfa_plog.h b/drivers/scsi/bfa/include/cs/bfa_plog.h
index 670f86e5fc6e..f5bef63b5877 100644
--- a/drivers/scsi/bfa/include/cs/bfa_plog.h
+++ b/drivers/scsi/bfa/include/cs/bfa_plog.h
@@ -80,7 +80,8 @@ enum bfa_plog_mid {
         BFA_PL_MID_HAL_FCXP     = 4,
         BFA_PL_MID_HAL_UF       = 5,
         BFA_PL_MID_FCS          = 6,
-        BFA_PL_MID_MAX          = 7
+        BFA_PL_MID_LPS          = 7,
+        BFA_PL_MID_MAX          = 8
 };
 
 #define BFA_PL_MID_STRLEN    8
@@ -118,7 +119,11 @@ enum bfa_plog_eid {
         BFA_PL_EID_RSCN                 = 17,
         BFA_PL_EID_DEBUG                = 18,
         BFA_PL_EID_MISC                 = 19,
-        BFA_PL_EID_MAX                  = 20
+        BFA_PL_EID_FIP_FCF_DISC         = 20,
+        BFA_PL_EID_FIP_FCF_CVL          = 21,
+        BFA_PL_EID_LOGIN                = 22,
+        BFA_PL_EID_LOGO                 = 23,
+        BFA_PL_EID_MAX                  = 24
 };
 
 #define BFA_PL_ENAME_STRLEN     8
diff --git a/drivers/scsi/bfa/include/cs/bfa_sm.h b/drivers/scsi/bfa/include/cs/bfa_sm.h
index 9877066680a6..11fba9082f05 100644
--- a/drivers/scsi/bfa/include/cs/bfa_sm.h
+++ b/drivers/scsi/bfa/include/cs/bfa_sm.h
@@ -23,9 +23,17 @@
 #define __BFA_SM_H__
 
 typedef void (*bfa_sm_t)(void *sm, int event);
+/**
+ * oc - object class eg. bfa_ioc
+ * st - state, eg. reset
+ * otype - object type, eg. struct bfa_ioc_s
+ * etype - object type, eg. enum ioc_event
+ */
+#define bfa_sm_state_decl(oc, st, otype, etype)         \
+        static void oc ## _sm_ ## st(otype * fsm, etype event)
 
-#define bfa_sm_set_state(_sm, _state)   (_sm)->sm = (bfa_sm_t)(_state)
-#define bfa_sm_send_event(_sm, _event)  (_sm)->sm((_sm), (_event))
+#define bfa_sm_set_state(_sm, _state)   ((_sm)->sm = (bfa_sm_t)(_state))
+#define bfa_sm_send_event(_sm, _event)  ((_sm)->sm((_sm), (_event)))
 #define bfa_sm_get_state(_sm)           ((_sm)->sm)
 #define bfa_sm_cmp_state(_sm, _state)   ((_sm)->sm == (bfa_sm_t)(_state))
 
@@ -62,7 +70,7 @@ typedef void (*bfa_fsm_t)(void *fsm, int event);
 } while (0)
 
 #define bfa_fsm_send_event(_fsm, _event)        \
-        (_fsm)->fsm((_fsm), (_event))
+        ((_fsm)->fsm((_fsm), (_event)))
 #define bfa_fsm_cmp_state(_fsm, _state)         \
         ((_fsm)->fsm == (bfa_fsm_t)(_state))
 
diff --git a/drivers/scsi/bfa/include/cs/bfa_trc.h b/drivers/scsi/bfa/include/cs/bfa_trc.h
index 3e743928c74c..310771c888e7 100644
--- a/drivers/scsi/bfa/include/cs/bfa_trc.h
+++ b/drivers/scsi/bfa/include/cs/bfa_trc.h
@@ -24,7 +24,7 @@
 #endif
 
 #ifndef BFA_TRC_TS
-#define BFA_TRC_TS(_trcm)       ((_trcm)->ticks ++)
+#define BFA_TRC_TS(_trcm)       ((_trcm)->ticks++)
 #endif
 
 struct bfa_trc_s {
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_aen.h b/drivers/scsi/bfa/include/defs/bfa_defs_aen.h
index 4c81a613db3d..35244698fcdc 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_aen.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_aen.h
@@ -30,6 +30,16 @@
 #include <defs/bfa_defs_audit.h>
 #include <defs/bfa_defs_ethport.h>
 
+#define BFA_AEN_MAX_APP         5
+
+enum bfa_aen_app {
+        bfa_aen_app_bcu = 0,    /* No thread for bcu */
+        bfa_aen_app_hcm = 1,
+        bfa_aen_app_cim = 2,
+        bfa_aen_app_snia = 3,
+        bfa_aen_app_test = 4,   /* To be removed after unit test */
+};
+
 enum bfa_aen_category {
         BFA_AEN_CAT_ADAPTER     = 1,
         BFA_AEN_CAT_PORT        = 2,
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_auth.h b/drivers/scsi/bfa/include/defs/bfa_defs_auth.h
index dd19c83aba58..45df32820911 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_auth.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_auth.h
@@ -23,6 +23,7 @@
 #define PRIVATE_KEY                     19009
 #define KEY_LEN                         32399
 #define BFA_AUTH_SECRET_STRING_LEN      256
+#define BFA_AUTH_FAIL_NO_PASSWORD       0xFE
 #define BFA_AUTH_FAIL_TIMEOUT           0xFF
 
 /**
@@ -41,6 +42,27 @@ enum bfa_auth_status {
         BFA_AUTH_STATUS_UNKNOWN = 9,    /*  authentication status unknown */
 };
 
+enum bfa_auth_rej_code {
+        BFA_AUTH_RJT_CODE_AUTH_FAILURE   = 1, /* auth failure */
+        BFA_AUTH_RJT_CODE_LOGICAL_ERR    = 2, /* logical error */
+};
+
+/**
+ * Authentication reject codes
+ */
+enum bfa_auth_rej_code_exp {
+        BFA_AUTH_MECH_NOT_USABLE        = 1, /* auth. mechanism not usable */
+        BFA_AUTH_DH_GROUP_NOT_USABLE    = 2, /* DH Group not usable */
+        BFA_AUTH_HASH_FUNC_NOT_USABLE   = 3, /* hash Function not usable */
+        BFA_AUTH_AUTH_XACT_STARTED      = 4, /* auth xact started */
+        BFA_AUTH_AUTH_FAILED            = 5, /* auth failed */
+        BFA_AUTH_INCORRECT_PLD          = 6, /* incorrect payload */
+        BFA_AUTH_INCORRECT_PROTO_MSG    = 7, /* incorrect proto msg */
+        BFA_AUTH_RESTART_AUTH_PROTO     = 8, /* restart auth protocol */
+        BFA_AUTH_AUTH_CONCAT_NOT_SUPP   = 9, /* auth concat not supported */
+        BFA_AUTH_PROTO_VER_NOT_SUPP     = 10,/* proto version not supported */
+};
+
 struct auth_proto_stats_s {
         u32        auth_rjts;
         u32        auth_negs;
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_cee.h b/drivers/scsi/bfa/include/defs/bfa_defs_cee.h
index 520a22f52dd1..b0ac9ac15c5d 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_cee.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_cee.h
@@ -28,10 +28,6 @@
 
 #define BFA_CEE_LLDP_MAX_STRING_LEN (128)
 
-
-/* FIXME: this is coming from the protocol spec. Can the host & apps share the
-   protocol .h files ?
- */
 #define BFA_CEE_LLDP_SYS_CAP_OTHER       0x0001
 #define BFA_CEE_LLDP_SYS_CAP_REPEATER    0x0002
 #define BFA_CEE_LLDP_SYS_CAP_MAC_BRIDGE  0x0004
@@ -94,9 +90,10 @@ struct bfa_cee_dcbx_cfg_s {
 /* CEE status */
 /* Making this to tri-state for the benefit of port list command */
 enum bfa_cee_status_e {
-    CEE_PHY_DOWN = 0,
-    CEE_PHY_UP = 1,
-    CEE_UP = 2,
+        CEE_UP = 0,
+        CEE_PHY_UP = 1,
+        CEE_LOOPBACK = 2,
+        CEE_PHY_DOWN = 3,
 };
 
 /* CEE Query */
@@ -107,7 +104,8 @@ struct bfa_cee_attr_s {
         struct bfa_cee_dcbx_cfg_s dcbx_remote;
         mac_t src_mac;
         u8 link_speed;
-        u8 filler[3];
+        u8 nw_priority;
+        u8 filler[2];
 };
 
 
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_driver.h b/drivers/scsi/bfa/include/defs/bfa_defs_driver.h
index 57049805762b..50382dd2ab41 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_driver.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_driver.h
@@ -21,6 +21,7 @@
 /**
  * Driver statistics
  */
+struct bfa_driver_stats_s {
         u16    tm_io_abort;
     u16    tm_io_abort_comp;
     u16    tm_lun_reset;
@@ -34,7 +35,7 @@
     u64    output_req;
     u64    input_words;
     u64    output_words;
-} bfa_driver_stats_t;
+};
 
 
 #endif /* __BFA_DEFS_DRIVER_H__ */
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_ethport.h b/drivers/scsi/bfa/include/defs/bfa_defs_ethport.h
index 79f9b3e146f7..b4fa0923aa89 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_ethport.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_ethport.h
@@ -19,6 +19,7 @@
 #define __BFA_DEFS_ETHPORT_H__
 
 #include <defs/bfa_defs_status.h>
+#include <defs/bfa_defs_port.h>
 #include <protocol/types.h>
 #include <cna/pstats/phyport_defs.h>
 #include <cna/pstats/ethport_defs.h>
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_fcport.h b/drivers/scsi/bfa/include/defs/bfa_defs_fcport.h
new file mode 100644
index 000000000000..a07ef4a3cd78
--- /dev/null
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_fcport.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
+ * All rights reserved
+ * www.brocade.com
+ *
+ *  bfa_defs_fcport.h
+ *
+ * Linux driver for Brocade Fibre Channel Host Bus Adapter.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License (GPL) Version 2 as
+ * published by the Free Software Foundation
+ *
+ * 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.
+ */
+#ifndef __BFA_DEFS_FCPORT_H__
+#define __BFA_DEFS_FCPORT_H__
+
+#include <defs/bfa_defs_types.h>
+#include <protocol/types.h>
+
+#pragma pack(1)
+
+/**
+ * FCoE statistics
+ */
+struct bfa_fcoe_stats_s {
+        u64     secs_reset;     /*  Seconds since stats reset        */
+        u64     cee_linkups;    /*  CEE link up              */
+        u64     cee_linkdns;    /*  CEE link down                    */
+        u64     fip_linkups;    /*  FIP link up              */
+        u64     fip_linkdns;    /*  FIP link down                    */
+        u64     fip_fails;      /*  FIP failures                     */
+        u64     mac_invalids;   /*  Invalid mac assignments          */
+        u64     vlan_req;       /*  Vlan requests                    */
+        u64     vlan_notify;    /*  Vlan notifications               */
+        u64     vlan_err;       /*  Vlan notification errors         */
+        u64     vlan_timeouts;  /*  Vlan request timeouts            */
+        u64     vlan_invalids;  /*  Vlan invalids                    */
+        u64     disc_req;       /*  Discovery requests               */
+        u64     disc_rsp;       /*  Discovery responses      */
+        u64     disc_err;       /*  Discovery error frames           */
+        u64     disc_unsol;     /*  Discovery unsolicited            */
+        u64     disc_timeouts;  /*  Discovery timeouts               */
+        u64     disc_fcf_unavail; /*  Discovery FCF not avail        */
+        u64     linksvc_unsupp; /*  FIP link service req unsupp.    */
+        u64     linksvc_err;    /*  FIP link service req errors     */
+        u64     logo_req;       /*  FIP logo                         */
+        u64     clrvlink_req;   /*  Clear virtual link requests     */
+        u64     op_unsupp;      /*  FIP operation unsupp.            */
+        u64     untagged;       /*  FIP untagged frames      */
+        u64     txf_ucast;      /*  Tx FCoE unicast frames           */
+        u64     txf_ucast_vlan; /*  Tx FCoE unicast vlan frames     */
+        u64     txf_ucast_octets; /*  Tx FCoE unicast octets         */
+        u64     txf_mcast;      /*  Tx FCoE mutlicast frames         */
+        u64     txf_mcast_vlan; /*  Tx FCoE mutlicast vlan frames   */
+        u64     txf_mcast_octets; /*  Tx FCoE multicast octets       */
+        u64     txf_bcast;      /*  Tx FCoE broadcast frames         */
+        u64     txf_bcast_vlan; /*  Tx FCoE broadcast vlan frames   */
+        u64     txf_bcast_octets; /*  Tx FCoE broadcast octets       */
+        u64     txf_timeout;    /*  Tx timeouts              */
+        u64     txf_parity_errors; /*  Transmit parity err           */
+        u64     txf_fid_parity_errors; /*  Transmit FID parity err  */
+        u64     tx_pause;       /*  Tx pause frames                  */
+        u64     tx_zero_pause;  /*  Tx zero pause frames             */
+        u64     tx_first_pause; /*  Tx first pause frames            */
+        u64     rx_pause;       /*  Rx pause frames                  */
+        u64     rx_zero_pause;  /*  Rx zero pause frames             */
+        u64     rx_first_pause; /*  Rx first pause frames            */
+        u64     rxf_ucast_octets; /*  Rx unicast octets      */
+        u64     rxf_ucast;      /*  Rx unicast frames                */
+        u64     rxf_ucast_vlan; /*  Rx unicast vlan frames           */
+        u64     rxf_mcast_octets; /*  Rx multicast octets            */
+        u64     rxf_mcast;      /*  Rx multicast frames      */
+        u64     rxf_mcast_vlan; /*  Rx multicast vlan frames         */
+        u64     rxf_bcast_octets; /*  Rx broadcast octests           */
+        u64     rxf_bcast;      /*  Rx broadcast frames      */
+        u64     rxf_bcast_vlan; /*  Rx broadcast vlan frames         */
+};
+
+/**
+ * QoS or FCoE stats (fcport stats excluding physical FC port stats)
+ */
+union bfa_fcport_stats_u {
+        struct bfa_qos_stats_s  fcqos;
+        struct bfa_fcoe_stats_s fcoe;
+};
+
+#pragma pack()
+
+#endif  /* __BFA_DEFS_FCPORT_H__ */
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_im_common.h b/drivers/scsi/bfa/include/defs/bfa_defs_im_common.h
deleted file mode 100644
index 9ccf53bef65a..000000000000
--- a/drivers/scsi/bfa/include/defs/bfa_defs_im_common.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
- * All rights reserved
- * www.brocade.com
- *
- * Linux driver for Brocade Fibre Channel Host Bus Adapter.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License (GPL) Version 2 as
- * published by the Free Software Foundation
- *
- * 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.
- */
-
-#ifndef __BFA_DEFS_IM_COMMON_H__
-#define __BFA_DEFS_IM_COMMON_H__
-
-#define BFA_ADAPTER_NAME_LEN    256
-#define BFA_ADAPTER_GUID_LEN    256
-#define RESERVED_VLAN_NAME      L"PORT VLAN"
-#define PASSTHRU_VLAN_NAME      L"PASSTHRU VLAN"
-
-        u64     tx_pkt_cnt;
-        u64     rx_pkt_cnt;
-        u32     duration;
-        u8              status;
-} bfa_im_stats_t, *pbfa_im_stats_t;
-
-#endif /* __BFA_DEFS_IM_COMMON_H__ */
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_im_team.h b/drivers/scsi/bfa/include/defs/bfa_defs_im_team.h
deleted file mode 100644
index a486a7eb81d6..000000000000
--- a/drivers/scsi/bfa/include/defs/bfa_defs_im_team.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
- * All rights reserved
- * www.brocade.com
- *
- * Linux driver for Brocade Fibre Channel Host Bus Adapter.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License (GPL) Version 2 as
- * published by the Free Software Foundation
- *
- * 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.
- */
-
-#ifndef __BFA_DEFS_IM_TEAM_H__
-#define __BFA_DEFS_IM_TEAM_H__
-
-#include <protocol/types.h>
-
-#define BFA_TEAM_MAX_PORTS      8
-#define BFA_TEAM_NAME_LEN       256
-#define BFA_MAX_NUM_TEAMS       16
-#define BFA_TEAM_INVALID_DELAY -1
-
-        BFA_LACP_RATE_SLOW = 1,
-        BFA_LACP_RATE_FAST
-} bfa_im_lacp_rate_t;
-
-        BFA_TEAM_MODE_FAIL_OVER = 1,
-        BFA_TEAM_MODE_FAIL_BACK,
-        BFA_TEAM_MODE_LACP,
-        BFA_TEAM_MODE_NONE
-} bfa_im_team_mode_t;
-
-        BFA_XMIT_POLICY_L2 = 1,
-        BFA_XMIT_POLICY_L3_L4
-} bfa_im_xmit_policy_t;
-
-        bfa_im_team_mode_t     team_mode;
-        bfa_im_lacp_rate_t     lacp_rate;
-        bfa_im_xmit_policy_t   xmit_policy;
-        int               delay;
-        wchar_t           primary[BFA_ADAPTER_NAME_LEN];
-        wchar_t           preferred_primary[BFA_ADAPTER_NAME_LEN];
-        mac_t             mac;
-        u16               num_ports;
-        u16          num_vlans;
-        u16 vlan_list[BFA_MAX_VLANS_PER_PORT];
-        wchar_t  team_guid_list[BFA_TEAM_MAX_PORTS][BFA_ADAPTER_GUID_LEN];
-        wchar_t  ioc_name_list[BFA_TEAM_MAX_PORTS][BFA_ADAPTER_NAME_LEN];
-} bfa_im_team_attr_t;
-
-        wchar_t                      team_name[BFA_TEAM_NAME_LEN];
-        bfa_im_xmit_policy_t     xmit_policy;
-        int                      delay;
-        wchar_t                  primary[BFA_ADAPTER_NAME_LEN];
-        wchar_t                  preferred_primary[BFA_ADAPTER_NAME_LEN];
-} bfa_im_team_edit_t, *pbfa_im_team_edit_t;
-
-        wchar_t                                 team_name[BFA_TEAM_NAME_LEN];
-        bfa_im_team_mode_t      team_mode;
-        mac_t                   mac;
-} bfa_im_team_info_t;
-
-        bfa_im_team_info_t              team_info[BFA_MAX_NUM_TEAMS];
-        u16                             num_teams;
-} bfa_im_team_list_t, *pbfa_im_team_list_t;
-
-#endif /* __BFA_DEFS_IM_TEAM_H__ */
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_ioc.h b/drivers/scsi/bfa/include/defs/bfa_defs_ioc.h
index b1d532da3a9d..8d8e6a966537 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_ioc.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_ioc.h
@@ -126,6 +126,7 @@ struct bfa_ioc_attr_s {
         struct bfa_ioc_driver_attr_s    driver_attr;    /*  driver attr    */
         struct bfa_ioc_pci_attr_s       pci_attr;
         u8                              port_id;        /*  port number    */
+        u8                              rsvd[7];        /*!< 64bit align    */
 };
 
 /**
@@ -143,8 +144,8 @@ enum bfa_ioc_aen_event {
  * BFA IOC level event data, now just a place holder
  */
 struct bfa_ioc_aen_data_s {
-        enum bfa_ioc_type_e ioc_type;
         wwn_t   pwwn;
+        s16 ioc_type;
         mac_t   mac;
 };
 
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_iocfc.h b/drivers/scsi/bfa/include/defs/bfa_defs_iocfc.h
index d76bcbd9820f..c290fb13d2d1 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_iocfc.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_iocfc.h
@@ -26,6 +26,8 @@
 
 #define BFA_IOCFC_INTR_DELAY    1125
 #define BFA_IOCFC_INTR_LATENCY  225
+#define BFA_IOCFCOE_INTR_DELAY  25
+#define BFA_IOCFCOE_INTR_LATENCY 5
 
 /**
  * Interrupt coalescing configuration.
@@ -50,7 +52,7 @@ struct bfa_iocfc_fwcfg_s {
         u16        num_fcxp_reqs;       /*  unassisted FC exchanges     */
         u16        num_uf_bufs; /*  unsolicited recv buffers    */
         u8              num_cqs;
-        u8              rsvd;
+        u8              rsvd[5];
 };
 
 struct bfa_iocfc_drvcfg_s {
@@ -224,18 +226,24 @@ struct bfa_fw_port_physm_stats_s {
 
 
 struct bfa_fw_fip_stats_s {
+    u32    vlan_req;           /*  vlan discovery requests             */
+    u32    vlan_notify;        /*  vlan notifications                  */
+    u32    vlan_err;           /*  vlan response error                 */
+    u32    vlan_timeouts;      /*  vlan disvoery timeouts              */
+    u32    vlan_invalids;      /*  invalid vlan in discovery advert.   */
     u32    disc_req;           /*  Discovery solicit requests          */
     u32    disc_rsp;           /*  Discovery solicit response          */
     u32    disc_err;           /*  Discovery advt. parse errors        */
     u32    disc_unsol;         /*  Discovery unsolicited               */
     u32    disc_timeouts;      /*  Discovery timeouts                  */
+    u32    disc_fcf_unavail;   /*  Discovery FCF Not Avail.            */
     u32    linksvc_unsupp;     /*  Unsupported link service req        */
     u32    linksvc_err;        /*  Parse error in link service req     */
     u32    logo_req;           /*  Number of FIP logos received        */
     u32    clrvlink_req;       /*  Clear virtual link req              */
     u32    op_unsupp;          /*  Unsupported FIP operation           */
     u32    untagged;           /*  Untagged frames (ignored)           */
-    u32    rsvd;
+    u32    invalid_version;    /*!< Invalid FIP version           */
 };
 
 
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_lport.h b/drivers/scsi/bfa/include/defs/bfa_defs_lport.h
index 7359f82aacfc..0952a139c47c 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_lport.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_lport.h
@@ -59,8 +59,8 @@ enum bfa_lport_aen_event {
  */
 struct bfa_lport_aen_data_s {
         u16        vf_id;       /*  vf_id of this logical port */
-        u16        rsvd;
-        enum bfa_port_role roles;       /*  Logical port mode,IM/TM/IP etc */
+        s16         roles;  /*  Logical port mode,IM/TM/IP etc */
+        u32        rsvd;
         wwn_t           ppwwn;  /*  WWN of its physical port */
         wwn_t           lpwwn;  /*  WWN of this logical port */
 };
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_mfg.h b/drivers/scsi/bfa/include/defs/bfa_defs_mfg.h
index 13fd4ab6aae2..c5bd9c36ad4d 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_mfg.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_mfg.h
@@ -22,7 +22,47 @@
 /**
  * Manufacturing block version
  */
-#define BFA_MFG_VERSION                         1
+#define BFA_MFG_VERSION                         2
+
+/**
+ * Manufacturing block encrypted version
+ */
+#define BFA_MFG_ENC_VER                         2
+
+/**
+ * Manufacturing block version 1 length
+ */
+#define BFA_MFG_VER1_LEN                        128
+
+/**
+ * Manufacturing block header length
+ */
+#define BFA_MFG_HDR_LEN                         4
+
+/**
+ * Checksum size
+ */
+#define BFA_MFG_CHKSUM_SIZE                     16
+
+/**
+ * Manufacturing block encrypted version
+ */
+#define BFA_MFG_ENC_VER                         2
+
+/**
+ * Manufacturing block version 1 length
+ */
+#define BFA_MFG_VER1_LEN                        128
+
+/**
+ * Manufacturing block header length
+ */
+#define BFA_MFG_HDR_LEN                         4
+
+/**
+ * Checksum size
+ */
+#define BFA_MFG_CHKSUM_SIZE                     16
 
 /**
  * Manufacturing block format
@@ -30,29 +70,74 @@
 #define BFA_MFG_SERIALNUM_SIZE                  11
 #define BFA_MFG_PARTNUM_SIZE                    14
 #define BFA_MFG_SUPPLIER_ID_SIZE                10
-#define BFA_MFG_SUPPLIER_PARTNUM_SIZE   20
-#define BFA_MFG_SUPPLIER_SERIALNUM_SIZE 20
-#define BFA_MFG_SUPPLIER_REVISION_SIZE  4
+#define BFA_MFG_SUPPLIER_PARTNUM_SIZE           20
+#define BFA_MFG_SUPPLIER_SERIALNUM_SIZE         20
+#define BFA_MFG_SUPPLIER_REVISION_SIZE          4
 #define STRSZ(_n)       (((_n) + 4) & ~3)
 
 /**
+ * Manufacturing card type
+ */
+enum {
+        BFA_MFG_TYPE_CB_MAX  = 825,      /*  Crossbow card type max     */
+        BFA_MFG_TYPE_FC8P2   = 825,      /*  8G 2port FC card           */
+        BFA_MFG_TYPE_FC8P1   = 815,      /*  8G 1port FC card           */
+        BFA_MFG_TYPE_FC4P2   = 425,      /*  4G 2port FC card           */
+        BFA_MFG_TYPE_FC4P1   = 415,      /*  4G 1port FC card           */
+        BFA_MFG_TYPE_CNA10P2 = 1020,     /*  10G 2port CNA card */
+        BFA_MFG_TYPE_CNA10P1 = 1010,     /*  10G 1port CNA card */
+};
+
+#pragma pack(1)
+
+/**
+ * Card type to port number conversion
+ */
+#define bfa_mfg_type2port_num(card_type) (((card_type) / 10) % 10)
+
+
+/**
+ * All numerical fields are in big-endian format.
+ */
+struct bfa_mfg_block_s {
+};
+
+/**
  * VPD data length
  */
-#define BFA_MFG_VPD_LEN     256
+#define BFA_MFG_VPD_LEN         512
+
+#define BFA_MFG_VPD_PCI_HDR_OFF         137
+#define BFA_MFG_VPD_PCI_VER_MASK        0x07    /*  version mask 3 bits */
+#define BFA_MFG_VPD_PCI_VDR_MASK        0xf8    /*  vendor mask 5 bits */
+
+/**
+ * VPD vendor tag
+ */
+enum {
+        BFA_MFG_VPD_UNKNOWN     = 0,     /*  vendor unknown             */
+        BFA_MFG_VPD_IBM         = 1,     /*  vendor IBM                 */
+        BFA_MFG_VPD_HP          = 2,     /*  vendor HP                  */
+        BFA_MFG_VPD_DELL        = 3,     /*  vendor DELL                */
+        BFA_MFG_VPD_PCI_IBM     = 0x08,  /*  PCI VPD IBM                */
+        BFA_MFG_VPD_PCI_HP      = 0x10,  /*  PCI VPD HP                 */
+        BFA_MFG_VPD_PCI_DELL    = 0x20,  /*  PCI VPD DELL               */
+        BFA_MFG_VPD_PCI_BRCD    = 0xf8,  /*  PCI VPD Brocade            */
+};
 
 /**
  * All numerical fields are in big-endian format.
  */
 struct bfa_mfg_vpd_s {
-    u8     version;    /*  vpd data version */
-    u8     vpd_sig[3]; /*  characters 'V', 'P', 'D' */
-    u8     chksum;     /*  u8 checksum */
-    u8     vendor;     /*  vendor */
-    u8     len;        /*  vpd data length excluding header */
-    u8     rsv;
-    u8     data[BFA_MFG_VPD_LEN];  /*  vpd data */
+        u8              version;        /*  vpd data version */
+        u8              vpd_sig[3];     /*  characters 'V', 'P', 'D' */
+        u8              chksum;         /*  u8 checksum */
+        u8              vendor;         /*  vendor */
+        u8      len;            /*  vpd data length excluding header */
+        u8      rsv;
+        u8              data[BFA_MFG_VPD_LEN];  /*  vpd data */
 };
 
-#pragma pack(1)
+#pragma pack()
 
 #endif /* __BFA_DEFS_MFG_H__ */
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_port.h b/drivers/scsi/bfa/include/defs/bfa_defs_port.h
index de0696c81bc4..501bc9739d9d 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_port.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_port.h
@@ -185,6 +185,8 @@ struct bfa_port_attr_s {
         wwn_t           fabric_name; /*  attached switch's nwwn */
         u8              fabric_ip_addr[BFA_FCS_FABRIC_IPADDR_SZ]; /*  attached
                                                         * fabric's ip addr */
+        struct mac_s    fpma_mac;       /*  Lport's FPMA Mac address */
+        u16     authfail;               /*  auth failed state */
 };
 
 /**
@@ -232,14 +234,15 @@ enum bfa_port_aen_sfp_pom {
 };
 
 struct bfa_port_aen_data_s {
-        enum bfa_ioc_type_e ioc_type;
-        wwn_t           pwwn;         /*  WWN of the physical port */
-        wwn_t           fwwn;         /*  WWN of the fabric port */
-        mac_t           mac;          /*  MAC addres of the ethernet port,
-                                       * applicable to CNA port only */
-        int             phy_port_num; /*! For SFP related events */
-        enum bfa_port_aen_sfp_pom level; /*  Only transitions will
-                                          * be informed */
+        wwn_t           pwwn;         /*  WWN of the physical port */
+        wwn_t           fwwn;         /*  WWN of the fabric port */
+        s32         phy_port_num; /*! For SFP related events */
+        s16         ioc_type;
+        s16         level;        /*  Only transitions will
+                                        * be informed */
+        struct mac_s    mac;          /*  MAC address of the ethernet port,
+                                        * applicable to CNA port only */
+        s16         rsvd;
 };
 
 #endif /* __BFA_DEFS_PORT_H__ */
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_pport.h b/drivers/scsi/bfa/include/defs/bfa_defs_pport.h
index a000bc4e2d4a..26e5cc78095d 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_pport.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_pport.h
@@ -61,7 +61,7 @@ enum bfa_pport_speed {
  *              Port operational type (in sync with SNIA port type).
  */
 enum bfa_pport_type {
-        BFA_PPORT_TYPE_UNKNOWN = 1,     /*  port type is unkown */
+        BFA_PPORT_TYPE_UNKNOWN = 1,     /*  port type is unknown */
         BFA_PPORT_TYPE_TRUNKED = 2,     /*  Trunked mode */
         BFA_PPORT_TYPE_NPORT   = 5,     /*  P2P with switched fabric */
         BFA_PPORT_TYPE_NLPORT  = 6,     /*  public loop */
@@ -232,7 +232,7 @@ struct bfa_pport_attr_s {
         u32             pid;            /*  port ID */
         enum bfa_pport_type     port_type;      /*  current topology */
         u32             loopback;       /*  external loopback */
-        u32             rsvd1;
+        u32             authfail;       /* auth fail state */
         u32             rsvd2;          /*  padding for 64 bit */
 };
 
@@ -240,73 +240,79 @@ struct bfa_pport_attr_s {
  *              FC Port statistics.
  */
 struct bfa_pport_fc_stats_s {
-        u64        secs_reset;  /*  seconds since stats is reset */
-        u64        tx_frames;   /*  transmitted frames */
-        u64        tx_words;    /*  transmitted words */
-        u64        rx_frames;   /*  received frames */
-        u64        rx_words;    /*  received words */
-        u64        lip_count;   /*  LIPs seen */
-        u64        nos_count;   /*  NOS count */
-        u64        error_frames;        /*  errored frames (sent?) */
-        u64        dropped_frames;      /*  dropped frames */
-        u64        link_failures;       /*  link failure count */
-        u64        loss_of_syncs;       /*  loss of sync count */
-        u64        loss_of_signals;/*  loss of signal count */
-        u64        primseq_errs;        /*  primitive sequence protocol */
-        u64        bad_os_count;        /*  invalid ordered set */
-        u64        err_enc_out; /*  Encoding error outside frame */
-        u64        invalid_crcs;        /*  frames received with invalid CRC*/
-        u64     undersized_frm; /*  undersized frames */
-        u64     oversized_frm;  /*  oversized frames */
-        u64     bad_eof_frm;    /*  frames with bad EOF */
-        struct bfa_qos_stats_s  qos_stats;      /*  QoS statistics */
+        u64    secs_reset; /* Seconds since stats is reset     */
+        u64    tx_frames;  /* Tx frames                */
+        u64    tx_words;   /* Tx words                 */
+        u64    tx_lip;     /* TX LIP               */
+        u64    tx_nos;     /* Tx NOS               */
+        u64    tx_ols;     /* Tx OLS               */
+        u64    tx_lr;      /* Tx LR                */
+        u64    tx_lrr;     /* Tx LRR               */
+        u64    rx_frames;  /* Rx frames                */
+        u64    rx_words;   /* Rx words                 */
+        u64    lip_count;  /* Rx LIP                   */
+        u64    nos_count;  /* Rx NOS               */
+        u64    ols_count;  /* Rx OLS               */
+        u64    lr_count;   /* Rx LR                */
+        u64    lrr_count;  /* Rx LRR               */
+        u64    invalid_crcs;   /* Rx CRC err frames            */
+        u64    invalid_crc_gd_eof; /* Rx CRC err good EOF frames   */
+        u64    undersized_frm; /* Rx undersized frames         */
+        u64    oversized_frm;  /* Rx oversized frames          */
+        u64    bad_eof_frm;    /* Rx frames with bad EOF       */
+        u64    error_frames;   /* Errored frames           */
+        u64    dropped_frames; /* Dropped frames           */
+        u64    link_failures;  /* Link Failure (LF) count          */
+        u64    loss_of_syncs;  /* Loss of sync count           */
+        u64    loss_of_signals;/* Loss of signal count         */
+        u64    primseq_errs;   /* Primitive sequence protocol err. */
+        u64    bad_os_count;   /* Invalid ordered sets         */
+        u64    err_enc_out;    /* Encoding err nonframe_8b10b      */
+        u64    err_enc;    /* Encoding err frame_8b10b         */
 };
 
 /**
  *              Eth Port statistics.
  */
 struct bfa_pport_eth_stats_s {
-        u64     secs_reset;     /*  seconds since stats is reset */
-        u64     frame_64;      /*  both rx and tx counter */
-        u64     frame_65_127;      /* both rx and tx counter */
-        u64     frame_128_255;     /* both rx and tx counter */
-        u64     frame_256_511;     /* both rx and tx counter */
-        u64     frame_512_1023;    /* both rx and tx counter */
-        u64     frame_1024_1518;   /* both rx and tx counter */
-        u64     frame_1519_1522;   /* both rx and tx counter */
-
-        u64     tx_bytes;
-        u64     tx_packets;
-        u64     tx_mcast_packets;
-        u64     tx_bcast_packets;
-        u64     tx_control_frame;
-        u64     tx_drop;
-        u64     tx_jabber;
-        u64     tx_fcs_error;
-        u64     tx_fragments;
-
-        u64     rx_bytes;
-        u64     rx_packets;
-        u64     rx_mcast_packets;
-        u64     rx_bcast_packets;
-        u64     rx_control_frames;
-        u64     rx_unknown_opcode;
-        u64     rx_drop;
-        u64     rx_jabber;
-        u64     rx_fcs_error;
-        u64     rx_alignment_error;
-        u64     rx_frame_length_error;
-        u64     rx_code_error;
-        u64     rx_fragments;
-
-        u64     rx_pause; /* BPC */
-        u64     rx_zero_pause; /*  BPC Pause cancellation */
-        u64     tx_pause;      /* BPC */
-        u64     tx_zero_pause; /*  BPC Pause cancellation */
-        u64     rx_fcoe_pause; /* BPC */
-        u64     rx_fcoe_zero_pause; /*  BPC Pause cancellation */
-        u64     tx_fcoe_pause;      /* BPC */
-        u64     tx_fcoe_zero_pause; /*  BPC Pause cancellation */
+        u64    secs_reset;   /* Seconds since stats is reset   */
+        u64    frame_64;     /* Frames 64 bytes            */
+        u64    frame_65_127;     /* Frames 65-127 bytes        */
+        u64    frame_128_255;    /* Frames 128-255 bytes       */
+        u64    frame_256_511;    /* Frames 256-511 bytes       */
+        u64    frame_512_1023;   /* Frames 512-1023 bytes          */
+        u64    frame_1024_1518;  /* Frames 1024-1518 bytes         */
+        u64    frame_1519_1522;  /* Frames 1519-1522 bytes         */
+        u64    tx_bytes;     /* Tx bytes               */
+        u64    tx_packets;   /* Tx packets             */
+        u64    tx_mcast_packets; /* Tx multicast packets       */
+        u64    tx_bcast_packets; /* Tx broadcast packets       */
+        u64    tx_control_frame; /* Tx control frame           */
+        u64    tx_drop;      /* Tx drops               */
+        u64    tx_jabber;    /* Tx jabber              */
+        u64    tx_fcs_error;     /* Tx FCS error           */
+        u64    tx_fragments;     /* Tx fragments           */
+        u64    rx_bytes;     /* Rx bytes               */
+        u64    rx_packets;   /* Rx packets             */
+        u64    rx_mcast_packets; /* Rx multicast packets       */
+        u64    rx_bcast_packets; /* Rx broadcast packets       */
+        u64    rx_control_frames; /* Rx control frames         */
+        u64    rx_unknown_opcode; /* Rx unknown opcode         */
+        u64    rx_drop;      /* Rx drops               */
+        u64    rx_jabber;    /* Rx jabber              */
+        u64    rx_fcs_error;     /* Rx FCS errors              */
+        u64    rx_alignment_error; /* Rx alignment errors          */
+        u64    rx_frame_length_error; /* Rx frame len errors       */
+        u64    rx_code_error;    /* Rx code errors             */
+        u64    rx_fragments;     /* Rx fragments           */
+        u64    rx_pause;     /* Rx pause               */
+        u64    rx_zero_pause;    /* Rx zero pause              */
+        u64    tx_pause;     /* Tx pause               */
+        u64    tx_zero_pause;    /* Tx zero pause              */
+        u64    rx_fcoe_pause;    /* Rx fcoe pause              */
+        u64    rx_fcoe_zero_pause; /* Rx FCoE zero pause       */
+        u64    tx_fcoe_pause;    /* Tx FCoE pause              */
+        u64    tx_fcoe_zero_pause; /* Tx FCoE zero pause       */
 };
 
 /**
@@ -333,8 +339,7 @@ struct bfa_pport_fcpmap_s {
 };
 
 /**
- *              Port RNID info.
- */
+ *              Port RNI         */
 struct bfa_pport_rnid_s {
         wwn_t             wwn;
         u32          unittype;
@@ -347,6 +352,23 @@ struct bfa_pport_rnid_s {
         u16          topologydiscoveryflags;
 };
 
+struct bfa_fcport_fcf_s {
+        wwn_t           name;           /* FCF name                 */
+        wwn_t           fabric_name;    /* Fabric Name              */
+        u8              fipenabled;     /* FIP enabled or not       */
+        u8              fipfailed;      /* FIP failed or not        */
+        u8              resv[2];
+        u8              pri;            /* FCF priority             */
+        u8              version;        /* FIP version used         */
+        u8              available;      /* Available  for  login    */
+        u8              fka_disabled;   /* FKA is disabled          */
+        u8              maxsz_verified; /* FCoE max size verified   */
+        u8              fc_map[3];      /* FC map                   */
+        u16             vlan;           /* FCoE vlan tag/priority   */
+        u32             fka_adv_per;    /* FIP  ka advert. period   */
+        struct mac_s    mac;            /* FCF mac                  */
+};
+
 /**
  *              Link state information
  */
@@ -378,6 +400,7 @@ struct bfa_pport_link_s {
                         struct fc_alpabm_s     alpabm;     /*  alpa bitmap */
                 } loop_info;
         } tl;
+        struct bfa_fcport_fcf_s fcf;    /*!< FCF information (for FCoE) */
 };
 
 #endif /* __BFA_DEFS_PPORT_H__ */
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_status.h b/drivers/scsi/bfa/include/defs/bfa_defs_status.h
index cdceaeb9f4b8..4374494bd566 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_status.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_status.h
@@ -180,8 +180,8 @@ enum bfa_status {
         BFA_STATUS_IM_ADAPT_ALREADY_IN_TEAM = 114, /*  Given adapter is part
                                                     * of another team */
         BFA_STATUS_IM_ADAPT_HAS_VLANS = 115, /*  Adapter has VLANs configured.
-                                              * Delete all VLANs before
-                                              * creating team */
+                                              * Delete all VLANs to become
+                                              * part of the team */
         BFA_STATUS_IM_PVID_MISMATCH = 116, /*  Mismatching PVIDs configured
                                             * for adapters */
         BFA_STATUS_IM_LINK_SPEED_MISMATCH = 117, /*  Mismatching link speeds
@@ -213,7 +213,7 @@ enum bfa_status {
                                              * loaded */
         BFA_STATUS_CARD_TYPE_MISMATCH = 131, /*  Card type mismatch */
         BFA_STATUS_BAD_ASICBLK = 132, /*  Bad ASIC block */
-        BFA_STATUS_NO_DRIVER = 133, /*  Storage/Ethernet driver not loaded */
+        BFA_STATUS_NO_DRIVER = 133, /*  Brocade adapter/driver not installed or loaded */
         BFA_STATUS_INVALID_MAC = 134, /*  Invalid mac address */
         BFA_STATUS_IM_NO_VLAN = 135, /*  No VLANs configured on the adapter */
         BFA_STATUS_IM_ETH_LB_FAILED = 136, /*  Ethernet loopback test failed */
@@ -228,8 +228,7 @@ enum bfa_status {
         BFA_STATUS_IM_GET_INETCFG_FAILED = 142, /*  Acquiring Network Subsytem
                                                  * handle Failed. Please try
                                                  * after some time */
-        BFA_STATUS_IM_NOT_BOUND = 143, /*  Brocade 10G Ethernet Service is not
-                                        * Enabled on this port */
+        BFA_STATUS_IM_NOT_BOUND = 143, /*  IM driver is not active */
         BFA_STATUS_INSUFFICIENT_PERMS = 144, /*  User doesn't have sufficient
                                               * permissions to execute the BCU
                                               * application */
@@ -242,6 +241,14 @@ enum bfa_status {
                                           * failed */
         BFA_STATUS_IM_UNBIND_FAILED = 149, /* ! < IM Driver unbind operation
                                             * failed */
+        BFA_STATUS_IM_PORT_IN_TEAM = 150, /*  Port is already part of the
+                                           * team */
+        BFA_STATUS_IM_VLAN_NOT_FOUND = 151, /*  VLAN ID doesn't exists */
+        BFA_STATUS_IM_TEAM_NOT_FOUND = 152, /*  Teaming configuration doesn't
+                                             * exists */
+        BFA_STATUS_IM_TEAM_CFG_NOT_ALLOWED = 153, /*  Given settings are not
+                                                * allowed for the current
+                                                * Teaming mode */
         BFA_STATUS_MAX_VAL              /*  Unknown error code */
 };
 #define bfa_status_t enum bfa_status
diff --git a/drivers/scsi/bfa/include/defs/bfa_defs_tsensor.h b/drivers/scsi/bfa/include/defs/bfa_defs_tsensor.h
index 31881d218515..ade763dbc8ce 100644
--- a/drivers/scsi/bfa/include/defs/bfa_defs_tsensor.h
+++ b/drivers/scsi/bfa/include/defs/bfa_defs_tsensor.h
@@ -25,7 +25,7 @@
  * Temperature sensor status values
  */
 enum bfa_tsensor_status {
-        BFA_TSENSOR_STATUS_UNKNOWN   = 1,   /*  unkown status */
+        BFA_TSENSOR_STATUS_UNKNOWN   = 1,   /*  unknown status */
         BFA_TSENSOR_STATUS_FAULTY    = 2,   /*  sensor is faulty */
         BFA_TSENSOR_STATUS_BELOW_MIN = 3,   /*  temperature below mininum */
         BFA_TSENSOR_STATUS_NOMINAL   = 4,   /*  normal temperature */
diff --git a/drivers/scsi/bfa/include/fcb/bfa_fcb_fcpim.h b/drivers/scsi/bfa/include/fcb/bfa_fcb_fcpim.h
index a6c70aee0aa3..52585d3dd891 100644
--- a/drivers/scsi/bfa/include/fcb/bfa_fcb_fcpim.h
+++ b/drivers/scsi/bfa/include/fcb/bfa_fcb_fcpim.h
@@ -70,7 +70,6 @@ void            bfa_fcb_itnim_online(struct bfad_itnim_s *itnim_drv);
  */
 void            bfa_fcb_itnim_offline(struct bfad_itnim_s *itnim_drv);
 
-void            bfa_fcb_itnim_tov_begin(struct bfad_itnim_s *itnim_drv);
 void            bfa_fcb_itnim_tov(struct bfad_itnim_s *itnim_drv);
 
 #endif /* __BFAD_FCB_FCPIM_H__ */
diff --git a/drivers/scsi/bfa/include/fcs/bfa_fcs.h b/drivers/scsi/bfa/include/fcs/bfa_fcs.h
index 627669c65546..f2fd35fdee28 100644
--- a/drivers/scsi/bfa/include/fcs/bfa_fcs.h
+++ b/drivers/scsi/bfa/include/fcs/bfa_fcs.h
@@ -49,6 +49,7 @@ struct bfa_fcs_s {
         struct bfa_trc_mod_s  *trcmod;  /*  tracing module */
         struct bfa_aen_s      *aen;     /*  aen component */
         bfa_boolean_t   vf_enabled;     /*  VF mode is enabled */
+        bfa_boolean_t   fdmi_enabled;   /*!< FDMI is enabled */
         bfa_boolean_t min_cfg;          /* min cfg enabled/disabled */
         u16        port_vfid;   /*  port default VF ID */
         struct bfa_fcs_driver_info_s driver_info;
@@ -60,10 +61,12 @@ struct bfa_fcs_s {
 /*
  * bfa fcs API functions
  */
-void bfa_fcs_init(struct bfa_fcs_s *fcs, struct bfa_s *bfa, struct bfad_s *bfad,
+void bfa_fcs_attach(struct bfa_fcs_s *fcs, struct bfa_s *bfa, struct bfad_s *bfad,
                         bfa_boolean_t min_cfg);
+void bfa_fcs_init(struct bfa_fcs_s *fcs);
 void bfa_fcs_driver_info_init(struct bfa_fcs_s *fcs,
                         struct bfa_fcs_driver_info_s *driver_info);
+void bfa_fcs_set_fdmi_param(struct bfa_fcs_s *fcs, bfa_boolean_t fdmi_enable);
 void bfa_fcs_exit(struct bfa_fcs_s *fcs);
 void bfa_fcs_trc_init(struct bfa_fcs_s *fcs, struct bfa_trc_mod_s *trcmod);
 void bfa_fcs_log_init(struct bfa_fcs_s *fcs, struct bfa_log_mod_s *logmod);
diff --git a/drivers/scsi/bfa/include/fcs/bfa_fcs_fabric.h b/drivers/scsi/bfa/include/fcs/bfa_fcs_fabric.h
index 4ffd2242d3de..08b79d5e46f3 100644
--- a/drivers/scsi/bfa/include/fcs/bfa_fcs_fabric.h
+++ b/drivers/scsi/bfa/include/fcs/bfa_fcs_fabric.h
@@ -75,7 +75,7 @@ struct bfa_fcs_fabric_s {
                                                             */
 };
 
-#define bfa_fcs_fabric_npiv_capable(__f)    (__f)->is_npiv
+#define bfa_fcs_fabric_npiv_capable(__f)    ((__f)->is_npiv)
 #define bfa_fcs_fabric_is_switched(__f)                 \
         ((__f)->fab_type == BFA_FCS_FABRIC_SWITCHED)
 
diff --git a/drivers/scsi/bfa/include/fcs/bfa_fcs_lport.h b/drivers/scsi/bfa/include/fcs/bfa_fcs_lport.h
index b85cba884b96..ceaefd3060f4 100644
--- a/drivers/scsi/bfa/include/fcs/bfa_fcs_lport.h
+++ b/drivers/scsi/bfa/include/fcs/bfa_fcs_lport.h
@@ -34,14 +34,6 @@ struct bfa_fcs_s;
 struct bfa_fcs_fabric_s;
 
 /*
-* @todo : need to move to a global config file.
- * Maximum Vports supported per physical port or vf.
- */
-#define BFA_FCS_MAX_VPORTS_SUPP_CB  255
-#define BFA_FCS_MAX_VPORTS_SUPP_CT  191
-
-/*
-* @todo : need to move to a global config file.
  * Maximum Rports supported per port (physical/logical).
  */
 #define BFA_FCS_MAX_RPORTS_SUPP  256    /* @todo : tentative value */
@@ -125,12 +117,12 @@ union bfa_fcs_port_topo_u {
 struct bfa_fcs_port_s {
         struct list_head         qe;    /*  used by port/vport */
         bfa_sm_t               sm;      /*  state machine */
-        struct bfa_fcs_fabric_s *fabric;        /*  parent fabric */
-        struct bfa_port_cfg_s  port_cfg;        /*  port configuration */
+        struct bfa_fcs_fabric_s *fabric;/*  parent fabric */
+        struct bfa_port_cfg_s  port_cfg;/*  port configuration */
         struct bfa_timer_s link_timer;  /*  timer for link offline */
-        u32        pid : 24;    /*  FC address */
-        u8         lp_tag;              /*  lport tag */
-        u16        num_rports;  /*  Num of r-ports */
+        u32 pid:24;     /*  FC address */
+        u8  lp_tag;     /*  lport tag */
+        u16 num_rports; /*  Num of r-ports */
         struct list_head rport_q;       /*  queue of discovered r-ports */
         struct bfa_fcs_s *fcs;  /*  FCS instance */
         union bfa_fcs_port_topo_u port_topo;    /*  fabric/loop/n2n details */
@@ -188,13 +180,14 @@ bfa_fcs_port_get_drvport(struct bfa_fcs_port_s *port)
 }
 
 
-#define bfa_fcs_port_get_opertype(_lport)       (_lport)->fabric->oper_type
+#define bfa_fcs_port_get_opertype(_lport)       ((_lport)->fabric->oper_type)
 
 
-#define bfa_fcs_port_get_fabric_name(_lport)    (_lport)->fabric->fabric_name
+#define bfa_fcs_port_get_fabric_name(_lport)    ((_lport)->fabric->fabric_name)
 
 
-#define bfa_fcs_port_get_fabric_ipaddr(_lport)  (_lport)->fabric->fabric_ip_addr
+#define bfa_fcs_port_get_fabric_ipaddr(_lport) \
+                ((_lport)->fabric->fabric_ip_addr)
 
 /**
  * bfa fcs port public functions
diff --git a/drivers/scsi/bfa/include/log/bfa_log_hal.h b/drivers/scsi/bfa/include/log/bfa_log_hal.h
index 0412aea2ec30..5f8f5e30b9e8 100644
--- a/drivers/scsi/bfa/include/log/bfa_log_hal.h
+++ b/drivers/scsi/bfa/include/log/bfa_log_hal.h
@@ -27,4 +27,10 @@
         (((u32) BFA_LOG_HAL_ID << BFA_LOG_MODID_OFFSET) | 3)
 #define BFA_LOG_HAL_SM_ASSERT \
         (((u32) BFA_LOG_HAL_ID << BFA_LOG_MODID_OFFSET) | 4)
+#define BFA_LOG_HAL_DRIVER_ERROR \
+        (((u32) BFA_LOG_HAL_ID << BFA_LOG_MODID_OFFSET) | 5)
+#define BFA_LOG_HAL_DRIVER_CONFIG_ERROR \
+        (((u32) BFA_LOG_HAL_ID << BFA_LOG_MODID_OFFSET) | 6)
+#define BFA_LOG_HAL_MBOX_ERROR \
+        (((u32) BFA_LOG_HAL_ID << BFA_LOG_MODID_OFFSET) | 7)
 #endif
diff --git a/drivers/scsi/bfa/include/log/bfa_log_linux.h b/drivers/scsi/bfa/include/log/bfa_log_linux.h
index 317c0547ee16..bd451db4c30a 100644
--- a/drivers/scsi/bfa/include/log/bfa_log_linux.h
+++ b/drivers/scsi/bfa/include/log/bfa_log_linux.h
@@ -41,4 +41,20 @@
                 (((u32) BFA_LOG_LINUX_ID << BFA_LOG_MODID_OFFSET) | 10)
 #define BFA_LOG_LINUX_SCSI_ABORT_COMP \
                 (((u32) BFA_LOG_LINUX_ID << BFA_LOG_MODID_OFFSET) | 11)
+#define BFA_LOG_LINUX_DRIVER_CONFIG_ERROR \
+                (((u32) BFA_LOG_LINUX_ID << BFA_LOG_MODID_OFFSET) | 12)
+#define BFA_LOG_LINUX_BNA_STATE_MACHINE \
+                (((u32) BFA_LOG_LINUX_ID << BFA_LOG_MODID_OFFSET) | 13)
+#define BFA_LOG_LINUX_IOC_ERROR \
+        (((u32) BFA_LOG_LINUX_ID << BFA_LOG_MODID_OFFSET) | 14)
+#define BFA_LOG_LINUX_RESOURCE_ALLOC_ERROR \
+        (((u32) BFA_LOG_LINUX_ID << BFA_LOG_MODID_OFFSET) | 15)
+#define BFA_LOG_LINUX_RING_BUFFER_ERROR \
+        (((u32) BFA_LOG_LINUX_ID << BFA_LOG_MODID_OFFSET) | 16)
+#define BFA_LOG_LINUX_DRIVER_ERROR \
+        (((u32) BFA_LOG_LINUX_ID << BFA_LOG_MODID_OFFSET) | 17)
+#define BFA_LOG_LINUX_DRIVER_DIAG \
+        (((u32) BFA_LOG_LINUX_ID << BFA_LOG_MODID_OFFSET) | 18)
+#define BFA_LOG_LINUX_DRIVER_AEN \
+        (((u32) BFA_LOG_LINUX_ID << BFA_LOG_MODID_OFFSET) | 19)
 #endif
diff --git a/drivers/scsi/bfa/include/protocol/ct.h b/drivers/scsi/bfa/include/protocol/ct.h
index c59d6630b070..b82540a230c4 100644
--- a/drivers/scsi/bfa/include/protocol/ct.h
+++ b/drivers/scsi/bfa/include/protocol/ct.h
@@ -82,7 +82,7 @@ enum {
 };
 
 /*
- * defintions for CT reason code
+ * definitions for CT reason code
  */
 enum {
         CT_RSN_INV_CMD          = 0x01,
@@ -129,7 +129,7 @@ enum {
 };
 
 /*
- * defintions for the explanation code for all servers
+ * definitions for the explanation code for all servers
  */
 enum {
         CT_EXP_AUTH_EXCEPTION                   = 0xF1,
@@ -193,11 +193,11 @@ struct fcgs_rftid_req_s {
 #define FC_GS_FCP_FC4_FEATURE_TARGET     0x01
 
 struct fcgs_rffid_req_s{
-    u32    rsvd          :8;
-    u32    dap            :24;          /* port identifier      */
-    u32    rsvd1         :16;
-    u32    fc4ftr_bits   :8;            /* fc4 feature bits     */
-    u32    fc4_type      :8;            /* corresponding FC4 Type */
+    u32    rsvd:8;
+    u32    dap:24;              /* port identifier      */
+    u32    rsvd1:16;
+    u32    fc4ftr_bits:8;       /* fc4 feature bits     */
+    u32    fc4_type:8;  /* corresponding FC4 Type */
 };
 
 /**
diff --git a/drivers/scsi/bfa/include/protocol/fc.h b/drivers/scsi/bfa/include/protocol/fc.h
index 3e39ba58cfb5..8d1038035a76 100644
--- a/drivers/scsi/bfa/include/protocol/fc.h
+++ b/drivers/scsi/bfa/include/protocol/fc.h
@@ -50,6 +50,11 @@ struct fchs_s {
 
         u32        ro;          /* relative offset */
 };
+
+#define FC_SOF_LEN      4
+#define FC_EOF_LEN      4
+#define FC_CRC_LEN      4
+
 /*
  * Fibre Channel BB_E Header Structure
  */
@@ -486,14 +491,14 @@ struct fc_rsi_s {
  * see FC-PH-X table 113 & 115 for explanation also FCP table 8
  */
 struct fc_prli_params_s{
-        u32        reserved: 16;
+        u32        reserved:16;
 #ifdef __BIGENDIAN
-        u32        reserved1: 5;
-        u32        rec_support : 1;
-        u32        task_retry_id : 1;
-        u32        retry : 1;
+        u32        reserved1:5;
+        u32        rec_support:1;
+        u32        task_retry_id:1;
+        u32        retry:1;
 
-        u32        confirm : 1;
+        u32        confirm:1;
         u32        doverlay:1;
         u32        initiator:1;
         u32        target:1;
@@ -502,10 +507,10 @@ struct fc_prli_params_s{
         u32        rxrdisab:1;
         u32        wxrdisab:1;
 #else
-        u32        retry : 1;
-        u32        task_retry_id : 1;
-        u32        rec_support : 1;
-        u32        reserved1: 5;
+        u32        retry:1;
+        u32        task_retry_id:1;
+        u32        rec_support:1;
+        u32        reserved1:5;
 
         u32        wxrdisab:1;
         u32        rxrdisab:1;
@@ -514,7 +519,7 @@ struct fc_prli_params_s{
         u32        target:1;
         u32        initiator:1;
         u32        doverlay:1;
-        u32        confirm : 1;
+        u32        confirm:1;
 #endif
 };
 
diff --git a/drivers/scsi/bfa/include/protocol/pcifw.h b/drivers/scsi/bfa/include/protocol/pcifw.h
deleted file mode 100644
index 6830dc3ee58a..000000000000
--- a/drivers/scsi/bfa/include/protocol/pcifw.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2005-2009 Brocade Communications Systems, Inc.
- * All rights reserved
- * www.brocade.com
- *
- * Linux driver for Brocade Fibre Channel Host Bus Adapter.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License (GPL) Version 2 as
- * published by the Free Software Foundation
- *
- * 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.
- */
-
-/**
- *  pcifw.h PCI FW related headers
- */
-
-#ifndef __PCIFW_H__
-#define __PCIFW_H__
-
-#pragma pack(1)
-
-struct pnp_hdr_s{
-  u32   signature;      /* "$PnP" */
-  u8    rev;            /* Struct revision */
-  u8    len;            /* Header structure len in multiples
-                                 * of 16 bytes */
-  u16  off;             /* Offset to next header 00 if none */
-  u8    rsvd;           /* Reserved byte */
-  u8    cksum;          /* 8-bit checksum for this header */
-  u32   pnp_dev_id;     /* PnP Device Id */
-  u16  mfstr;           /* Pointer to manufacturer string */
-  u16   prstr;          /* Pointer to product string */
-  u8    devtype[3];     /* Device Type Code */
-  u8    devind;         /* Device Indicator */
-  u16   bcventr;        /* Bootstrap entry vector */
-  u16   rsvd2;          /* Reserved */
-  u16  sriv;            /* Static resource information vector */
-};
-
-struct pci_3_0_ds_s{
- u32    sig;            /* Signature "PCIR" */
- u16    vendid;         /* Vendor ID */
- u16    devid;          /* Device ID */
- u16    devlistoff;     /* Device List Offset */
- u16    len;            /* PCI Data Structure Length */
- u8     rev;            /* PCI Data Structure Revision */
- u8     clcode[3];      /* Class Code */
- u16    imglen;         /* Code image length in multiples of
-                                 * 512 bytes */
- u16    coderev;        /* Revision level of code/data */
- u8     codetype;       /* Code type 0x00 - BIOS */
- u8     indr;           /* Last image indicator */
- u16    mrtimglen;      /* Max Run Time Image Length */
- u16    cuoff;          /* Config Utility Code Header Offset */
- u16    dmtfclp;        /* DMTF CLP entry point offset */
-};
-
-struct pci_optrom_hdr_s{
- u16    sig;            /* Signature 0x55AA */
- u8     len;            /* Option ROM length in units of 512 bytes */
- u8     inivec[3];      /* Initialization vector */
- u8     rsvd[16];       /* Reserved field */
- u16    verptr;         /* Pointer to version string - private */
- u16    pcids;          /* Pointer to PCI data structure */
- u16    pnphdr;         /* Pointer to PnP expansion header */
-};
-
-#pragma pack()
-
-#endif
diff --git a/drivers/scsi/bfa/loop.c b/drivers/scsi/bfa/loop.c
index a418dedebe9e..f6342efb6a90 100644
--- a/drivers/scsi/bfa/loop.c
+++ b/drivers/scsi/bfa/loop.c
@@ -58,49 +58,16 @@ static const u8   port_loop_alpa_map[] = {
 /*
  * Local Functions
  */
-bfa_status_t    bfa_fcs_port_loop_send_plogi(struct bfa_fcs_port_s *port,
-                                             u8 alpa);
-
-void            bfa_fcs_port_loop_plogi_response(void *fcsarg,
-                                                 struct bfa_fcxp_s *fcxp,
-                                                 void *cbarg,
-                                                 bfa_status_t req_status,
-                                                 u32 rsp_len,
-                                                 u32 resid_len,
-                                                 struct fchs_s *rsp_fchs);
-
-bfa_status_t    bfa_fcs_port_loop_send_adisc(struct bfa_fcs_port_s *port,
-                                             u8 alpa);
-
-void            bfa_fcs_port_loop_adisc_response(void *fcsarg,
-                                                 struct bfa_fcxp_s *fcxp,
-                                                 void *cbarg,
-                                                 bfa_status_t req_status,
-                                                 u32 rsp_len,
-                                                 u32 resid_len,
-                                                 struct fchs_s *rsp_fchs);
-
-bfa_status_t    bfa_fcs_port_loop_send_plogi_acc(struct bfa_fcs_port_s *port,
-                                                 u8 alpa);
-
-void            bfa_fcs_port_loop_plogi_acc_response(void *fcsarg,
-                                                     struct bfa_fcxp_s *fcxp,
-                                                     void *cbarg,
-                                                     bfa_status_t req_status,
-                                                     u32 rsp_len,
-                                                     u32 resid_len,
-                                                     struct fchs_s *rsp_fchs);
-
-bfa_status_t    bfa_fcs_port_loop_send_adisc_acc(struct bfa_fcs_port_s *port,
-                                                 u8 alpa);
-
-void            bfa_fcs_port_loop_adisc_acc_response(void *fcsarg,
-                                                     struct bfa_fcxp_s *fcxp,
-                                                     void *cbarg,
-                                                     bfa_status_t req_status,
-                                                     u32 rsp_len,
-                                                     u32 resid_len,
-                                                     struct fchs_s *rsp_fchs);
+static bfa_status_t bfa_fcs_port_loop_send_plogi(struct bfa_fcs_port_s *port,
+                                        u8 alpa);
+
+static void bfa_fcs_port_loop_plogi_response(void *fcsarg,
+                                        struct bfa_fcxp_s *fcxp,
+                                        void *cbarg,
+                                        bfa_status_t req_status,
+                                        u32 rsp_len,
+                                        u32 resid_len,
+                                        struct fchs_s *rsp_fchs);
 /**
  *   Called by port to initializar in provate LOOP topology.
  */
@@ -179,7 +146,7 @@ bfa_fcs_port_loop_lip(struct bfa_fcs_port_s *port)
 /**
  * Local Functions.
  */
-bfa_status_t
+static bfa_status_t
 bfa_fcs_port_loop_send_plogi(struct bfa_fcs_port_s *port, u8 alpa)
 {
         struct fchs_s          fchs;
@@ -195,7 +162,7 @@ bfa_fcs_port_loop_send_plogi(struct bfa_fcs_port_s *port, u8 alpa)
         len = fc_plogi_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), alpa,
                              bfa_fcs_port_get_fcid(port), 0,
                              port->port_cfg.pwwn, port->port_cfg.nwwn,
-                                 bfa_pport_get_maxfrsize(port->fcs->bfa));
+                                 bfa_fcport_get_maxfrsize(port->fcs->bfa));
 
         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
                           FC_CLASS_3, len, &fchs,
@@ -208,7 +175,7 @@ bfa_fcs_port_loop_send_plogi(struct bfa_fcs_port_s *port, u8 alpa)
 /**
  *   Called by fcxp to notify the Plogi response
  */
-void
+static void
 bfa_fcs_port_loop_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
                                  void *cbarg, bfa_status_t req_status,
                                  u32 rsp_len, u32 resid_len,
@@ -244,179 +211,3 @@ bfa_fcs_port_loop_plogi_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
                 bfa_assert(0);
         }
 }
-
-bfa_status_t
-bfa_fcs_port_loop_send_plogi_acc(struct bfa_fcs_port_s *port, u8 alpa)
-{
-        struct fchs_s          fchs;
-        struct bfa_fcxp_s *fcxp;
-        int             len;
-
-        bfa_trc(port->fcs, alpa);
-
-        fcxp = bfa_fcxp_alloc(NULL, port->fcs->bfa, 0, 0, NULL, NULL, NULL,
-                                  NULL);
-        bfa_assert(fcxp);
-
-        len = fc_plogi_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), alpa,
-                                 bfa_fcs_port_get_fcid(port), 0,
-                                 port->port_cfg.pwwn, port->port_cfg.nwwn,
-                                 bfa_pport_get_maxfrsize(port->fcs->bfa));
-
-        bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
-                                 FC_CLASS_3, len, &fchs,
-                                 bfa_fcs_port_loop_plogi_acc_response,
-                                 (void *)port, FC_MAX_PDUSZ, 0); /* No response
-                                                                  * expected
-                                                                  */
-
-        return BFA_STATUS_OK;
-}
-
-/*
- *  Plogi Acc Response
- * We donot do any processing here.
- */
-void
-bfa_fcs_port_loop_plogi_acc_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
-                                     void *cbarg, bfa_status_t req_status,
-                                     u32 rsp_len, u32 resid_len,
-                                     struct fchs_s *rsp_fchs)
-{
-
-        struct bfa_fcs_port_s *port = (struct bfa_fcs_port_s *) cbarg;
-
-        bfa_trc(port->fcs, port->pid);
-
-        /*
-         * Sanity Checks
-         */
-        if (req_status != BFA_STATUS_OK) {
-                bfa_trc(port->fcs, req_status);
-                return;
-        }
-}
-
-bfa_status_t
-bfa_fcs_port_loop_send_adisc(struct bfa_fcs_port_s *port, u8 alpa)
-{
-        struct fchs_s          fchs;
-        struct bfa_fcxp_s *fcxp;
-        int             len;
-
-        bfa_trc(port->fcs, alpa);
-
-        fcxp = bfa_fcxp_alloc(NULL, port->fcs->bfa, 0, 0, NULL, NULL, NULL,
-                                  NULL);
-        bfa_assert(fcxp);
-
-        len = fc_adisc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), alpa,
-                             bfa_fcs_port_get_fcid(port), 0,
-                             port->port_cfg.pwwn, port->port_cfg.nwwn);
-
-        bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
-                          FC_CLASS_3, len, &fchs,
-                          bfa_fcs_port_loop_adisc_response, (void *)port,
-                          FC_MAX_PDUSZ, FC_RA_TOV);
-
-        return BFA_STATUS_OK;
-}
-
-/**
- *   Called by fcxp to notify the ADISC response
- */
-void
-bfa_fcs_port_loop_adisc_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
-                                 void *cbarg, bfa_status_t req_status,
-                                 u32 rsp_len, u32 resid_len,
-                                 struct fchs_s *rsp_fchs)
-{
-        struct bfa_fcs_port_s *port = (struct bfa_fcs_port_s *) cbarg;
-        struct bfa_fcs_rport_s *rport;
-        struct fc_adisc_s     *adisc_resp;
-        struct fc_els_cmd_s   *els_cmd;
-        u32        pid = rsp_fchs->s_id;
-
-        bfa_trc(port->fcs, req_status);
-
-        /*
-         * Sanity Checks
-         */
-        if (req_status != BFA_STATUS_OK) {
-                /*
-                 * TBD : we may need to retry certain requests
-                 */
-                bfa_fcxp_free(fcxp);
-                return;
-        }
-
-        els_cmd = (struct fc_els_cmd_s *) BFA_FCXP_RSP_PLD(fcxp);
-        adisc_resp = (struct fc_adisc_s *) els_cmd;
-
-        if (els_cmd->els_code == FC_ELS_ACC) {
-        } else {
-                bfa_trc(port->fcs, adisc_resp->els_cmd.els_code);
-
-                /*
-                 * TBD: we may need to check for reject codes and retry
-                 */
-                rport = bfa_fcs_port_get_rport_by_pid(port, pid);
-                if (rport) {
-                        list_del(&rport->qe);
-                        bfa_fcs_rport_delete(rport);
-                }
-
-        }
-        return;
-}
-
-bfa_status_t
-bfa_fcs_port_loop_send_adisc_acc(struct bfa_fcs_port_s *port, u8 alpa)
-{
-        struct fchs_s          fchs;
-        struct bfa_fcxp_s *fcxp;
-        int             len;
-
-        bfa_trc(port->fcs, alpa);
-
-        fcxp = bfa_fcxp_alloc(NULL, port->fcs->bfa, 0, 0, NULL, NULL, NULL,
-                                  NULL);
-        bfa_assert(fcxp);
-
-        len = fc_adisc_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), alpa,
-                                 bfa_fcs_port_get_fcid(port), 0,
-                                 port->port_cfg.pwwn, port->port_cfg.nwwn);
-
-        bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
-                                FC_CLASS_3, len, &fchs,
-                                bfa_fcs_port_loop_adisc_acc_response,
-                                (void *)port, FC_MAX_PDUSZ, 0); /* no reponse
-                                                                 * expected
-                                                                 */
-
-        return BFA_STATUS_OK;
-}
-
-/*
- *  Adisc Acc Response
- * We donot do any processing here.
- */
-void
-bfa_fcs_port_loop_adisc_acc_response(void *fcsarg, struct bfa_fcxp_s *fcxp,
-                                     void *cbarg, bfa_status_t req_status,
-                                     u32 rsp_len, u32 resid_len,
-                                     struct fchs_s *rsp_fchs)
-{
-
-        struct bfa_fcs_port_s *port = (struct bfa_fcs_port_s *) cbarg;
-
-        bfa_trc(port->fcs, port->pid);
-
-        /*
-         * Sanity Checks
-         */
-        if (req_status != BFA_STATUS_OK) {
-                bfa_trc(port->fcs, req_status);
-                return;
-        }
-}
diff --git a/drivers/scsi/bfa/lport_api.c b/drivers/scsi/bfa/lport_api.c
index 8f51a83f1834..d3907d184e2b 100644
--- a/drivers/scsi/bfa/lport_api.c
+++ b/drivers/scsi/bfa/lport_api.c
@@ -43,7 +43,7 @@ bfa_fcs_cfg_base_port(struct bfa_fcs_s *fcs, struct bfa_port_cfg_s *port_cfg)
 struct bfa_fcs_port_s *
 bfa_fcs_get_base_port(struct bfa_fcs_s *fcs)
 {
-        return (&fcs->fabric.bport);
+        return &fcs->fabric.bport;
 }
 
 wwn_t
@@ -88,11 +88,10 @@ bfa_fcs_port_get_rport(struct bfa_fcs_port_s *port, wwn_t wwn, int index,
         }
 
         bfa_trc(fcs, i);
-        if (rport) {
+        if (rport)
                 return rport->pwwn;
-        } else {
+        else
                 return (wwn_t) 0;
-        }
 }
 
 void
@@ -157,7 +156,7 @@ bfa_fcs_port_get_rport_max_speed(struct bfa_fcs_port_s *port)
         /*
          * Get Physical port's current speed
          */
-        bfa_pport_get_attr(port->fcs->bfa, &pport_attr);
+        bfa_fcport_get_attr(port->fcs->bfa, &pport_attr);
         pport_speed = pport_attr.speed;
         bfa_trc(fcs, pport_speed);
 
@@ -198,17 +197,17 @@ bfa_fcs_lookup_port(struct bfa_fcs_s *fcs, u16 vf_id, wwn_t lpwwn)
         vf = bfa_fcs_vf_lookup(fcs, vf_id);
         if (vf == NULL) {
                 bfa_trc(fcs, vf_id);
-                return (NULL);
+                return NULL;
         }
 
         if (!lpwwn || (vf->bport.port_cfg.pwwn == lpwwn))
-                return (&vf->bport);
+                return &vf->bport;
 
         vport = bfa_fcs_fabric_vport_lookup(vf, lpwwn);
         if (vport)
-                return (&vport->lport);
+                return &vport->lport;
 
-        return (NULL);
+        return NULL;
 }
 
 /*
@@ -236,7 +235,8 @@ bfa_fcs_port_get_info(struct bfa_fcs_port_s *port,
                 port_info->port_wwn = bfa_fcs_port_get_pwwn(port);
                 port_info->node_wwn = bfa_fcs_port_get_nwwn(port);
 
-                port_info->max_vports_supp = bfa_fcs_vport_get_max(port->fcs);
+                port_info->max_vports_supp =
+                        bfa_lps_get_max_vport(port->fcs->bfa);
                 port_info->num_vports_inuse =
                         bfa_fcs_fabric_vport_count(port->fabric);
                 port_info->max_rports_supp = BFA_FCS_MAX_RPORTS_SUPP;
diff --git a/drivers/scsi/bfa/ms.c b/drivers/scsi/bfa/ms.c
index c96b3ca007ae..5e8c8dee6c97 100644
--- a/drivers/scsi/bfa/ms.c
+++ b/drivers/scsi/bfa/ms.c
@@ -118,7 +118,7 @@ bfa_fcs_port_ms_sm_offline(struct bfa_fcs_port_ms_s *ms,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ms->port->fcs, event);
         }
 }
 
@@ -141,7 +141,7 @@ bfa_fcs_port_ms_sm_plogi_sending(struct bfa_fcs_port_ms_s *ms,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ms->port->fcs, event);
         }
 }
 
@@ -190,7 +190,7 @@ bfa_fcs_port_ms_sm_plogi(struct bfa_fcs_port_ms_s *ms, enum port_ms_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ms->port->fcs, event);
         }
 }
 
@@ -216,7 +216,7 @@ bfa_fcs_port_ms_sm_plogi_retry(struct bfa_fcs_port_ms_s *ms,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ms->port->fcs, event);
         }
 }
 
@@ -230,10 +230,6 @@ bfa_fcs_port_ms_sm_online(struct bfa_fcs_port_ms_s *ms,
         switch (event) {
         case MSSM_EVENT_PORT_OFFLINE:
                 bfa_sm_set_state(ms, bfa_fcs_port_ms_sm_offline);
-                /*
-                 * now invoke MS related sub-modules
-                 */
-                bfa_fcs_port_fdmi_offline(ms);
                 break;
 
         case MSSM_EVENT_PORT_FABRIC_RSCN:
@@ -243,7 +239,7 @@ bfa_fcs_port_ms_sm_online(struct bfa_fcs_port_ms_s *ms,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ms->port->fcs, event);
         }
 }
 
@@ -266,7 +262,7 @@ bfa_fcs_port_ms_sm_gmal_sending(struct bfa_fcs_port_ms_s *ms,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ms->port->fcs, event);
         }
 }
 
@@ -304,7 +300,7 @@ bfa_fcs_port_ms_sm_gmal(struct bfa_fcs_port_ms_s *ms, enum port_ms_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ms->port->fcs, event);
         }
 }
 
@@ -330,7 +326,7 @@ bfa_fcs_port_ms_sm_gmal_retry(struct bfa_fcs_port_ms_s *ms,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ms->port->fcs, event);
         }
 }
 
@@ -466,7 +462,7 @@ bfa_fcs_port_ms_sm_gfn_sending(struct bfa_fcs_port_ms_s *ms,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ms->port->fcs, event);
         }
 }
 
@@ -502,7 +498,7 @@ bfa_fcs_port_ms_sm_gfn(struct bfa_fcs_port_ms_s *ms, enum port_ms_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ms->port->fcs, event);
         }
 }
 
@@ -528,7 +524,7 @@ bfa_fcs_port_ms_sm_gfn_retry(struct bfa_fcs_port_ms_s *ms,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ms->port->fcs, event);
         }
 }
 
@@ -637,7 +633,7 @@ bfa_fcs_port_ms_send_plogi(void *ms_cbarg, struct bfa_fcxp_s *fcxp_alloced)
                              bfa_os_hton3b(FC_MGMT_SERVER),
                              bfa_fcs_port_get_fcid(port), 0,
                              port->port_cfg.pwwn, port->port_cfg.nwwn,
-                             bfa_pport_get_maxfrsize(port->fcs->bfa));
+                             bfa_fcport_get_maxfrsize(port->fcs->bfa));
 
         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
                       FC_CLASS_3, len, &fchs, bfa_fcs_port_ms_plogi_response,
@@ -735,6 +731,7 @@ bfa_fcs_port_ms_offline(struct bfa_fcs_port_s *port)
 
         ms->port = port;
         bfa_sm_send_event(ms, MSSM_EVENT_PORT_OFFLINE);
+        bfa_fcs_port_fdmi_offline(ms);
 }
 
 void
diff --git a/drivers/scsi/bfa/ns.c b/drivers/scsi/bfa/ns.c
index 59fea99d67a4..d20dd7e15742 100644
--- a/drivers/scsi/bfa/ns.c
+++ b/drivers/scsi/bfa/ns.c
@@ -164,7 +164,7 @@ bfa_fcs_port_ns_sm_offline(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -187,7 +187,7 @@ bfa_fcs_port_ns_sm_plogi_sending(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -221,7 +221,7 @@ bfa_fcs_port_ns_sm_plogi(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -247,7 +247,7 @@ bfa_fcs_port_ns_sm_plogi_retry(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -270,7 +270,7 @@ bfa_fcs_port_ns_sm_sending_rspn_id(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -304,7 +304,7 @@ bfa_fcs_port_ns_sm_rspn_id(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -330,7 +330,7 @@ bfa_fcs_port_ns_sm_rspn_id_retry(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -353,7 +353,7 @@ bfa_fcs_port_ns_sm_sending_rft_id(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -390,7 +390,7 @@ bfa_fcs_port_ns_sm_rft_id(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -413,7 +413,7 @@ bfa_fcs_port_ns_sm_rft_id_retry(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -436,7 +436,7 @@ bfa_fcs_port_ns_sm_sending_rff_id(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -494,7 +494,7 @@ bfa_fcs_port_ns_sm_rff_id(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -517,7 +517,7 @@ bfa_fcs_port_ns_sm_rff_id_retry(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 static void
@@ -539,7 +539,7 @@ bfa_fcs_port_ns_sm_sending_gid_ft(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -575,7 +575,7 @@ bfa_fcs_port_ns_sm_gid_ft(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -598,7 +598,7 @@ bfa_fcs_port_ns_sm_gid_ft_retry(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -626,7 +626,7 @@ bfa_fcs_port_ns_sm_online(struct bfa_fcs_port_ns_s *ns,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(ns->port->fcs, event);
         }
 }
 
@@ -660,7 +660,7 @@ bfa_fcs_port_ns_send_plogi(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
                              bfa_os_hton3b(FC_NAME_SERVER),
                              bfa_fcs_port_get_fcid(port), 0,
                              port->port_cfg.pwwn, port->port_cfg.nwwn,
-                             bfa_pport_get_maxfrsize(port->fcs->bfa));
+                             bfa_fcport_get_maxfrsize(port->fcs->bfa));
 
         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
                       FC_CLASS_3, len, &fchs, bfa_fcs_port_ns_plogi_response,
@@ -932,11 +932,10 @@ bfa_fcs_port_ns_send_rff_id(void *ns_cbarg, struct bfa_fcxp_s *fcxp_alloced)
         }
         ns->fcxp = fcxp;
 
-        if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns->port)) {
+        if (BFA_FCS_VPORT_IS_INITIATOR_MODE(ns->port))
                 fc4_ftrs = FC_GS_FCP_FC4_FEATURE_INITIATOR;
-        } else if (BFA_FCS_VPORT_IS_TARGET_MODE(ns->port)) {
+        else if (BFA_FCS_VPORT_IS_TARGET_MODE(ns->port))
                 fc4_ftrs = FC_GS_FCP_FC4_FEATURE_TARGET;
-        }
 
         len = fc_rffid_build(&fchs, bfa_fcxp_get_reqbuf(fcxp),
                              bfa_fcs_port_get_fcid(port), 0, FC_TYPE_FCP,
diff --git a/drivers/scsi/bfa/plog.c b/drivers/scsi/bfa/plog.c
index 86af818d17bb..fcb8864d3276 100644
--- a/drivers/scsi/bfa/plog.c
+++ b/drivers/scsi/bfa/plog.c
@@ -180,5 +180,5 @@ bfa_plog_disable(struct bfa_plog_s *plog)
 bfa_boolean_t
 bfa_plog_get_setting(struct bfa_plog_s *plog)
 {
-        return((bfa_boolean_t)plog->plog_enabled);
+        return (bfa_boolean_t)plog->plog_enabled;
 }
diff --git a/drivers/scsi/bfa/rport.c b/drivers/scsi/bfa/rport.c
index 9cf58bb138dc..7b096f2e3836 100644
--- a/drivers/scsi/bfa/rport.c
+++ b/drivers/scsi/bfa/rport.c
@@ -19,6 +19,7 @@
  *  rport.c Remote port implementation.
  */
 
+#include <linux/slab.h>
 #include <bfa.h>
 #include <bfa_svc.h>
 #include "fcbuild.h"
@@ -224,7 +225,7 @@ bfa_fcs_rport_sm_uninit(struct bfa_fcs_rport_s *rport, enum rport_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -276,7 +277,7 @@ bfa_fcs_rport_sm_plogi_sending(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -332,7 +333,7 @@ bfa_fcs_rport_sm_plogiacc_sending(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -406,7 +407,7 @@ bfa_fcs_rport_sm_plogi_retry(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -481,7 +482,7 @@ bfa_fcs_rport_sm_plogi(struct bfa_fcs_rport_s *rport, enum rport_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -534,7 +535,7 @@ bfa_fcs_rport_sm_hal_online(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -589,7 +590,7 @@ bfa_fcs_rport_sm_online(struct bfa_fcs_rport_s *rport, enum rport_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -646,7 +647,7 @@ bfa_fcs_rport_sm_nsquery_sending(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -704,7 +705,7 @@ bfa_fcs_rport_sm_nsquery(struct bfa_fcs_rport_s *rport, enum rport_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -754,7 +755,7 @@ bfa_fcs_rport_sm_adisc_sending(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -816,7 +817,7 @@ bfa_fcs_rport_sm_adisc(struct bfa_fcs_rport_s *rport, enum rport_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -846,7 +847,7 @@ bfa_fcs_rport_sm_fc4_logorcv(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -869,7 +870,7 @@ bfa_fcs_rport_sm_fc4_logosend(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -905,7 +906,7 @@ bfa_fcs_rport_sm_fc4_offline(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -925,10 +926,17 @@ bfa_fcs_rport_sm_hcb_offline(struct bfa_fcs_rport_s *rport,
         case RPSM_EVENT_HCB_OFFLINE:
         case RPSM_EVENT_ADDRESS_CHANGE:
                 if (bfa_fcs_port_is_online(rport->port)) {
-                        bfa_sm_set_state(rport,
-                                         bfa_fcs_rport_sm_nsdisc_sending);
-                        rport->ns_retries = 0;
-                        bfa_fcs_rport_send_gidpn(rport, NULL);
+                        if (bfa_fcs_fabric_is_switched(rport->port->fabric)) {
+                                bfa_sm_set_state(rport,
+                                        bfa_fcs_rport_sm_nsdisc_sending);
+                                rport->ns_retries = 0;
+                                bfa_fcs_rport_send_gidpn(rport, NULL);
+                        } else {
+                                bfa_sm_set_state(rport,
+                                        bfa_fcs_rport_sm_plogi_sending);
+                                rport->plogi_retries = 0;
+                                bfa_fcs_rport_send_plogi(rport, NULL);
+                        }
                 } else {
                         rport->pid = 0;
                         bfa_sm_set_state(rport, bfa_fcs_rport_sm_offline);
@@ -951,7 +959,7 @@ bfa_fcs_rport_sm_hcb_offline(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -1011,7 +1019,7 @@ bfa_fcs_rport_sm_hcb_logorcv(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -1038,7 +1046,7 @@ bfa_fcs_rport_sm_hcb_logosend(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -1073,7 +1081,7 @@ bfa_fcs_rport_sm_logo_sending(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -1132,7 +1140,7 @@ bfa_fcs_rport_sm_offline(struct bfa_fcs_rport_s *rport, enum rport_event event)
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -1188,7 +1196,7 @@ bfa_fcs_rport_sm_nsdisc_sending(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -1249,7 +1257,7 @@ bfa_fcs_rport_sm_nsdisc_retry(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -1334,7 +1342,7 @@ bfa_fcs_rport_sm_nsdisc_sent(struct bfa_fcs_rport_s *rport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -1366,7 +1374,7 @@ bfa_fcs_rport_send_plogi(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
         len = fc_plogi_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), rport->pid,
                              bfa_fcs_port_get_fcid(port), 0,
                              port->port_cfg.pwwn, port->port_cfg.nwwn,
-                             bfa_pport_get_maxfrsize(port->fcs->bfa));
+                             bfa_fcport_get_maxfrsize(port->fcs->bfa));
 
         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
                       FC_CLASS_3, len, &fchs, bfa_fcs_rport_plogi_response,
@@ -1478,7 +1486,7 @@ bfa_fcs_rport_send_plogiacc(void *rport_cbarg, struct bfa_fcxp_s *fcxp_alloced)
         len = fc_plogi_acc_build(&fchs, bfa_fcxp_get_reqbuf(fcxp), rport->pid,
                                  bfa_fcs_port_get_fcid(port), rport->reply_oxid,
                                  port->port_cfg.pwwn, port->port_cfg.nwwn,
-                                 bfa_pport_get_maxfrsize(port->fcs->bfa));
+                                 bfa_fcport_get_maxfrsize(port->fcs->bfa));
 
         bfa_fcxp_send(fcxp, NULL, port->fabric->vf_id, port->lp_tag, BFA_FALSE,
                       FC_CLASS_3, len, &fchs, NULL, NULL, FC_MAX_PDUSZ, 0);
@@ -1813,7 +1821,7 @@ bfa_fcs_rport_process_rpsc(struct bfa_fcs_rport_s *rport,
         /*
          * get curent speed from pport attributes from BFA
          */
-        bfa_pport_get_attr(port->fcs->bfa, &pport_attr);
+        bfa_fcport_get_attr(port->fcs->bfa, &pport_attr);
 
         speeds.port_op_speed = fc_bfa_speed_to_rpsc_operspeed(pport_attr.speed);
 
@@ -2032,13 +2040,10 @@ bfa_fcs_rport_aen_post(struct bfa_fcs_rport_s *rport,
 
         switch (event) {
         case BFA_RPORT_AEN_ONLINE:
-                bfa_log(logmod, BFA_AEN_RPORT_ONLINE, rpwwn_ptr, lpwwn_ptr);
-                break;
         case BFA_RPORT_AEN_OFFLINE:
-                bfa_log(logmod, BFA_AEN_RPORT_OFFLINE, rpwwn_ptr, lpwwn_ptr);
-                break;
         case BFA_RPORT_AEN_DISCONNECT:
-                bfa_log(logmod, BFA_AEN_RPORT_DISCONNECT, rpwwn_ptr, lpwwn_ptr);
+                bfa_log(logmod, BFA_LOG_CREATE_ID(BFA_AEN_CAT_RPORT, event),
+                        rpwwn_ptr, lpwwn_ptr);
                 break;
         case BFA_RPORT_AEN_QOS_PRIO:
                 aen_data.rport.priv.qos = data->priv.qos;
@@ -2164,7 +2169,7 @@ bfa_fcs_rport_update(struct bfa_fcs_rport_s *rport, struct fc_logi_s *plogi)
                 bfa_trc(port->fcs, port->fabric->bb_credit);
 
                 port->fabric->bb_credit = bfa_os_ntohs(plogi->csp.bbcred);
-                bfa_pport_set_tx_bbcredit(port->fcs->bfa,
+                bfa_fcport_set_tx_bbcredit(port->fcs->bfa,
                                           port->fabric->bb_credit);
         }
 
@@ -2575,23 +2580,6 @@ bfa_fcs_rport_send_ls_rjt(struct bfa_fcs_rport_s *rport, struct fchs_s *rx_fchs,
 }
 
 /**
- *   Module initialization
- */
-void
-bfa_fcs_rport_modinit(struct bfa_fcs_s *fcs)
-{
-}
-
-/**
- *   Module cleanup
- */
-void
-bfa_fcs_rport_modexit(struct bfa_fcs_s *fcs)
-{
-        bfa_fcs_modexit_comp(fcs);
-}
-
-/**
  * Return state of rport.
  */
 int
diff --git a/drivers/scsi/bfa/rport_api.c b/drivers/scsi/bfa/rport_api.c
index 3dae1774181e..a441f41d2a64 100644
--- a/drivers/scsi/bfa/rport_api.c
+++ b/drivers/scsi/bfa/rport_api.c
@@ -102,7 +102,7 @@ bfa_fcs_rport_get_attr(struct bfa_fcs_rport_s *rport,
         rport_attr->qos_attr = qos_attr;
 
         rport_attr->trl_enforced = BFA_FALSE;
-        if (bfa_pport_is_ratelim(port->fcs->bfa)) {
+        if (bfa_fcport_is_ratelim(port->fcs->bfa)) {
                 if ((rport->rpf.rpsc_speed == BFA_PPORT_SPEED_UNKNOWN) ||
                         (rport->rpf.rpsc_speed <
                         bfa_fcs_port_get_rport_max_speed(port)))
diff --git a/drivers/scsi/bfa/rport_ftrs.c b/drivers/scsi/bfa/rport_ftrs.c
index 8a1f59d596c1..ae7bba67ae2a 100644
--- a/drivers/scsi/bfa/rport_ftrs.c
+++ b/drivers/scsi/bfa/rport_ftrs.c
@@ -79,7 +79,7 @@ bfa_fcs_rpf_sm_uninit(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
         bfa_trc(rport->fcs, event);
 
         switch (event) {
-        case RPFSM_EVENT_RPORT_ONLINE :
+        case RPFSM_EVENT_RPORT_ONLINE:
                 if (!BFA_FCS_PID_IS_WKA(rport->pid)) {
                         bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_rpsc_sending);
                         rpf->rpsc_retries = 0;
@@ -87,11 +87,11 @@ bfa_fcs_rpf_sm_uninit(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
                         break;
                 };
 
-        case RPFSM_EVENT_RPORT_OFFLINE :
+        case RPFSM_EVENT_RPORT_OFFLINE:
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -107,14 +107,14 @@ bfa_fcs_rpf_sm_rpsc_sending(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_rpsc);
                 break;
 
-        case RPFSM_EVENT_RPORT_OFFLINE :
+        case RPFSM_EVENT_RPORT_OFFLINE:
                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_offline);
                 bfa_fcxp_walloc_cancel(rport->fcs->bfa, &rpf->fcxp_wqe);
                 rpf->rpsc_retries = 0;
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -130,11 +130,10 @@ bfa_fcs_rpf_sm_rpsc(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
         case RPFSM_EVENT_RPSC_COMP:
                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_online);
                 /* Update speed info in f/w via BFA */
-                if (rpf->rpsc_speed != BFA_PPORT_SPEED_UNKNOWN) {
+                if (rpf->rpsc_speed != BFA_PPORT_SPEED_UNKNOWN)
                         bfa_rport_speed(rport->bfa_rport, rpf->rpsc_speed);
-                } else if (rpf->assigned_speed != BFA_PPORT_SPEED_UNKNOWN) {
+                else if (rpf->assigned_speed != BFA_PPORT_SPEED_UNKNOWN)
                         bfa_rport_speed(rport->bfa_rport, rpf->assigned_speed);
-                }
                 break;
 
         case RPFSM_EVENT_RPSC_FAIL:
@@ -154,14 +153,14 @@ bfa_fcs_rpf_sm_rpsc(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
                 }
                 break;
 
-        case RPFSM_EVENT_RPORT_OFFLINE :
+        case RPFSM_EVENT_RPORT_OFFLINE:
                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_offline);
                 bfa_fcxp_discard(rpf->fcxp);
                 rpf->rpsc_retries = 0;
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -174,20 +173,20 @@ bfa_fcs_rpf_sm_rpsc_retry(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
         bfa_trc(rport->fcs, event);
 
         switch (event) {
-        case RPFSM_EVENT_TIMEOUT :
+        case RPFSM_EVENT_TIMEOUT:
                 /* re-send the RPSC */
                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_rpsc_sending);
                 bfa_fcs_rpf_send_rpsc2(rpf, NULL);
                 break;
 
-        case RPFSM_EVENT_RPORT_OFFLINE :
+        case RPFSM_EVENT_RPORT_OFFLINE:
                 bfa_timer_stop(&rpf->timer);
                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_offline);
                 rpf->rpsc_retries = 0;
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -201,13 +200,13 @@ bfa_fcs_rpf_sm_online(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
         bfa_trc(rport->fcs, event);
 
         switch (event) {
-        case RPFSM_EVENT_RPORT_OFFLINE :
+        case RPFSM_EVENT_RPORT_OFFLINE:
                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_offline);
                 rpf->rpsc_retries = 0;
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 
@@ -221,16 +220,16 @@ bfa_fcs_rpf_sm_offline(struct bfa_fcs_rpf_s *rpf, enum rpf_event event)
         bfa_trc(rport->fcs, event);
 
         switch (event) {
-        case RPFSM_EVENT_RPORT_ONLINE :
+        case RPFSM_EVENT_RPORT_ONLINE:
                 bfa_sm_set_state(rpf, bfa_fcs_rpf_sm_rpsc_sending);
                 bfa_fcs_rpf_send_rpsc2(rpf, NULL);
                 break;
 
-        case RPFSM_EVENT_RPORT_OFFLINE :
+        case RPFSM_EVENT_RPORT_OFFLINE:
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(rport->fcs, event);
         }
 }
 /**
@@ -366,10 +365,9 @@ bfa_fcs_rpf_rpsc2_response(void *fcsarg, struct bfa_fcxp_s *fcxp, void *cbarg,
                 bfa_trc(rport->fcs, ls_rjt->reason_code);
                 bfa_trc(rport->fcs, ls_rjt->reason_code_expl);
                 rport->stats.rpsc_rejects++;
-                if (ls_rjt->reason_code == FC_LS_RJT_RSN_CMD_NOT_SUPP) {
+                if (ls_rjt->reason_code == FC_LS_RJT_RSN_CMD_NOT_SUPP)
                         bfa_sm_send_event(rpf, RPFSM_EVENT_RPSC_FAIL);
-                } else {
+                else
                         bfa_sm_send_event(rpf, RPFSM_EVENT_RPSC_ERROR);
-                }
         }
 }
diff --git a/drivers/scsi/bfa/scn.c b/drivers/scsi/bfa/scn.c
index bd4771ff62c8..8fe09ba88a91 100644
--- a/drivers/scsi/bfa/scn.c
+++ b/drivers/scsi/bfa/scn.c
@@ -90,7 +90,7 @@ bfa_fcs_port_scn_sm_offline(struct bfa_fcs_port_scn_s *scn,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(scn->port->fcs, event);
         }
 }
 
@@ -109,7 +109,7 @@ bfa_fcs_port_scn_sm_sending_scr(struct bfa_fcs_port_scn_s *scn,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(scn->port->fcs, event);
         }
 }
 
@@ -137,7 +137,7 @@ bfa_fcs_port_scn_sm_scr(struct bfa_fcs_port_scn_s *scn,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(scn->port->fcs, event);
         }
 }
 
@@ -157,7 +157,7 @@ bfa_fcs_port_scn_sm_scr_retry(struct bfa_fcs_port_scn_s *scn,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(scn->port->fcs, event);
         }
 }
 
@@ -171,7 +171,7 @@ bfa_fcs_port_scn_sm_online(struct bfa_fcs_port_scn_s *scn,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(scn->port->fcs, event);
         }
 }
 
diff --git a/drivers/scsi/bfa/vfapi.c b/drivers/scsi/bfa/vfapi.c
index 31d81fe2fc48..391a4790bebd 100644
--- a/drivers/scsi/bfa/vfapi.c
+++ b/drivers/scsi/bfa/vfapi.c
@@ -189,7 +189,7 @@ bfa_fcs_vf_lookup(struct bfa_fcs_s *fcs, u16 vf_id)
 {
         bfa_trc(fcs, vf_id);
         if (vf_id == FC_VF_ID_NULL)
-                return (&fcs->fabric);
+                return &fcs->fabric;
 
         /**
          * @todo vf support
diff --git a/drivers/scsi/bfa/vport.c b/drivers/scsi/bfa/vport.c
index c10af06c5714..27cd619a227a 100644
--- a/drivers/scsi/bfa/vport.c
+++ b/drivers/scsi/bfa/vport.c
@@ -31,13 +31,13 @@
 
 BFA_TRC_FILE(FCS, VPORT);
 
-#define __vport_fcs(__vp)       (__vp)->lport.fcs
-#define __vport_pwwn(__vp)      (__vp)->lport.port_cfg.pwwn
-#define __vport_nwwn(__vp)      (__vp)->lport.port_cfg.nwwn
-#define __vport_bfa(__vp)       (__vp)->lport.fcs->bfa
-#define __vport_fcid(__vp)      (__vp)->lport.pid
-#define __vport_fabric(__vp)    (__vp)->lport.fabric
-#define __vport_vfid(__vp)      (__vp)->lport.fabric->vf_id
+#define __vport_fcs(__vp)       ((__vp)->lport.fcs)
+#define __vport_pwwn(__vp)      ((__vp)->lport.port_cfg.pwwn)
+#define __vport_nwwn(__vp)      ((__vp)->lport.port_cfg.nwwn)
+#define __vport_bfa(__vp)       ((__vp)->lport.fcs->bfa)
+#define __vport_fcid(__vp)      ((__vp)->lport.pid)
+#define __vport_fabric(__vp)    ((__vp)->lport.fabric)
+#define __vport_vfid(__vp)      ((__vp)->lport.fabric->vf_id)
 
 #define BFA_FCS_VPORT_MAX_RETRIES  5
 /*
@@ -122,7 +122,7 @@ bfa_fcs_vport_sm_uninit(struct bfa_fcs_vport_s *vport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(__vport_fcs(vport), event);
         }
 }
 
@@ -165,7 +165,7 @@ bfa_fcs_vport_sm_created(struct bfa_fcs_vport_s *vport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(__vport_fcs(vport), event);
         }
 }
 
@@ -202,7 +202,7 @@ bfa_fcs_vport_sm_offline(struct bfa_fcs_vport_s *vport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(__vport_fcs(vport), event);
         }
 }
 
@@ -249,7 +249,7 @@ bfa_fcs_vport_sm_fdisc(struct bfa_fcs_vport_s *vport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(__vport_fcs(vport), event);
         }
 }
 
@@ -283,7 +283,7 @@ bfa_fcs_vport_sm_fdisc_retry(struct bfa_fcs_vport_s *vport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(__vport_fcs(vport), event);
         }
 }
 
@@ -310,7 +310,7 @@ bfa_fcs_vport_sm_online(struct bfa_fcs_vport_s *vport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(__vport_fcs(vport), event);
         }
 }
 
@@ -339,7 +339,7 @@ bfa_fcs_vport_sm_deleting(struct bfa_fcs_vport_s *vport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(__vport_fcs(vport), event);
         }
 }
 
@@ -387,7 +387,7 @@ bfa_fcs_vport_sm_cleanup(struct bfa_fcs_vport_s *vport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(__vport_fcs(vport), event);
         }
 }
 
@@ -419,7 +419,7 @@ bfa_fcs_vport_sm_logo(struct bfa_fcs_vport_s *vport,
                 break;
 
         default:
-                bfa_assert(0);
+                bfa_sm_fault(__vport_fcs(vport), event);
         }
 }
 
@@ -447,22 +447,8 @@ bfa_fcs_vport_aen_post(bfa_fcs_lport_t *port, enum bfa_lport_aen_event event)
 
         bfa_assert(role <= BFA_PORT_ROLE_FCP_MAX);
 
-        switch (event) {
-        case BFA_LPORT_AEN_NPIV_DUP_WWN:
-                bfa_log(logmod, BFA_AEN_LPORT_NPIV_DUP_WWN, lpwwn_ptr,
-                        role_str[role / 2]);
-                break;
-        case BFA_LPORT_AEN_NPIV_FABRIC_MAX:
-                bfa_log(logmod, BFA_AEN_LPORT_NPIV_FABRIC_MAX, lpwwn_ptr,
-                        role_str[role / 2]);
-                break;
-        case BFA_LPORT_AEN_NPIV_UNKNOWN:
-                bfa_log(logmod, BFA_AEN_LPORT_NPIV_UNKNOWN, lpwwn_ptr,
-                        role_str[role / 2]);
-                break;
-        default:
-                break;
-        }
+        bfa_log(logmod, BFA_LOG_CREATE_ID(BFA_AEN_CAT_LPORT, event), lpwwn_ptr,
+                        role_str[role/2]);
 
         aen_data.lport.vf_id = port->fabric->vf_id;
         aen_data.lport.roles = role;
@@ -478,7 +464,7 @@ static void
 bfa_fcs_vport_do_fdisc(struct bfa_fcs_vport_s *vport)
 {
         bfa_lps_fdisc(vport->lps, vport,
-                      bfa_pport_get_maxfrsize(__vport_bfa(vport)),
+                      bfa_fcport_get_maxfrsize(__vport_bfa(vport)),
                       __vport_pwwn(vport), __vport_nwwn(vport));
         vport->vport_stats.fdisc_sent++;
 }
@@ -617,38 +603,6 @@ bfa_fcs_vport_delete_comp(struct bfa_fcs_vport_s *vport)
 }
 
 /**
- *   Module initialization
- */
-void
-bfa_fcs_vport_modinit(struct bfa_fcs_s *fcs)
-{
-}
-
-/**
- *   Module cleanup
- */
-void
-bfa_fcs_vport_modexit(struct bfa_fcs_s *fcs)
-{
-        bfa_fcs_modexit_comp(fcs);
-}
-
-u32
-bfa_fcs_vport_get_max(struct bfa_fcs_s *fcs)
-{
-        struct bfa_ioc_attr_s ioc_attr;
-
-        bfa_get_attr(fcs->bfa, &ioc_attr);
-
-        if (ioc_attr.pci_attr.device_id == BFA_PCI_DEVICE_ID_CT)
-                return (BFA_FCS_MAX_VPORTS_SUPP_CT);
-        else
-                return (BFA_FCS_MAX_VPORTS_SUPP_CB);
-}
-
-
-
-/**
  *  fcs_vport_api Virtual port API
  */
 
@@ -675,7 +629,7 @@ bfa_fcs_vport_create(struct bfa_fcs_vport_s *vport, struct bfa_fcs_s *fcs,
                      struct bfad_vport_s *vport_drv)
 {
         if (vport_cfg->pwwn == 0)
-                return (BFA_STATUS_INVALID_WWN);
+                return BFA_STATUS_INVALID_WWN;
 
         if (bfa_fcs_port_get_pwwn(&fcs->fabric.bport) == vport_cfg->pwwn)
                 return BFA_STATUS_VPORT_WWN_BP;
@@ -684,7 +638,7 @@ bfa_fcs_vport_create(struct bfa_fcs_vport_s *vport, struct bfa_fcs_s *fcs,
                 return BFA_STATUS_VPORT_EXISTS;
 
         if (bfa_fcs_fabric_vport_count(&fcs->fabric) ==
-            bfa_fcs_vport_get_max(fcs))
+                bfa_lps_get_max_vport(fcs->bfa))
                 return BFA_STATUS_VPORT_MAX;
 
         vport->lps = bfa_lps_alloc(fcs->bfa);
@@ -694,7 +648,8 @@ bfa_fcs_vport_create(struct bfa_fcs_vport_s *vport, struct bfa_fcs_s *fcs,
         vport->vport_drv = vport_drv;
         bfa_sm_set_state(vport, bfa_fcs_vport_sm_uninit);
 
-        bfa_fcs_lport_init(&vport->lport, fcs, vf_id, vport_cfg, vport);
+        bfa_fcs_lport_attach(&vport->lport, fcs, vf_id, vport);
+        bfa_fcs_lport_init(&vport->lport, vport_cfg);
 
         bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_CREATE);
 
@@ -888,4 +843,15 @@ bfa_cb_lps_fdisclogo_comp(void *bfad, void *uarg)
         bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_RSP_OK);
 }
 
+/**
+ * Received clear virtual link
+ */
+void
+bfa_cb_lps_cvl_event(void *bfad, void *uarg)
+{
+        struct bfa_fcs_vport_s *vport = uarg;
 
+        /* Send an Offline followed by an ONLINE */
+        bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_OFFLINE);
+        bfa_sm_send_event(vport, BFA_FCS_VPORT_SM_ONLINE);
+}
diff --git a/drivers/scsi/bnx2i/bnx2i.h b/drivers/scsi/bnx2i/bnx2i.h
index 5edde1a8c04d..6b624e767d3b 100644
--- a/drivers/scsi/bnx2i/bnx2i.h
+++ b/drivers/scsi/bnx2i/bnx2i.h
@@ -232,7 +232,6 @@ struct bnx2i_conn {
         struct iscsi_cls_conn *cls_conn;
         struct bnx2i_hba *hba;
         struct completion cmd_cleanup_cmpl;
-        int is_bound;
 
         u32 iscsi_conn_cid;
 #define BNX2I_CID_RESERVED      0x5AFF
@@ -363,6 +362,7 @@ struct bnx2i_hba {
         u32 num_ccell;
 
         int ofld_conns_active;
+        wait_queue_head_t eh_wait;
 
         int max_active_conns;
         struct iscsi_cid_queue cid_que;
@@ -382,6 +382,7 @@ struct bnx2i_hba {
         spinlock_t lock;        /* protects hba structure access */
         struct mutex net_dev_lock;/* sync net device access */
 
+        int hba_shutdown_tmo;
         /*
          * PCI related info.
          */
@@ -685,6 +686,7 @@ extern unsigned int error_mask1, error_mask2;
 extern u64 iscsi_error_mask;
 extern unsigned int en_tcp_dack;
 extern unsigned int event_coal_div;
+extern unsigned int event_coal_min;
 
 extern struct scsi_transport_template *bnx2i_scsi_xport_template;
 extern struct iscsi_transport bnx2i_iscsi_transport;
diff --git a/drivers/scsi/bnx2i/bnx2i_hwi.c b/drivers/scsi/bnx2i/bnx2i_hwi.c
index 5c8d7630c13e..18352ff82101 100644
--- a/drivers/scsi/bnx2i/bnx2i_hwi.c
+++ b/drivers/scsi/bnx2i/bnx2i_hwi.c
@@ -11,6 +11,7 @@
  * Written by: Anil Veerabhadrappa (anilgv@broadcom.com)
  */
 
+#include <linux/gfp.h>
 #include <scsi/scsi_tcq.h>
 #include <scsi/libiscsi.h>
 #include "bnx2i.h"
@@ -133,20 +134,38 @@ void bnx2i_arm_cq_event_coalescing(struct bnx2i_endpoint *ep, u8 action)
 {
         struct bnx2i_5771x_cq_db *cq_db;
         u16 cq_index;
+        u16 next_index;
+        u32 num_active_cmds;
 
+
+        /* Coalesce CQ entries only on 10G devices */
         if (!test_bit(BNX2I_NX2_DEV_57710, &ep->hba->cnic_dev_type))
                 return;
 
+        /* Do not update CQ DB multiple times before firmware writes
+         * '0xFFFF' to CQDB->SQN field. Deviation may cause spurious
+         * interrupts and other unwanted results
+         */
+        cq_db = (struct bnx2i_5771x_cq_db *) ep->qp.cq_pgtbl_virt;
+        if (cq_db->sqn[0] && cq_db->sqn[0] != 0xFFFF)
+                return;
+
         if (action == CNIC_ARM_CQE) {
-                cq_index = ep->qp.cqe_exp_seq_sn +
-                           ep->num_active_cmds / event_coal_div;
-                cq_index %= (ep->qp.cqe_size * 2 + 1);
-                if (!cq_index) {
+                num_active_cmds = ep->num_active_cmds;
+                if (num_active_cmds <= event_coal_min)
+                        next_index = 1;
+                else
+                        next_index = event_coal_min +
+                                (num_active_cmds - event_coal_min) / event_coal_div;
+                if (!next_index)
+                        next_index = 1;
+                cq_index = ep->qp.cqe_exp_seq_sn + next_index - 1;
+                if (cq_index > ep->qp.cqe_size * 2)
+                        cq_index -= ep->qp.cqe_size * 2;
+                if (!cq_index)
                         cq_index = 1;
-                        cq_db = (struct bnx2i_5771x_cq_db *)
-                                        ep->qp.cq_pgtbl_virt;
-                        cq_db->sqn[0] = cq_index;
-                }
+
+                cq_db->sqn[0] = cq_index;
         }
 }
 
@@ -366,6 +385,7 @@ int bnx2i_send_iscsi_tmf(struct bnx2i_conn *bnx2i_conn,
         struct bnx2i_cmd *bnx2i_cmd;
         struct bnx2i_tmf_request *tmfabort_wqe;
         u32 dword;
+        u32 scsi_lun[2];
 
         bnx2i_cmd = (struct bnx2i_cmd *)mtask->dd_data;
         tmfabort_hdr = (struct iscsi_tm *)mtask->hdr;
@@ -376,27 +396,35 @@ int bnx2i_send_iscsi_tmf(struct bnx2i_conn *bnx2i_conn,
         tmfabort_wqe->op_attr = 0;
         tmfabort_wqe->op_attr =
                 ISCSI_TMF_REQUEST_ALWAYS_ONE | ISCSI_TM_FUNC_ABORT_TASK;
-        tmfabort_wqe->lun[0] = be32_to_cpu(tmfabort_hdr->lun[0]);
-        tmfabort_wqe->lun[1] = be32_to_cpu(tmfabort_hdr->lun[1]);
 
         tmfabort_wqe->itt = (mtask->itt | (ISCSI_TASK_TYPE_MPATH << 14));
         tmfabort_wqe->reserved2 = 0;
         tmfabort_wqe->cmd_sn = be32_to_cpu(tmfabort_hdr->cmdsn);
 
         ctask = iscsi_itt_to_task(conn, tmfabort_hdr->rtt);
-        if (!ctask || ctask->sc)
+        if (!ctask || !ctask->sc)
                 /*
                  * the iscsi layer must have completed the cmd while this
                  * was starting up.
+                 *
+                 * Note: In the case of a SCSI cmd timeout, the task's sc
+                 *       is still active; hence ctask->sc != 0
+                 *       In this case, the task must be aborted
                  */
                 return 0;
+
         ref_sc = ctask->sc;
 
+        /* Retrieve LUN directly from the ref_sc */
+        int_to_scsilun(ref_sc->device->lun, (struct scsi_lun *) scsi_lun);
+        tmfabort_wqe->lun[0] = be32_to_cpu(scsi_lun[0]);
+        tmfabort_wqe->lun[1] = be32_to_cpu(scsi_lun[1]);
+
         if (ref_sc->sc_data_direction == DMA_TO_DEVICE)
                 dword = (ISCSI_TASK_TYPE_WRITE << ISCSI_CMD_REQUEST_TYPE_SHIFT);
         else
                 dword = (ISCSI_TASK_TYPE_READ << ISCSI_CMD_REQUEST_TYPE_SHIFT);
-        tmfabort_wqe->ref_itt = (dword | tmfabort_hdr->rtt);
+        tmfabort_wqe->ref_itt = (dword | (tmfabort_hdr->rtt & ISCSI_ITT_MASK));
         tmfabort_wqe->ref_cmd_sn = be32_to_cpu(tmfabort_hdr->refcmdsn);
 
         tmfabort_wqe->bd_list_addr_lo = (u32) bnx2i_conn->hba->mp_bd_dma;
diff --git a/drivers/scsi/bnx2i/bnx2i_init.c b/drivers/scsi/bnx2i/bnx2i_init.c
index 0c4210d48ee8..5d9296c599f6 100644
--- a/drivers/scsi/bnx2i/bnx2i_init.c
+++ b/drivers/scsi/bnx2i/bnx2i_init.c
@@ -17,8 +17,8 @@ static struct list_head adapter_list = LIST_HEAD_INIT(adapter_list);
 static u32 adapter_count;
 
 #define DRV_MODULE_NAME         "bnx2i"
-#define DRV_MODULE_VERSION      "2.0.1e"
-#define DRV_MODULE_RELDATE      "June 22, 2009"
+#define DRV_MODULE_VERSION      "2.1.0"
+#define DRV_MODULE_RELDATE      "Dec 06, 2009"
 
 static char version[] __devinitdata =
                 "Broadcom NetXtreme II iSCSI Driver " DRV_MODULE_NAME \
@@ -32,6 +32,10 @@ MODULE_VERSION(DRV_MODULE_VERSION);
 
 static DEFINE_MUTEX(bnx2i_dev_lock);
 
+unsigned int event_coal_min = 24;
+module_param(event_coal_min, int, 0664);
+MODULE_PARM_DESC(event_coal_min, "Event Coalescing Minimum Commands");
+
 unsigned int event_coal_div = 1;
 module_param(event_coal_div, int, 0664);
 MODULE_PARM_DESC(event_coal_div, "Event Coalescing Divide Factor");
@@ -83,8 +87,12 @@ void bnx2i_identify_device(struct bnx2i_hba *hba)
                 set_bit(BNX2I_NX2_DEV_5709, &hba->cnic_dev_type);
                 hba->mail_queue_access = BNX2I_MQ_BIN_MODE;
         } else if (hba->pci_did == PCI_DEVICE_ID_NX2_57710 ||
-                   hba->pci_did == PCI_DEVICE_ID_NX2_57711)
+                   hba->pci_did == PCI_DEVICE_ID_NX2_57711 ||
+                   hba->pci_did == PCI_DEVICE_ID_NX2_57711E)
                 set_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type);
+        else
+                printk(KERN_ALERT "bnx2i: unknown device, 0x%x\n",
+                                  hba->pci_did);
 }
 
 
@@ -169,11 +177,22 @@ void bnx2i_stop(void *handle)
         struct bnx2i_hba *hba = handle;
 
         /* check if cleanup happened in GOING_DOWN context */
-        clear_bit(ADAPTER_STATE_UP, &hba->adapter_state);
         if (!test_and_clear_bit(ADAPTER_STATE_GOING_DOWN,
                                 &hba->adapter_state))
                 iscsi_host_for_each_session(hba->shost,
                                             bnx2i_drop_session);
+
+        /* Wait for all endpoints to be torn down, Chip will be reset once
+         *  control returns to network driver. So it is required to cleanup and
+         * release all connection resources before returning from this routine.
+         */
+        wait_event_interruptible_timeout(hba->eh_wait,
+                                         (hba->ofld_conns_active == 0),
+                                         hba->hba_shutdown_tmo);
+        /* This flag should be cleared last so that ep_disconnect() gracefully
+         * cleans up connection context
+         */
+        clear_bit(ADAPTER_STATE_UP, &hba->adapter_state);
 }
 
 /**
@@ -363,7 +382,7 @@ static int __init bnx2i_mod_init(void)
 
         printk(KERN_INFO "%s", version);
 
-        if (!is_power_of_2(sq_size))
+        if (sq_size && !is_power_of_2(sq_size))
                 sq_size = roundup_pow_of_two(sq_size);
 
         mutex_init(&bnx2i_dev_lock);
diff --git a/drivers/scsi/bnx2i/bnx2i_iscsi.c b/drivers/scsi/bnx2i/bnx2i_iscsi.c
index cafb888c2376..fa68ab34b998 100644
--- a/drivers/scsi/bnx2i/bnx2i_iscsi.c
+++ b/drivers/scsi/bnx2i/bnx2i_iscsi.c
@@ -12,6 +12,7 @@
  * Written by: Anil Veerabhadrappa (anilgv@broadcom.com)
  */
 
+#include <linux/slab.h>
 #include <scsi/scsi_tcq.h>
 #include <scsi/libiscsi.h>
 #include "bnx2i.h"
@@ -485,7 +486,6 @@ static int bnx2i_setup_cmd_pool(struct bnx2i_hba *hba,
                 struct iscsi_task *task = session->cmds[i];
                 struct bnx2i_cmd *cmd = task->dd_data;
 
-                /* Anil */
                 task->hdr = &cmd->hdr;
                 task->hdr_max = sizeof(struct iscsi_hdr);
 
@@ -765,7 +765,6 @@ struct bnx2i_hba *bnx2i_alloc_hba(struct cnic_dev *cnic)
         hba->pci_svid = hba->pcidev->subsystem_vendor;
         hba->pci_func = PCI_FUNC(hba->pcidev->devfn);
         hba->pci_devno = PCI_SLOT(hba->pcidev->devfn);
-        bnx2i_identify_device(hba);
 
         bnx2i_identify_device(hba);
         bnx2i_setup_host_queue_size(hba, shost);
@@ -821,6 +820,11 @@ struct bnx2i_hba *bnx2i_alloc_hba(struct cnic_dev *cnic)
 
         spin_lock_init(&hba->lock);
         mutex_init(&hba->net_dev_lock);
+        init_waitqueue_head(&hba->eh_wait);
+        if (test_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type))
+                hba->hba_shutdown_tmo = 240 * HZ;
+        else    /* 5706/5708/5709 */
+                hba->hba_shutdown_tmo = 30 * HZ;
 
         if (iscsi_host_add(shost, &hba->pcidev->dev))
                 goto free_dump_mem;
@@ -1161,9 +1165,6 @@ static int bnx2i_task_xmit(struct iscsi_task *task)
         struct bnx2i_cmd *cmd = task->dd_data;
         struct iscsi_cmd *hdr = (struct iscsi_cmd *) task->hdr;
 
-        if (!bnx2i_conn->is_bound)
-                return -ENOTCONN;
-
         /*
          * If there is no scsi_cmnd this must be a mgmt task
          */
@@ -1371,7 +1372,6 @@ static int bnx2i_conn_bind(struct iscsi_cls_session *cls_session,
         bnx2i_conn->ep = bnx2i_ep;
         bnx2i_conn->iscsi_conn_cid = bnx2i_ep->ep_iscsi_cid;
         bnx2i_conn->fw_cid = bnx2i_ep->ep_cid;
-        bnx2i_conn->is_bound = 1;
 
         ret_code = bnx2i_bind_conn_to_iscsi_cid(hba, bnx2i_conn,
                                                 bnx2i_ep->ep_iscsi_cid);
@@ -1432,8 +1432,8 @@ static int bnx2i_conn_get_param(struct iscsi_cls_conn *cls_conn,
                 break;
         case ISCSI_PARAM_CONN_ADDRESS:
                 if (bnx2i_conn->ep)
-                        len = sprintf(buf, NIPQUAD_FMT "\n",
-                                      NIPQUAD(bnx2i_conn->ep->cm_sk->dst_ip));
+                        len = sprintf(buf, "%pI4\n",
+                                      &bnx2i_conn->ep->cm_sk->dst_ip);
                 break;
         default:
                 return iscsi_conn_get_param(cls_conn, param, buf);
@@ -1663,8 +1663,8 @@ static struct iscsi_endpoint *bnx2i_ep_connect(struct Scsi_Host *shost,
                  */
                 hba = bnx2i_check_route(dst_addr);
 
-        if (!hba) {
-                rc = -ENOMEM;
+        if (!hba || test_bit(ADAPTER_STATE_GOING_DOWN, &hba->adapter_state)) {
+                rc = -EINVAL;
                 goto check_busy;
         }
 
@@ -1809,7 +1809,7 @@ static int bnx2i_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
                                                (bnx2i_ep->state ==
                                                 EP_STATE_CONNECT_COMPL)),
                                               msecs_to_jiffies(timeout_ms));
-        if (!rc || (bnx2i_ep->state == EP_STATE_OFLD_FAILED))
+        if (bnx2i_ep->state == EP_STATE_OFLD_FAILED)
                 rc = -1;
 
         if (rc > 0)
@@ -1883,7 +1883,7 @@ static void bnx2i_ep_disconnect(struct iscsi_endpoint *ep)
 
         bnx2i_ep = ep->dd_data;
 
-        /* driver should not attempt connection cleanup untill TCP_CONNECT
+        /* driver should not attempt connection cleanup until TCP_CONNECT
          * completes either successfully or fails. Timeout is 9-secs, so
          * wait for it to complete
          */
@@ -1896,9 +1896,7 @@ static void bnx2i_ep_disconnect(struct iscsi_endpoint *ep)
                 conn = bnx2i_conn->cls_conn->dd_data;
                 session = conn->session;
 
-                spin_lock_bh(&session->lock);
-                bnx2i_conn->is_bound = 0;
-                spin_unlock_bh(&session->lock);
+                iscsi_suspend_queue(conn);
         }
 
         hba = bnx2i_ep->hba;
@@ -1964,6 +1962,8 @@ return_bnx2i_ep:
 
         if (!hba->ofld_conns_active)
                 bnx2i_unreg_dev_all();
+
+        wake_up_interruptible(&hba->eh_wait);
 }
 
 
@@ -1997,7 +1997,8 @@ static struct scsi_host_template bnx2i_host_template = {
         .queuecommand           = iscsi_queuecommand,
         .eh_abort_handler       = iscsi_eh_abort,
         .eh_device_reset_handler = iscsi_eh_device_reset,
-        .eh_target_reset_handler = iscsi_eh_target_reset,
+        .eh_target_reset_handler = iscsi_eh_recover_target,
+        .change_queue_depth     = iscsi_change_queue_depth,
         .can_queue              = 1024,
         .max_sectors            = 127,
         .cmd_per_lun            = 32,
@@ -2034,7 +2035,7 @@ struct iscsi_transport bnx2i_iscsi_transport = {
                                   ISCSI_USERNAME | ISCSI_PASSWORD |
                                   ISCSI_USERNAME_IN | ISCSI_PASSWORD_IN |
                                   ISCSI_FAST_ABORT | ISCSI_ABORT_TMO |
-                                  ISCSI_LU_RESET_TMO |
+                                  ISCSI_LU_RESET_TMO | ISCSI_TGT_RESET_TMO |
                                   ISCSI_PING_TMO | ISCSI_RECV_TMO |
                                   ISCSI_IFACE_NAME | ISCSI_INITIATOR_NAME,
         .host_param_mask        = ISCSI_HOST_HWADDRESS | ISCSI_HOST_NETDEV_NAME,
diff --git a/drivers/scsi/bvme6000_scsi.c b/drivers/scsi/bvme6000_scsi.c
index 5799cb5cba6b..d40ea2f5be10 100644
--- a/drivers/scsi/bvme6000_scsi.c
+++ b/drivers/scsi/bvme6000_scsi.c
@@ -12,6 +12,7 @@
 #include <linux/platform_device.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 #include <asm/bvme6000hw.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
diff --git a/drivers/scsi/ch.c b/drivers/scsi/ch.c
index fe11c1d4b31d..4799d4391203 100644
--- a/drivers/scsi/ch.c
+++ b/drivers/scsi/ch.c
@@ -23,6 +23,7 @@
 #include <linux/mutex.h>
 #include <linux/idr.h>
 #include <linux/smp_lock.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
diff --git a/drivers/scsi/constants.c b/drivers/scsi/constants.c
index 63abb06c4edb..cd05e049d5f6 100644
--- a/drivers/scsi/constants.c
+++ b/drivers/scsi/constants.c
@@ -141,6 +141,7 @@ static const struct value_name_pair serv_out12_arr[] = {
 static const struct value_name_pair serv_in16_arr[] = {
         {0x10, "Read capacity(16)"},
         {0x11, "Read long(16)"},
+        {0x12, "Get LBA status"},
 };
 #define SERV_IN16_SZ ARRAY_SIZE(serv_in16_arr)
 
@@ -218,18 +219,15 @@ static void print_opcode_name(unsigned char * cdbp, int cdb_len)
                         break;
                 }
                 sa = (cdbp[8] << 8) + cdbp[9];
-                name = get_sa_name(maint_in_arr, MAINT_IN_SZ, sa);
-                if (name) {
+                name = get_sa_name(variable_length_arr, VARIABLE_LENGTH_SZ, sa);
+                if (name)
                         printk("%s", name);
-                        if ((cdb_len > 0) && (len != cdb_len))
-                                printk(", in_cdb_len=%d, ext_len=%d",
-                                       len, cdb_len);
-                } else {
+                else
                         printk("cdb[0]=0x%x, sa=0x%x", cdb0, sa);
-                        if ((cdb_len > 0) && (len != cdb_len))
-                                printk(", in_cdb_len=%d, ext_len=%d",
-                                       len, cdb_len);
-                }
+
+                if ((cdb_len > 0) && (len != cdb_len))
+                        printk(", in_cdb_len=%d, ext_len=%d", len, cdb_len);
+
                 break;
         case MAINTENANCE_IN:
                 sa = cdbp[1] & 0x1f;
@@ -348,6 +346,9 @@ void scsi_print_command(struct scsi_cmnd *cmd)
 {
         int k;
 
+        if (cmd->cmnd == NULL)
+                return;
+
         scmd_printk(KERN_INFO, cmd, "CDB: ");
         print_opcode_name(cmd->cmnd, cmd->cmd_len);
 
diff --git a/drivers/scsi/cxgb3i/cxgb3i_ddp.c b/drivers/scsi/cxgb3i/cxgb3i_ddp.c
index 344fd53b9954..b58d9134ac1b 100644
--- a/drivers/scsi/cxgb3i/cxgb3i_ddp.c
+++ b/drivers/scsi/cxgb3i/cxgb3i_ddp.c
@@ -10,6 +10,7 @@
  * Written by: Karen Xie (kxie@chelsio.com)
  */
 
+#include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/scatterlist.h>
 
diff --git a/drivers/scsi/cxgb3i/cxgb3i_ddp.h b/drivers/scsi/cxgb3i/cxgb3i_ddp.h
index 87dd56b422bf..6761b329124d 100644
--- a/drivers/scsi/cxgb3i/cxgb3i_ddp.h
+++ b/drivers/scsi/cxgb3i/cxgb3i_ddp.h
@@ -13,6 +13,7 @@
 #ifndef __CXGB3I_ULP2_DDP_H__
 #define __CXGB3I_ULP2_DDP_H__
 
+#include <linux/slab.h>
 #include <linux/vmalloc.h>
 
 /**
diff --git a/drivers/scsi/cxgb3i/cxgb3i_iscsi.c b/drivers/scsi/cxgb3i/cxgb3i_iscsi.c
index 2631bddd255e..7b686abaae64 100644
--- a/drivers/scsi/cxgb3i/cxgb3i_iscsi.c
+++ b/drivers/scsi/cxgb3i/cxgb3i_iscsi.c
@@ -12,6 +12,7 @@
  */
 
 #include <linux/inet.h>
+#include <linux/slab.h>
 #include <linux/crypto.h>
 #include <linux/if_vlan.h>
 #include <net/dst.h>
@@ -591,8 +592,7 @@ static int cxgb3i_conn_bind(struct iscsi_cls_session *cls_session,
         cxgb3i_conn_max_recv_dlength(conn);
 
         spin_lock_bh(&conn->session->lock);
-        sprintf(conn->portal_address, NIPQUAD_FMT,
-                NIPQUAD(c3cn->daddr.sin_addr.s_addr));
+        sprintf(conn->portal_address, "%pI4", &c3cn->daddr.sin_addr.s_addr);
         conn->portal_port = ntohs(c3cn->daddr.sin_port);
         spin_unlock_bh(&conn->session->lock);
 
@@ -709,6 +709,12 @@ static int cxgb3i_host_set_param(struct Scsi_Host *shost,
 {
         struct cxgb3i_hba *hba = iscsi_host_priv(shost);
 
+        if (!hba->ndev) {
+                shost_printk(KERN_ERR, shost, "Could not set host param. "
+                             "Netdev for host not set.\n");
+                return -ENODEV;
+        }
+
         cxgb3i_api_debug("param %d, buf %s.\n", param, buf);
 
         switch (param) {
@@ -739,6 +745,12 @@ static int cxgb3i_host_get_param(struct Scsi_Host *shost,
         struct cxgb3i_hba *hba = iscsi_host_priv(shost);
         int len = 0;
 
+        if (!hba->ndev) {
+                shost_printk(KERN_ERR, shost, "Could not set host param. "
+                             "Netdev for host not set.\n");
+                return -ENODEV;
+        }
+
         cxgb3i_api_debug("hba %s, param %d.\n", hba->ndev->name, param);
 
         switch (param) {
@@ -753,7 +765,7 @@ static int cxgb3i_host_get_param(struct Scsi_Host *shost,
                 __be32 addr;
 
                 addr = cxgb3i_get_private_ipv4addr(hba->ndev);
-                len = sprintf(buf, NIPQUAD_FMT, NIPQUAD(addr));
+                len = sprintf(buf, "%pI4", &addr);
                 break;
         }
         default:
@@ -904,7 +916,7 @@ static struct scsi_host_template cxgb3i_host_template = {
         .cmd_per_lun            = ISCSI_DEF_CMD_PER_LUN,
         .eh_abort_handler       = iscsi_eh_abort,
         .eh_device_reset_handler = iscsi_eh_device_reset,
-        .eh_target_reset_handler = iscsi_eh_target_reset,
+        .eh_target_reset_handler = iscsi_eh_recover_target,
         .target_alloc           = iscsi_target_alloc,
         .use_clustering         = DISABLE_CLUSTERING,
         .this_id                = -1,
@@ -937,7 +949,7 @@ static struct iscsi_transport cxgb3i_iscsi_transport = {
                                 ISCSI_USERNAME | ISCSI_PASSWORD |
                                 ISCSI_USERNAME_IN | ISCSI_PASSWORD_IN |
                                 ISCSI_FAST_ABORT | ISCSI_ABORT_TMO |
-                                ISCSI_LU_RESET_TMO |
+                                ISCSI_LU_RESET_TMO | ISCSI_TGT_RESET_TMO |
                                 ISCSI_PING_TMO | ISCSI_RECV_TMO |
                                 ISCSI_IFACE_NAME | ISCSI_INITIATOR_NAME,
         .host_param_mask        = ISCSI_HOST_HWADDRESS | ISCSI_HOST_IPADDRESS |
diff --git a/drivers/scsi/cxgb3i/cxgb3i_offload.c b/drivers/scsi/cxgb3i/cxgb3i_offload.c
index c1d5be4adf9c..a175be9c496f 100644
--- a/drivers/scsi/cxgb3i/cxgb3i_offload.c
+++ b/drivers/scsi/cxgb3i/cxgb3i_offload.c
@@ -13,6 +13,7 @@
  */
 
 #include <linux/if_vlan.h>
+#include <linux/slab.h>
 #include <linux/version.h>
 
 #include "cxgb3_defs.h"
@@ -291,7 +292,7 @@ static void act_open_req_arp_failure(struct t3cdev *dev, struct sk_buff *skb)
         c3cn_hold(c3cn);
         spin_lock_bh(&c3cn->lock);
         if (c3cn->state == C3CN_STATE_CONNECTING)
-                fail_act_open(c3cn, EHOSTUNREACH);
+                fail_act_open(c3cn, -EHOSTUNREACH);
         spin_unlock_bh(&c3cn->lock);
         c3cn_put(c3cn);
         __kfree_skb(skb);
@@ -792,18 +793,18 @@ static int act_open_rpl_status_to_errno(int status)
 {
         switch (status) {
         case CPL_ERR_CONN_RESET:
-                return ECONNREFUSED;
+                return -ECONNREFUSED;
         case CPL_ERR_ARP_MISS:
-                return EHOSTUNREACH;
+                return -EHOSTUNREACH;
         case CPL_ERR_CONN_TIMEDOUT:
-                return ETIMEDOUT;
+                return -ETIMEDOUT;
         case CPL_ERR_TCAM_FULL:
-                return ENOMEM;
+                return -ENOMEM;
         case CPL_ERR_CONN_EXIST:
                 cxgb3i_log_error("ACTIVE_OPEN_RPL: 4-tuple in use\n");
-                return EADDRINUSE;
+                return -EADDRINUSE;
         default:
-                return EIO;
+                return -EIO;
         }
 }
 
@@ -817,7 +818,7 @@ static void act_open_retry_timer(unsigned long data)
         spin_lock_bh(&c3cn->lock);
         skb = alloc_skb(sizeof(struct cpl_act_open_req), GFP_ATOMIC);
         if (!skb)
-                fail_act_open(c3cn, ENOMEM);
+                fail_act_open(c3cn, -ENOMEM);
         else {
                 skb->sk = (struct sock *)c3cn;
                 set_arp_failure_handler(skb, act_open_req_arp_failure);
@@ -966,14 +967,14 @@ static int abort_status_to_errno(struct s3_conn *c3cn, int abort_reason,
         case CPL_ERR_BAD_SYN: /* fall through */
         case CPL_ERR_CONN_RESET:
                 return c3cn->state > C3CN_STATE_ESTABLISHED ?
-                        EPIPE : ECONNRESET;
+                        -EPIPE : -ECONNRESET;
         case CPL_ERR_XMIT_TIMEDOUT:
         case CPL_ERR_PERSIST_TIMEDOUT:
         case CPL_ERR_FINWAIT2_TIMEDOUT:
         case CPL_ERR_KEEPALIVE_TIMEDOUT:
-                return ETIMEDOUT;
+                return -ETIMEDOUT;
         default:
-                return EIO;
+                return -EIO;
         }
 }
 
@@ -1440,6 +1441,10 @@ void cxgb3i_c3cn_release(struct s3_conn *c3cn)
 static int is_cxgb3_dev(struct net_device *dev)
 {
         struct cxgb3i_sdev_data *cdata;
+        struct net_device *ndev = dev;
+
+        if (dev->priv_flags & IFF_802_1Q_VLAN)
+                ndev = vlan_dev_real_dev(dev);
 
         write_lock(&cdata_rwlock);
         list_for_each_entry(cdata, &cdata_list, list) {
@@ -1447,7 +1452,7 @@ static int is_cxgb3_dev(struct net_device *dev)
                 int i;
 
                 for (i = 0; i < ports->nports; i++)
-                        if (dev == ports->lldevs[i]) {
+                        if (ndev == ports->lldevs[i]) {
                                 write_unlock(&cdata_rwlock);
                                 return 1;
                         }
@@ -1563,9 +1568,29 @@ free_tid:
         s3_free_atid(cdev, c3cn->tid);
         c3cn->tid = 0;
 out_err:
-        return -1;
+        return -EINVAL;
 }
 
+/**
+ * cxgb3i_find_dev - find the interface associated with the given address
+ * @ipaddr: ip address
+ */
+static struct net_device *
+cxgb3i_find_dev(struct net_device *dev, __be32 ipaddr)
+{
+        struct flowi fl;
+        int err;
+        struct rtable *rt;
+
+        memset(&fl, 0, sizeof(fl));
+        fl.nl_u.ip4_u.daddr = ipaddr;
+
+        err = ip_route_output_key(dev ? dev_net(dev) : &init_net, &rt, &fl);
+        if (!err)
+                return (&rt->u.dst)->dev;
+
+        return NULL;
+}
 
 /**
  * cxgb3i_c3cn_connect - initiates an iscsi tcp connection to a given address
@@ -1581,6 +1606,7 @@ int cxgb3i_c3cn_connect(struct net_device *dev, struct s3_conn *c3cn,
         struct cxgb3i_sdev_data *cdata;
         struct t3cdev *cdev;
         __be32 sipv4;
+        struct net_device *dstdev;
         int err;
 
         c3cn_conn_debug("c3cn 0x%p, dev 0x%p.\n", c3cn, dev);
@@ -1591,6 +1617,13 @@ int cxgb3i_c3cn_connect(struct net_device *dev, struct s3_conn *c3cn,
         c3cn->daddr.sin_port = usin->sin_port;
         c3cn->daddr.sin_addr.s_addr = usin->sin_addr.s_addr;
 
+        dstdev = cxgb3i_find_dev(dev, usin->sin_addr.s_addr);
+        if (!dstdev || !is_cxgb3_dev(dstdev))
+                return -ENETUNREACH;
+
+        if (dstdev->priv_flags & IFF_802_1Q_VLAN)
+                dev = dstdev;
+
         rt = find_route(dev, c3cn->saddr.sin_addr.s_addr,
                         c3cn->daddr.sin_addr.s_addr,
                         c3cn->saddr.sin_port,
@@ -1643,10 +1676,11 @@ int cxgb3i_c3cn_connect(struct net_device *dev, struct s3_conn *c3cn,
         } else
                 c3cn->saddr.sin_addr.s_addr = sipv4;
 
-        c3cn_conn_debug("c3cn 0x%p, %u.%u.%u.%u,%u-%u.%u.%u.%u,%u SYN_SENT.\n",
-                        c3cn, NIPQUAD(c3cn->saddr.sin_addr.s_addr),
+        c3cn_conn_debug("c3cn 0x%p, %pI4,%u-%pI4,%u SYN_SENT.\n",
+                        c3cn,
+                        &c3cn->saddr.sin_addr.s_addr,
                         ntohs(c3cn->saddr.sin_port),
-                        NIPQUAD(c3cn->daddr.sin_addr.s_addr),
+                        &c3cn->daddr.sin_addr.s_addr,
                         ntohs(c3cn->daddr.sin_port));
 
         c3cn_set_state(c3cn, C3CN_STATE_CONNECTING);
diff --git a/drivers/scsi/cxgb3i/cxgb3i_pdu.c b/drivers/scsi/cxgb3i/cxgb3i_pdu.c
index 709105071177..dc5e3e77a351 100644
--- a/drivers/scsi/cxgb3i/cxgb3i_pdu.c
+++ b/drivers/scsi/cxgb3i/cxgb3i_pdu.c
@@ -12,6 +12,7 @@
  * Written by: Karen Xie (kxie@chelsio.com)
  */
 
+#include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/crypto.h>
 #include <scsi/scsi_cmnd.h>
@@ -388,8 +389,8 @@ int cxgb3i_conn_xmit_pdu(struct iscsi_task *task)
         if (err > 0) {
                 int pdulen = err;
 
-        cxgb3i_tx_debug("task 0x%p, skb 0x%p, len %u/%u, rv %d.\n",
-                        task, skb, skb->len, skb->data_len, err);
+                cxgb3i_tx_debug("task 0x%p, skb 0x%p, len %u/%u, rv %d.\n",
+                                task, skb, skb->len, skb->data_len, err);
 
                 if (task->conn->hdrdgst_en)
                         pdulen += ISCSI_DIGEST_SIZE;
@@ -461,10 +462,8 @@ void cxgb3i_conn_pdu_ready(struct s3_conn *c3cn)
                 skb = skb_peek(&c3cn->receive_queue);
         }
         read_unlock(&c3cn->callback_lock);
-        if (c3cn) {
-                c3cn->copied_seq += read;
-                cxgb3i_c3cn_rx_credits(c3cn, read);
-        }
+        c3cn->copied_seq += read;
+        cxgb3i_c3cn_rx_credits(c3cn, read);
         conn->rxdata_octets += read;
 
         if (err) {
diff --git a/drivers/scsi/dc395x.c b/drivers/scsi/dc395x.c
index 075e2397273c..bd977be7544e 100644
--- a/drivers/scsi/dc395x.c
+++ b/drivers/scsi/dc395x.c
@@ -57,6 +57,7 @@
 #include <linux/pci.h>
 #include <linux/list.h>
 #include <linux/vmalloc.h>
+#include <linux/slab.h>
 #include <asm/io.h>
 
 #include <scsi/scsi.h>
@@ -1509,7 +1510,7 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
                  * Try anyway?
                  *
                  * We could, BUT: Sometimes the TRM_S1040 misses to produce a Selection
-                 * Timeout, a Disconnect or a Reselction IRQ, so we would be screwed!
+                 * Timeout, a Disconnect or a Reselection IRQ, so we would be screwed!
                  * (This is likely to be a bug in the hardware. Obviously, most people
                  *  only have one initiator per SCSI bus.)
                  * Instead let this fail and have the timer make sure the command is 
diff --git a/drivers/scsi/device_handler/scsi_dh.c b/drivers/scsi/device_handler/scsi_dh.c
index 3ee1cbc89479..6fae3d285ae7 100644
--- a/drivers/scsi/device_handler/scsi_dh.c
+++ b/drivers/scsi/device_handler/scsi_dh.c
@@ -21,6 +21,7 @@
  *               Mike Anderson <andmike@linux.vnet.ibm.com>
  */
 
+#include <linux/slab.h>
 #include <scsi/scsi_dh.h>
 #include "../scsi_priv.h"
 
@@ -226,7 +227,7 @@ store_dh_state(struct device *dev, struct device_attribute *attr,
                          * Activate a device handler
                          */
                         if (scsi_dh->activate)
-                                err = scsi_dh->activate(sdev);
+                                err = scsi_dh->activate(sdev, NULL, NULL);
                         else
                                 err = 0;
                 }
@@ -304,18 +305,15 @@ static int scsi_dh_notifier(struct notifier_block *nb,
         sdev = to_scsi_device(dev);
 
         if (action == BUS_NOTIFY_ADD_DEVICE) {
+                err = device_create_file(dev, &scsi_dh_state_attr);
+                /* don't care about err */
                 devinfo = device_handler_match(NULL, sdev);
-                if (!devinfo)
-                        goto out;
-
-                err = scsi_dh_handler_attach(sdev, devinfo);
-                if (!err)
-                        err = device_create_file(dev, &scsi_dh_state_attr);
+                if (devinfo)
+                        err = scsi_dh_handler_attach(sdev, devinfo);
         } else if (action == BUS_NOTIFY_DEL_DEVICE) {
                 device_remove_file(dev, &scsi_dh_state_attr);
                 scsi_dh_handler_detach(sdev, NULL);
         }
-out:
         return err;
 }
 
@@ -423,10 +421,17 @@ EXPORT_SYMBOL_GPL(scsi_unregister_device_handler);
 /*
  * scsi_dh_activate - activate the path associated with the scsi_device
  *      corresponding to the given request queue.
- * @q - Request queue that is associated with the scsi_device to be
- *      activated.
+ *     Returns immediately without waiting for activation to be completed.
+ * @q    - Request queue that is associated with the scsi_device to be
+ *         activated.
+ * @fn   - Function to be called upon completion of the activation.
+ *         Function fn is called with data (below) and the error code.
+ *         Function fn may be called from the same calling context. So,
+ *         do not hold the lock in the caller which may be needed in fn.
+ * @data - data passed to the function fn upon completion.
+ *
  */
-int scsi_dh_activate(struct request_queue *q)
+int scsi_dh_activate(struct request_queue *q, activate_complete fn, void *data)
 {
         int err = 0;
         unsigned long flags;
@@ -445,7 +450,7 @@ int scsi_dh_activate(struct request_queue *q)
                 return err;
 
         if (scsi_dh->activate)
-                err = scsi_dh->activate(sdev);
+                err = scsi_dh->activate(sdev, fn, data);
         put_device(&sdev->sdev_gendev);
         return err;
 }
diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c
index b5cdefaf2608..1a970a76b1b9 100644
--- a/drivers/scsi/device_handler/scsi_dh_alua.c
+++ b/drivers/scsi/device_handler/scsi_dh_alua.c
@@ -19,6 +19,7 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *
  */
+#include <linux/slab.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_dh.h>
@@ -60,11 +61,17 @@ struct alua_dh_data {
         int                     bufflen;
         unsigned char           sense[SCSI_SENSE_BUFFERSIZE];
         int                     senselen;
+        struct scsi_device      *sdev;
+        activate_complete       callback_fn;
+        void                    *callback_data;
 };
 
 #define ALUA_POLICY_SWITCH_CURRENT      0
 #define ALUA_POLICY_SWITCH_ALL          1
 
+static char print_alua_state(int);
+static int alua_check_sense(struct scsi_device *, struct scsi_sense_hdr *);
+
 static inline struct alua_dh_data *get_alua_data(struct scsi_device *sdev)
 {
         struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
@@ -231,18 +238,71 @@ done:
 }
 
 /*
+ * alua_stpg - Evaluate SET TARGET GROUP STATES
+ * @sdev: the device to be evaluated
+ * @state: the new target group state
+ *
+ * Send a SET TARGET GROUP STATES command to the device.
+ * We only have to test here if we should resubmit the command;
+ * any other error is assumed as a failure.
+ */
+static void stpg_endio(struct request *req, int error)
+{
+        struct alua_dh_data *h = req->end_io_data;
+        struct scsi_sense_hdr sense_hdr;
+        unsigned err = SCSI_DH_IO;
+
+        if (error || host_byte(req->errors) != DID_OK ||
+                        msg_byte(req->errors) != COMMAND_COMPLETE)
+                goto done;
+
+        if (err == SCSI_DH_IO && h->senselen > 0) {
+                err = scsi_normalize_sense(h->sense, SCSI_SENSE_BUFFERSIZE,
+                                           &sense_hdr);
+                if (!err) {
+                        err = SCSI_DH_IO;
+                        goto done;
+                }
+                err = alua_check_sense(h->sdev, &sense_hdr);
+                if (err == ADD_TO_MLQUEUE) {
+                        err = SCSI_DH_RETRY;
+                        goto done;
+                }
+                sdev_printk(KERN_INFO, h->sdev,
+                            "%s: stpg sense code: %02x/%02x/%02x\n",
+                            ALUA_DH_NAME, sense_hdr.sense_key,
+                            sense_hdr.asc, sense_hdr.ascq);
+                err = SCSI_DH_IO;
+        }
+        if (err == SCSI_DH_OK) {
+                h->state = TPGS_STATE_OPTIMIZED;
+                sdev_printk(KERN_INFO, h->sdev,
+                            "%s: port group %02x switched to state %c\n",
+                            ALUA_DH_NAME, h->group_id,
+                            print_alua_state(h->state));
+        }
+done:
+        blk_put_request(req);
+        if (h->callback_fn) {
+                h->callback_fn(h->callback_data, err);
+                h->callback_fn = h->callback_data = NULL;
+        }
+        return;
+}
+
+/*
  * submit_stpg - Issue a SET TARGET GROUP STATES command
- * @sdev: sdev the command should be sent to
  *
  * Currently we're only setting the current target port group state
  * to 'active/optimized' and let the array firmware figure out
  * the states of the remaining groups.
  */
-static unsigned submit_stpg(struct scsi_device *sdev, struct alua_dh_data *h)
+static unsigned submit_stpg(struct alua_dh_data *h)
 {
         struct request *rq;
         int err = SCSI_DH_RES_TEMP_UNAVAIL;
         int stpg_len = 8;
+        struct scsi_device *sdev = h->sdev;
 
         /* Prepare the data buffer */
         memset(h->buff, 0, stpg_len);
@@ -252,7 +312,7 @@ static unsigned submit_stpg(struct scsi_device *sdev, struct alua_dh_data *h)
 
         rq = get_alua_req(sdev, h->buff, stpg_len, WRITE);
         if (!rq)
-                goto done;
+                return SCSI_DH_RES_TEMP_UNAVAIL;
 
         /* Prepare the command. */
         rq->cmd[0] = MAINTENANCE_OUT;
@@ -266,17 +326,9 @@ static unsigned submit_stpg(struct scsi_device *sdev, struct alua_dh_data *h)
         rq->sense = h->sense;
         memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
         rq->sense_len = h->senselen = 0;
+        rq->end_io_data = h;
 
-        err = blk_execute_rq(rq->q, NULL, rq, 1);
-        if (err == -EIO) {
-                sdev_printk(KERN_INFO, sdev,
-                            "%s: stpg failed with %x\n",
-                            ALUA_DH_NAME, rq->errors);
-                h->senselen = rq->sense_len;
-                err = SCSI_DH_IO;
-        }
-        blk_put_request(rq);
-done:
+        blk_execute_rq_nowait(rq->q, NULL, rq, 1, stpg_endio);
         return err;
 }
 
@@ -477,50 +529,6 @@ static int alua_check_sense(struct scsi_device *sdev,
 }
 
 /*
- * alua_stpg - Evaluate SET TARGET GROUP STATES
- * @sdev: the device to be evaluated
- * @state: the new target group state
- *
- * Send a SET TARGET GROUP STATES command to the device.
- * We only have to test here if we should resubmit the command;
- * any other error is assumed as a failure.
- */
-static int alua_stpg(struct scsi_device *sdev, int state,
-                     struct alua_dh_data *h)
-{
-        struct scsi_sense_hdr sense_hdr;
-        unsigned err;
-        int retry = ALUA_FAILOVER_RETRIES;
-
- retry:
-        err = submit_stpg(sdev, h);
-        if (err == SCSI_DH_IO && h->senselen > 0) {
-                err = scsi_normalize_sense(h->sense, SCSI_SENSE_BUFFERSIZE,
-                                           &sense_hdr);
-                if (!err)
-                        return SCSI_DH_IO;
-                err = alua_check_sense(sdev, &sense_hdr);
-                if (retry > 0 && err == ADD_TO_MLQUEUE) {
-                        retry--;
-                        goto retry;
-                }
-                sdev_printk(KERN_INFO, sdev,
-                            "%s: stpg sense code: %02x/%02x/%02x\n",
-                            ALUA_DH_NAME, sense_hdr.sense_key,
-                            sense_hdr.asc, sense_hdr.ascq);
-                err = SCSI_DH_IO;
-        }
-        if (err == SCSI_DH_OK) {
-                h->state = state;
-                sdev_printk(KERN_INFO, sdev,
-                            "%s: port group %02x switched to state %c\n",
-                            ALUA_DH_NAME, h->group_id,
-                            print_alua_state(h->state) );
-        }
-        return err;
-}
-
-/*
  * alua_rtpg - Evaluate REPORT TARGET GROUP STATES
  * @sdev: the device to be evaluated.
  *
@@ -652,7 +660,8 @@ out:
  * based on a certain policy. But until we actually encounter them it
  * should be okay.
  */
-static int alua_activate(struct scsi_device *sdev)
+static int alua_activate(struct scsi_device *sdev,
+                        activate_complete fn, void *data)
 {
         struct alua_dh_data *h = get_alua_data(sdev);
         int err = SCSI_DH_OK;
@@ -663,11 +672,19 @@ static int alua_activate(struct scsi_device *sdev)
                         goto out;
         }
 
-        if (h->tpgs & TPGS_MODE_EXPLICIT && h->state != TPGS_STATE_OPTIMIZED)
-                err = alua_stpg(sdev, TPGS_STATE_OPTIMIZED, h);
+        if (h->tpgs & TPGS_MODE_EXPLICIT && h->state != TPGS_STATE_OPTIMIZED) {
+                h->callback_fn = fn;
+                h->callback_data = data;
+                err = submit_stpg(h);
+                if (err == SCSI_DH_OK)
+                        return 0;
+                h->callback_fn = h->callback_data = NULL;
+        }
 
 out:
-        return err;
+        if (fn)
+                fn(data, err);
+        return 0;
 }
 
 /*
@@ -701,6 +718,8 @@ static const struct scsi_dh_devlist alua_dev_list[] = {
         {"IBM", "2145" },
         {"Pillar", "Axiom" },
         {"Intel", "Multi-Flex"},
+        {"NETAPP", "LUN"},
+        {"AIX", "NVDISK"},
         {NULL, NULL}
 };
 
@@ -745,6 +764,7 @@ static int alua_bus_attach(struct scsi_device *sdev)
         h->rel_port = -1;
         h->buff = h->inq;
         h->bufflen = ALUA_INQUIRY_SIZE;
+        h->sdev = sdev;
 
         err = alua_initialize(sdev, h);
         if (err != SCSI_DH_OK)
diff --git a/drivers/scsi/device_handler/scsi_dh_emc.c b/drivers/scsi/device_handler/scsi_dh_emc.c
index 0cffe84976fe..e8a0bc3efd49 100644
--- a/drivers/scsi/device_handler/scsi_dh_emc.c
+++ b/drivers/scsi/device_handler/scsi_dh_emc.c
@@ -20,6 +20,7 @@
  * along with this program; see the file COPYING.  If not, write to
  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  */
+#include <linux/slab.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_dh.h>
@@ -272,7 +273,7 @@ static struct request *get_req(struct scsi_device *sdev, int cmd,
         int len = 0;
 
         rq = blk_get_request(sdev->request_queue,
-                        (cmd == MODE_SELECT) ? WRITE : READ, GFP_NOIO);
+                        (cmd != INQUIRY) ? WRITE : READ, GFP_NOIO);
         if (!rq) {
                 sdev_printk(KERN_INFO, sdev, "get_req: blk_get_request failed");
                 return NULL;
@@ -286,14 +287,17 @@ static struct request *get_req(struct scsi_device *sdev, int cmd,
                 len = sizeof(short_trespass);
                 rq->cmd_flags |= REQ_RW;
                 rq->cmd[1] = 0x10;
+                rq->cmd[4] = len;
                 break;
         case MODE_SELECT_10:
                 len = sizeof(long_trespass);
                 rq->cmd_flags |= REQ_RW;
                 rq->cmd[1] = 0x10;
+                rq->cmd[8] = len;
                 break;
         case INQUIRY:
                 len = CLARIION_BUFFER_SIZE;
+                rq->cmd[4] = len;
                 memset(buffer, 0, len);
                 break;
         default:
@@ -301,7 +305,6 @@ static struct request *get_req(struct scsi_device *sdev, int cmd,
                 break;
         }
 
-        rq->cmd[4] = len;
         rq->cmd_type = REQ_TYPE_BLOCK_PC;
         rq->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
                          REQ_FAILFAST_DRIVER;
@@ -528,7 +531,8 @@ retry:
         return err;
 }
 
-static int clariion_activate(struct scsi_device *sdev)
+static int clariion_activate(struct scsi_device *sdev,
+                                activate_complete fn, void *data)
 {
         struct clariion_dh_data *csdev = get_clariion_data(sdev);
         int result;
@@ -559,7 +563,9 @@ done:
                     csdev->port, lun_state[csdev->lun_state],
                     csdev->default_sp + 'A');
 
-        return result;
+        if (fn)
+                fn(data, result);
+        return 0;
 }
 /*
  * params - parameters in the following format
diff --git a/drivers/scsi/device_handler/scsi_dh_hp_sw.c b/drivers/scsi/device_handler/scsi_dh_hp_sw.c
index f7da7530875e..e3916641e627 100644
--- a/drivers/scsi/device_handler/scsi_dh_hp_sw.c
+++ b/drivers/scsi/device_handler/scsi_dh_hp_sw.c
@@ -21,6 +21,7 @@
  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include <linux/slab.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_dbg.h>
 #include <scsi/scsi_eh.h>
@@ -39,8 +40,14 @@ struct hp_sw_dh_data {
         unsigned char sense[SCSI_SENSE_BUFFERSIZE];
         int path_state;
         int retries;
+        int retry_cnt;
+        struct scsi_device *sdev;
+        activate_complete       callback_fn;
+        void                    *callback_data;
 };
 
+static int hp_sw_start_stop(struct hp_sw_dh_data *);
+
 static inline struct hp_sw_dh_data *get_hp_sw_data(struct scsi_device *sdev)
 {
         struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
@@ -191,19 +198,53 @@ static int start_done(struct scsi_device *sdev, unsigned char *sense)
         return rc;
 }
 
+static void start_stop_endio(struct request *req, int error)
+{
+        struct hp_sw_dh_data *h = req->end_io_data;
+        unsigned err = SCSI_DH_OK;
+
+        if (error || host_byte(req->errors) != DID_OK ||
+                        msg_byte(req->errors) != COMMAND_COMPLETE) {
+                sdev_printk(KERN_WARNING, h->sdev,
+                            "%s: sending start_stop_unit failed with %x\n",
+                            HP_SW_NAME, req->errors);
+                err = SCSI_DH_IO;
+                goto done;
+        }
+
+        if (req->sense_len > 0) {
+                err = start_done(h->sdev, h->sense);
+                if (err == SCSI_DH_RETRY) {
+                        err = SCSI_DH_IO;
+                        if (--h->retry_cnt) {
+                                blk_put_request(req);
+                                err = hp_sw_start_stop(h);
+                                if (err == SCSI_DH_OK)
+                                        return;
+                        }
+                }
+        }
+done:
+        blk_put_request(req);
+        if (h->callback_fn) {
+                h->callback_fn(h->callback_data, err);
+                h->callback_fn = h->callback_data = NULL;
+        }
+        return;
+
+}
+
 /*
  * hp_sw_start_stop - Send START STOP UNIT command
  * @sdev: sdev command should be sent to
  *
  * Sending START STOP UNIT activates the SP.
  */
-static int hp_sw_start_stop(struct scsi_device *sdev, struct hp_sw_dh_data *h)
+static int hp_sw_start_stop(struct hp_sw_dh_data *h)
 {
         struct request *req;
-        int ret, retry;
 
-retry:
-        req = blk_get_request(sdev->request_queue, WRITE, GFP_NOIO);
+        req = blk_get_request(h->sdev->request_queue, WRITE, GFP_ATOMIC);
         if (!req)
                 return SCSI_DH_RES_TEMP_UNAVAIL;
 
@@ -217,32 +258,10 @@ retry:
         req->sense = h->sense;
         memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
         req->sense_len = 0;
-        retry = h->retries;
-
-        ret = blk_execute_rq(req->q, NULL, req, 1);
-        if (ret == -EIO) {
-                if (req->sense_len > 0) {
-                        ret = start_done(sdev, h->sense);
-                } else {
-                        sdev_printk(KERN_WARNING, sdev,
-                                    "%s: sending start_stop_unit failed with %x\n",
-                                    HP_SW_NAME, req->errors);
-                        ret = SCSI_DH_IO;
-                }
-        } else
-                ret = SCSI_DH_OK;
+        req->end_io_data = h;
 
-        if (ret == SCSI_DH_RETRY) {
-                if (--retry) {
-                        blk_put_request(req);
-                        goto retry;
-                }
-                ret = SCSI_DH_IO;
-        }
-
-        blk_put_request(req);
-
-        return ret;
+        blk_execute_rq_nowait(req->q, NULL, req, 1, start_stop_endio);
+        return SCSI_DH_OK;
 }
 
 static int hp_sw_prep_fn(struct scsi_device *sdev, struct request *req)
@@ -268,7 +287,8 @@ static int hp_sw_prep_fn(struct scsi_device *sdev, struct request *req)
  * activate the passive path (and deactivate the
  * previously active one).
  */
-static int hp_sw_activate(struct scsi_device *sdev)
+static int hp_sw_activate(struct scsi_device *sdev,
+                                activate_complete fn, void *data)
 {
         int ret = SCSI_DH_OK;
         struct hp_sw_dh_data *h = get_hp_sw_data(sdev);
@@ -276,14 +296,18 @@ static int hp_sw_activate(struct scsi_device *sdev)
         ret = hp_sw_tur(sdev, h);
 
         if (ret == SCSI_DH_OK && h->path_state == HP_SW_PATH_PASSIVE) {
-                ret = hp_sw_start_stop(sdev, h);
+                h->retry_cnt = h->retries;
+                h->callback_fn = fn;
+                h->callback_data = data;
+                ret = hp_sw_start_stop(h);
                 if (ret == SCSI_DH_OK)
-                        sdev_printk(KERN_INFO, sdev,
-                                    "%s: activated path\n",
-                                    HP_SW_NAME);
+                        return 0;
+                h->callback_fn = h->callback_data = NULL;
         }
 
-        return ret;
+        if (fn)
+                fn(data, ret);
+        return 0;
 }
 
 static const struct scsi_dh_devlist hp_sw_dh_data_list[] = {
@@ -326,6 +350,7 @@ static int hp_sw_bus_attach(struct scsi_device *sdev)
         h = (struct hp_sw_dh_data *) scsi_dh_data->buf;
         h->path_state = HP_SW_PATH_UNINITIALIZED;
         h->retries = HP_SW_RETRIES;
+        h->sdev = sdev;
 
         ret = hp_sw_tur(sdev, h);
         if (ret != SCSI_DH_OK || h->path_state == HP_SW_PATH_UNINITIALIZED)
diff --git a/drivers/scsi/device_handler/scsi_dh_rdac.c b/drivers/scsi/device_handler/scsi_dh_rdac.c
index 268189d31d9c..5b683e429542 100644
--- a/drivers/scsi/device_handler/scsi_dh_rdac.c
+++ b/drivers/scsi/device_handler/scsi_dh_rdac.c
@@ -22,6 +22,8 @@
 #include <scsi/scsi.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_dh.h>
+#include <linux/workqueue.h>
+#include <linux/slab.h>
 
 #define RDAC_NAME "rdac"
 #define RDAC_RETRY_COUNT 5
@@ -138,7 +140,13 @@ struct rdac_controller {
         } mode_select;
         u8      index;
         u8      array_name[ARRAY_LABEL_LEN];
+        spinlock_t              ms_lock;
+        int                     ms_queued;
+        struct work_struct      ms_work;
+        struct scsi_device      *ms_sdev;
+        struct list_head        ms_head;
 };
+
 struct c8_inquiry {
         u8      peripheral_info;
         u8      page_code; /* 0xC8 */
@@ -198,8 +206,17 @@ static const char *lun_state[] =
         "owned (AVT mode)",
 };
 
+struct rdac_queue_data {
+        struct list_head        entry;
+        struct rdac_dh_data     *h;
+        activate_complete       callback_fn;
+        void                    *callback_data;
+};
+
 static LIST_HEAD(ctlr_list);
 static DEFINE_SPINLOCK(list_lock);
+static struct workqueue_struct *kmpath_rdacd;
+static void send_mode_select(struct work_struct *work);
 
 /*
  * module parameter to enable rdac debug logging.
@@ -281,7 +298,6 @@ static struct request *rdac_failover_get(struct scsi_device *sdev,
                 rdac_pg->subpage_code = 0x1;
                 rdac_pg->page_len[0] = 0x01;
                 rdac_pg->page_len[1] = 0x28;
-                rdac_pg->lun_table[h->lun] = 0x81;
         } else {
                 struct rdac_pg_legacy *rdac_pg;
 
@@ -291,7 +307,6 @@ static struct request *rdac_failover_get(struct scsi_device *sdev,
                 common = &rdac_pg->common;
                 rdac_pg->page_code = RDAC_PAGE_CODE_REDUNDANT_CONTROLLER;
                 rdac_pg->page_len = 0x68;
-                rdac_pg->lun_table[h->lun] = 0x81;
         }
         common->rdac_mode[1] = RDAC_MODE_TRANSFER_SPECIFIED_LUNS;
         common->quiescence_timeout = RDAC_QUIESCENCE_TIME;
@@ -325,6 +340,7 @@ static void release_controller(struct kref *kref)
         struct rdac_controller *ctlr;
         ctlr = container_of(kref, struct rdac_controller, kref);
 
+        flush_workqueue(kmpath_rdacd);
         spin_lock(&list_lock);
         list_del(&ctlr->node);
         spin_unlock(&list_lock);
@@ -363,6 +379,11 @@ static struct rdac_controller *get_controller(u8 *subsys_id, u8 *slot_id,
 
         kref_init(&ctlr->kref);
         ctlr->use_ms10 = -1;
+        ctlr->ms_queued = 0;
+        ctlr->ms_sdev = NULL;
+        spin_lock_init(&ctlr->ms_lock);
+        INIT_WORK(&ctlr->ms_work, send_mode_select);
+        INIT_LIST_HEAD(&ctlr->ms_head);
         list_add(&ctlr->node, &ctlr_list);
 done:
         spin_unlock(&list_lock);
@@ -490,7 +511,7 @@ static int set_mode_select(struct scsi_device *sdev, struct rdac_dh_data *h)
 }
 
 static int mode_select_handle_sense(struct scsi_device *sdev,
-                                    unsigned char *sensebuf)
+                                        unsigned char *sensebuf)
 {
         struct scsi_sense_hdr sense_hdr;
         int err = SCSI_DH_IO, ret;
@@ -533,11 +554,29 @@ done:
         return err;
 }
 
-static int send_mode_select(struct scsi_device *sdev, struct rdac_dh_data *h)
+static void send_mode_select(struct work_struct *work)
 {
+        struct rdac_controller *ctlr =
+                container_of(work, struct rdac_controller, ms_work);
         struct request *rq;
+        struct scsi_device *sdev = ctlr->ms_sdev;
+        struct rdac_dh_data *h = get_rdac_data(sdev);
         struct request_queue *q = sdev->request_queue;
         int err, retry_cnt = RDAC_RETRY_COUNT;
+        struct rdac_queue_data *tmp, *qdata;
+        LIST_HEAD(list);
+        u8 *lun_table;
+
+        spin_lock(&ctlr->ms_lock);
+        list_splice_init(&ctlr->ms_head, &list);
+        ctlr->ms_queued = 0;
+        ctlr->ms_sdev = NULL;
+        spin_unlock(&ctlr->ms_lock);
+
+        if (ctlr->use_ms10)
+                lun_table = ctlr->mode_select.expanded.lun_table;
+        else
+                lun_table = ctlr->mode_select.legacy.lun_table;
 
 retry:
         err = SCSI_DH_RES_TEMP_UNAVAIL;
@@ -545,6 +584,10 @@ retry:
         if (!rq)
                 goto done;
 
+        list_for_each_entry(qdata, &list, entry) {
+                lun_table[qdata->h->lun] = 0x81;
+        }
+
         RDAC_LOG(RDAC_LOG_FAILOVER, sdev, "array %s, ctlr %d, "
                 "%s MODE_SELECT command",
                 (char *) h->ctlr->array_name, h->ctlr->index,
@@ -565,10 +608,45 @@ retry:
         }
 
 done:
-        return err;
+        list_for_each_entry_safe(qdata, tmp, &list, entry) {
+                list_del(&qdata->entry);
+                if (err == SCSI_DH_OK)
+                        qdata->h->state = RDAC_STATE_ACTIVE;
+                if (qdata->callback_fn)
+                        qdata->callback_fn(qdata->callback_data, err);
+                kfree(qdata);
+        }
+        return;
+}
+
+static int queue_mode_select(struct scsi_device *sdev,
+                                activate_complete fn, void *data)
+{
+        struct rdac_queue_data *qdata;
+        struct rdac_controller *ctlr;
+
+        qdata = kzalloc(sizeof(*qdata), GFP_KERNEL);
+        if (!qdata)
+                return SCSI_DH_RETRY;
+
+        qdata->h = get_rdac_data(sdev);
+        qdata->callback_fn = fn;
+        qdata->callback_data = data;
+
+        ctlr = qdata->h->ctlr;
+        spin_lock(&ctlr->ms_lock);
+        list_add_tail(&qdata->entry, &ctlr->ms_head);
+        if (!ctlr->ms_queued) {
+                ctlr->ms_queued = 1;
+                ctlr->ms_sdev = sdev;
+                queue_work(kmpath_rdacd, &ctlr->ms_work);
+        }
+        spin_unlock(&ctlr->ms_lock);
+        return SCSI_DH_OK;
 }
 
-static int rdac_activate(struct scsi_device *sdev)
+static int rdac_activate(struct scsi_device *sdev,
+                        activate_complete fn, void *data)
 {
         struct rdac_dh_data *h = get_rdac_data(sdev);
         int err = SCSI_DH_OK;
@@ -577,10 +655,15 @@ static int rdac_activate(struct scsi_device *sdev)
         if (err != SCSI_DH_OK)
                 goto done;
 
-        if (h->lun_state == RDAC_LUN_UNOWNED)
-                err = send_mode_select(sdev, h);
+        if (h->lun_state == RDAC_LUN_UNOWNED) {
+                err = queue_mode_select(sdev, fn, data);
+                if (err == SCSI_DH_OK)
+                        return 0;
+        }
 done:
-        return err;
+        if (fn)
+                fn(data, err);
+        return 0;
 }
 
 static int rdac_prep_fn(struct scsi_device *sdev, struct request *req)
@@ -666,6 +749,8 @@ static const struct scsi_dh_devlist rdac_dev_list[] = {
         {"IBM", "1724"},
         {"IBM", "1726"},
         {"IBM", "1742"},
+        {"IBM", "1745"},
+        {"IBM", "1746"},
         {"IBM", "1814"},
         {"IBM", "1815"},
         {"IBM", "1818"},
@@ -790,13 +875,26 @@ static int __init rdac_init(void)
         int r;
 
         r = scsi_register_device_handler(&rdac_dh);
-        if (r != 0)
+        if (r != 0) {
                 printk(KERN_ERR "Failed to register scsi device handler.");
+                goto done;
+        }
+
+        /*
+         * Create workqueue to handle mode selects for rdac
+         */
+        kmpath_rdacd = create_singlethread_workqueue("kmpath_rdacd");
+        if (!kmpath_rdacd) {
+                scsi_unregister_device_handler(&rdac_dh);
+                printk(KERN_ERR "kmpath_rdacd creation failed.\n");
+        }
+done:
         return r;
 }
 
 static void __exit rdac_exit(void)
 {
+        destroy_workqueue(kmpath_rdacd);
         scsi_unregister_device_handler(&rdac_dh);
 }
 
diff --git a/drivers/scsi/dmx3191d.c b/drivers/scsi/dmx3191d.c
index fa738ec8692a..207352cc70cc 100644
--- a/drivers/scsi/dmx3191d.c
+++ b/drivers/scsi/dmx3191d.c
@@ -31,7 +31,7 @@
 #include <scsi/scsi_host.h>
 
 /*
- * Defintions for the generic 5380 driver.
+ * Definitions for the generic 5380 driver.
  */
 #define AUTOSENSE
 
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index 496764349c41..0435d044c9da 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -188,7 +188,8 @@ MODULE_DEVICE_TABLE(pci,dptids);
 static int adpt_detect(struct scsi_host_template* sht)
 {
         struct pci_dev *pDev = NULL;
-        adpt_hba* pHba;
+        adpt_hba *pHba;
+        adpt_hba *next;
 
         PINFO("Detecting Adaptec I2O RAID controllers...\n");
 
@@ -206,7 +207,8 @@ static int adpt_detect(struct scsi_host_template* sht)
         }
 
         /* In INIT state, Activate IOPs */
-        for (pHba = hba_chain; pHba; pHba = pHba->next) {
+        for (pHba = hba_chain; pHba; pHba = next) {
+                next = pHba->next;
                 // Activate does get status , init outbound, and get hrt
                 if (adpt_i2o_activate_hba(pHba) < 0) {
                         adpt_i2o_delete_hba(pHba);
@@ -243,7 +245,8 @@ rebuild_sys_tab:
         PDEBUG("HBA's in OPERATIONAL state\n");
 
         printk("dpti: If you have a lot of devices this could take a few minutes.\n");
-        for (pHba = hba_chain; pHba; pHba = pHba->next) {
+        for (pHba = hba_chain; pHba; pHba = next) {
+                next = pHba->next;
                 printk(KERN_INFO"%s: Reading the hardware resource table.\n", pHba->name);
                 if (adpt_i2o_lct_get(pHba) < 0){
                         adpt_i2o_delete_hba(pHba);
@@ -263,7 +266,8 @@ rebuild_sys_tab:
                 adpt_sysfs_class = NULL;
         }
 
-        for (pHba = hba_chain; pHba; pHba = pHba->next) {
+        for (pHba = hba_chain; pHba; pHba = next) {
+                next = pHba->next;
                 if (adpt_scsi_host_alloc(pHba, sht) < 0){
                         adpt_i2o_delete_hba(pHba);
                         continue;
@@ -1229,11 +1233,10 @@ static void adpt_i2o_delete_hba(adpt_hba* pHba)
                 }
         }
         pci_dev_put(pHba->pDev);
-        kfree(pHba);
-
         if (adpt_sysfs_class)
                 device_destroy(adpt_sysfs_class,
                                 MKDEV(DPTI_I2O_MAJOR, pHba->unit));
+        kfree(pHba);
 
         if(hba_count <= 0){
                 unregister_chrdev(DPTI_I2O_MAJOR, DPT_DRIVER);   
diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index c7076ce25e21..d1c31378f6da 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -490,6 +490,7 @@
 #include <linux/ctype.h>
 #include <linux/spinlock.h>
 #include <linux/dma-mapping.h>
+#include <linux/slab.h>
 #include <asm/byteorder.h>
 #include <asm/dma.h>
 #include <asm/io.h>
@@ -1509,7 +1510,7 @@ static int option_setup(char *str)
         char *cur = str;
         int i = 1;
 
-        while (cur && isdigit(*cur) && i <= MAX_INT_PARAM) {
+        while (cur && isdigit(*cur) && i < MAX_INT_PARAM) {
                 ints[i++] = simple_strtoul(cur, NULL, 0);
 
                 if ((cur = strchr(cur, ',')) != NULL)
diff --git a/drivers/scsi/eata_pio.c b/drivers/scsi/eata_pio.c
index 152dd15db276..60886c19065e 100644
--- a/drivers/scsi/eata_pio.c
+++ b/drivers/scsi/eata_pio.c
@@ -50,7 +50,6 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/ioport.h>
-#include <linux/slab.h>
 #include <linux/in.h>
 #include <linux/pci.h>
 #include <linux/proc_fs.h>
diff --git a/drivers/scsi/esp_scsi.c b/drivers/scsi/esp_scsi.c
index a680e18b5f3b..e2bc779f86c1 100644
--- a/drivers/scsi/esp_scsi.c
+++ b/drivers/scsi/esp_scsi.c
@@ -1449,9 +1449,6 @@ static void esp_msgin_sdtr(struct esp *esp, struct esp_target_data *tp)
         if (offset > 15)
                 goto do_reject;
 
-        if (esp->flags & ESP_FLAG_DISABLE_SYNC)
-                offset = 0;
-
         if (offset) {
                 int one_clock;
 
@@ -2405,12 +2402,6 @@ static int esp_slave_configure(struct scsi_device *dev)
         struct esp_target_data *tp = &esp->target[dev->id];
         int goal_tags, queue_depth;
 
-        if (esp->flags & ESP_FLAG_DISABLE_SYNC) {
-                /* Bypass async domain validation */
-                dev->ppr  = 0;
-                dev->sdtr = 0;
-        }
-
         goal_tags = 0;
 
         if (dev->tagged_supported) {
@@ -2660,7 +2651,10 @@ static void esp_set_offset(struct scsi_target *target, int offset)
         struct esp *esp = shost_priv(host);
         struct esp_target_data *tp = &esp->target[target->id];
 
-        tp->nego_goal_offset = offset;
+        if (esp->flags & ESP_FLAG_DISABLE_SYNC)
+                tp->nego_goal_offset = 0;
+        else
+                tp->nego_goal_offset = offset;
         tp->flags |= ESP_TGT_CHECK_NEGO;
 }
 
diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c
index 704b8e034946..f01b9b44e8aa 100644
--- a/drivers/scsi/fcoe/fcoe.c
+++ b/drivers/scsi/fcoe/fcoe.c
@@ -26,6 +26,7 @@
 #include <linux/if_ether.h>
 #include <linux/if_vlan.h>
 #include <linux/crc32.h>
+#include <linux/slab.h>
 #include <linux/cpu.h>
 #include <linux/fs.h>
 #include <linux/sysfs.h>
@@ -66,14 +67,14 @@ LIST_HEAD(fcoe_hostlist);
 DEFINE_PER_CPU(struct fcoe_percpu_s, fcoe_percpu);
 
 /* Function Prototypes */
-static int fcoe_reset(struct Scsi_Host *shost);
+static int fcoe_reset(struct Scsi_Host *);
 static int fcoe_xmit(struct fc_lport *, struct fc_frame *);
 static int fcoe_rcv(struct sk_buff *, struct net_device *,
                     struct packet_type *, struct net_device *);
-static int fcoe_percpu_receive_thread(void *arg);
-static void fcoe_clean_pending_queue(struct fc_lport *lp);
-static void fcoe_percpu_clean(struct fc_lport *lp);
-static int fcoe_link_ok(struct fc_lport *lp);
+static int fcoe_percpu_receive_thread(void *);
+static void fcoe_clean_pending_queue(struct fc_lport *);
+static void fcoe_percpu_clean(struct fc_lport *);
+static int fcoe_link_ok(struct fc_lport *);
 
 static struct fc_lport *fcoe_hostlist_lookup(const struct net_device *);
 static int fcoe_hostlist_add(const struct fc_lport *);
@@ -82,15 +83,77 @@ static void fcoe_check_wait_queue(struct fc_lport *, struct sk_buff *);
 static int fcoe_device_notification(struct notifier_block *, ulong, void *);
 static void fcoe_dev_setup(void);
 static void fcoe_dev_cleanup(void);
-static struct fcoe_interface *
-        fcoe_hostlist_lookup_port(const struct net_device *dev);
+static struct fcoe_interface
+*fcoe_hostlist_lookup_port(const struct net_device *);
+
+static int fcoe_fip_recv(struct sk_buff *, struct net_device *,
+                         struct packet_type *, struct net_device *);
+
+static void fcoe_fip_send(struct fcoe_ctlr *, struct sk_buff *);
+static void fcoe_update_src_mac(struct fc_lport *, u8 *);
+static u8 *fcoe_get_src_mac(struct fc_lport *);
+static void fcoe_destroy_work(struct work_struct *);
+
+static int fcoe_ddp_setup(struct fc_lport *, u16, struct scatterlist *,
+                          unsigned int);
+static int fcoe_ddp_done(struct fc_lport *, u16);
+
+static int fcoe_cpu_callback(struct notifier_block *, unsigned long, void *);
+
+static int fcoe_create(const char *, struct kernel_param *);
+static int fcoe_destroy(const char *, struct kernel_param *);
+static int fcoe_enable(const char *, struct kernel_param *);
+static int fcoe_disable(const char *, struct kernel_param *);
+
+static struct fc_seq *fcoe_elsct_send(struct fc_lport *,
+                                      u32 did, struct fc_frame *,
+                                      unsigned int op,
+                                      void (*resp)(struct fc_seq *,
+                                                   struct fc_frame *,
+                                                   void *),
+                                      void *, u32 timeout);
+static void fcoe_recv_frame(struct sk_buff *skb);
 
-/* notification function from net device */
+static void fcoe_get_lesb(struct fc_lport *, struct fc_els_lesb *);
+
+module_param_call(create, fcoe_create, NULL, NULL, S_IWUSR);
+__MODULE_PARM_TYPE(create, "string");
+MODULE_PARM_DESC(create, " Creates fcoe instance on a ethernet interface");
+module_param_call(destroy, fcoe_destroy, NULL, NULL, S_IWUSR);
+__MODULE_PARM_TYPE(destroy, "string");
+MODULE_PARM_DESC(destroy, " Destroys fcoe instance on a ethernet interface");
+module_param_call(enable, fcoe_enable, NULL, NULL, S_IWUSR);
+__MODULE_PARM_TYPE(enable, "string");
+MODULE_PARM_DESC(enable, " Enables fcoe on a ethernet interface.");
+module_param_call(disable, fcoe_disable, NULL, NULL, S_IWUSR);
+__MODULE_PARM_TYPE(disable, "string");
+MODULE_PARM_DESC(disable, " Disables fcoe on a ethernet interface.");
+
+/* notification function for packets from net device */
 static struct notifier_block fcoe_notifier = {
         .notifier_call = fcoe_device_notification,
 };
 
-static struct scsi_transport_template *scsi_transport_fcoe_sw;
+/* notification function for CPU hotplug events */
+static struct notifier_block fcoe_cpu_notifier = {
+        .notifier_call = fcoe_cpu_callback,
+};
+
+static struct scsi_transport_template *fcoe_transport_template;
+static struct scsi_transport_template *fcoe_vport_transport_template;
+
+static int fcoe_vport_destroy(struct fc_vport *);
+static int fcoe_vport_create(struct fc_vport *, bool disabled);
+static int fcoe_vport_disable(struct fc_vport *, bool disable);
+static void fcoe_set_vport_symbolic_name(struct fc_vport *);
+
+static struct libfc_function_template fcoe_libfc_fcn_templ = {
+        .frame_send = fcoe_xmit,
+        .ddp_setup = fcoe_ddp_setup,
+        .ddp_done = fcoe_ddp_done,
+        .elsct_send = fcoe_elsct_send,
+        .get_lesb = fcoe_get_lesb,
+};
 
 struct fc_function_template fcoe_transport_function = {
         .show_host_node_name = 1,
@@ -123,6 +186,48 @@ struct fc_function_template fcoe_transport_function = {
         .issue_fc_host_lip = fcoe_reset,
 
         .terminate_rport_io = fc_rport_terminate_io,
+
+        .vport_create = fcoe_vport_create,
+        .vport_delete = fcoe_vport_destroy,
+        .vport_disable = fcoe_vport_disable,
+        .set_vport_symbolic_name = fcoe_set_vport_symbolic_name,
+
+        .bsg_request = fc_lport_bsg_request,
+};
+
+struct fc_function_template fcoe_vport_transport_function = {
+        .show_host_node_name = 1,
+        .show_host_port_name = 1,
+        .show_host_supported_classes = 1,
+        .show_host_supported_fc4s = 1,
+        .show_host_active_fc4s = 1,
+        .show_host_maxframe_size = 1,
+
+        .show_host_port_id = 1,
+        .show_host_supported_speeds = 1,
+        .get_host_speed = fc_get_host_speed,
+        .show_host_speed = 1,
+        .show_host_port_type = 1,
+        .get_host_port_state = fc_get_host_port_state,
+        .show_host_port_state = 1,
+        .show_host_symbolic_name = 1,
+
+        .dd_fcrport_size = sizeof(struct fc_rport_libfc_priv),
+        .show_rport_maxframe_size = 1,
+        .show_rport_supported_classes = 1,
+
+        .show_host_fabric_name = 1,
+        .show_starget_node_name = 1,
+        .show_starget_port_name = 1,
+        .show_starget_port_id = 1,
+        .set_rport_dev_loss_tmo = fc_set_rport_loss_tmo,
+        .show_rport_dev_loss_tmo = 1,
+        .get_fc_host_stats = fc_get_host_stats,
+        .issue_fc_host_lip = fcoe_reset,
+
+        .terminate_rport_io = fc_rport_terminate_io,
+
+        .bsg_request = fc_lport_bsg_request,
 };
 
 static struct scsi_host_template fcoe_shost_template = {
@@ -137,20 +242,17 @@ static struct scsi_host_template fcoe_shost_template = {
         .change_queue_depth = fc_change_queue_depth,
         .change_queue_type = fc_change_queue_type,
         .this_id = -1,
-        .cmd_per_lun = 32,
+        .cmd_per_lun = 3,
         .can_queue = FCOE_MAX_OUTSTANDING_COMMANDS,
         .use_clustering = ENABLE_CLUSTERING,
         .sg_tablesize = SG_ALL,
         .max_sectors = 0xffff,
 };
 
-static int fcoe_fip_recv(struct sk_buff *skb, struct net_device *dev,
-                         struct packet_type *ptype,
-                         struct net_device *orig_dev);
 /**
- * fcoe_interface_setup()
- * @fcoe: new fcoe_interface
- * @netdev : ptr to the associated netdevice struct
+ * fcoe_interface_setup() - Setup a FCoE interface
+ * @fcoe:   The new FCoE interface
+ * @netdev: The net device that the fcoe interface is on
  *
  * Returns : 0 for success
  * Locking: must be called with the RTNL mutex held
@@ -160,23 +262,36 @@ static int fcoe_interface_setup(struct fcoe_interface *fcoe,
 {
         struct fcoe_ctlr *fip = &fcoe->ctlr;
         struct netdev_hw_addr *ha;
+        struct net_device *real_dev;
         u8 flogi_maddr[ETH_ALEN];
+        const struct net_device_ops *ops;
 
         fcoe->netdev = netdev;
 
+        /* Let LLD initialize for FCoE */
+        ops = netdev->netdev_ops;
+        if (ops->ndo_fcoe_enable) {
+                if (ops->ndo_fcoe_enable(netdev))
+                        FCOE_NETDEV_DBG(netdev, "Failed to enable FCoE"
+                                        " specific feature for LLD.\n");
+        }
+
         /* Do not support for bonding device */
         if ((netdev->priv_flags & IFF_MASTER_ALB) ||
             (netdev->priv_flags & IFF_SLAVE_INACTIVE) ||
             (netdev->priv_flags & IFF_MASTER_8023AD)) {
+                FCOE_NETDEV_DBG(netdev, "Bonded interfaces not supported\n");
                 return -EOPNOTSUPP;
         }
 
         /* look for SAN MAC address, if multiple SAN MACs exist, only
          * use the first one for SPMA */
+        real_dev = (netdev->priv_flags & IFF_802_1Q_VLAN) ?
+                vlan_dev_real_dev(netdev) : netdev;
         rcu_read_lock();
-        for_each_dev_addr(netdev, ha) {
+        for_each_dev_addr(real_dev, ha) {
                 if ((ha->type == NETDEV_HW_ADDR_T_SAN) &&
-                    (is_valid_ether_addr(fip->ctl_src_addr))) {
+                    (is_valid_ether_addr(ha->addr))) {
                         memcpy(fip->ctl_src_addr, ha->addr, ETH_ALEN);
                         fip->spma = 1;
                         break;
@@ -216,19 +331,16 @@ static int fcoe_interface_setup(struct fcoe_interface *fcoe,
         return 0;
 }
 
-static void fcoe_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb);
-static void fcoe_update_src_mac(struct fcoe_ctlr *fip, u8 *old, u8 *new);
-static void fcoe_destroy_work(struct work_struct *work);
-
 /**
- * fcoe_interface_create()
- * @netdev: network interface
+ * fcoe_interface_create() - Create a FCoE interface on a net device
+ * @netdev: The net device to create the FCoE interface on
  *
  * Returns: pointer to a struct fcoe_interface or NULL on error
  */
 static struct fcoe_interface *fcoe_interface_create(struct net_device *netdev)
 {
         struct fcoe_interface *fcoe;
+        int err;
 
         fcoe = kzalloc(sizeof(*fcoe), GFP_KERNEL);
         if (!fcoe) {
@@ -245,15 +357,22 @@ static struct fcoe_interface *fcoe_interface_create(struct net_device *netdev)
         fcoe_ctlr_init(&fcoe->ctlr);
         fcoe->ctlr.send = fcoe_fip_send;
         fcoe->ctlr.update_mac = fcoe_update_src_mac;
+        fcoe->ctlr.get_src_addr = fcoe_get_src_mac;
 
-        fcoe_interface_setup(fcoe, netdev);
+        err = fcoe_interface_setup(fcoe, netdev);
+        if (err) {
+                fcoe_ctlr_destroy(&fcoe->ctlr);
+                kfree(fcoe);
+                dev_put(netdev);
+                return NULL;
+        }
 
         return fcoe;
 }
 
 /**
- * fcoe_interface_cleanup() - clean up netdev configurations
- * @fcoe:
+ * fcoe_interface_cleanup() - Clean up a FCoE interface
+ * @fcoe: The FCoE interface to be cleaned up
  *
  * Caller must be holding the RTNL mutex
  */
@@ -262,6 +381,7 @@ void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
         struct net_device *netdev = fcoe->netdev;
         struct fcoe_ctlr *fip = &fcoe->ctlr;
         u8 flogi_maddr[ETH_ALEN];
+        const struct net_device_ops *ops;
 
         /*
          * Don't listen for Ethernet packets anymore.
@@ -276,16 +396,22 @@ void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
         /* Delete secondary MAC addresses */
         memcpy(flogi_maddr, (u8[6]) FC_FCOE_FLOGI_MAC, ETH_ALEN);
         dev_unicast_delete(netdev, flogi_maddr);
-        if (!is_zero_ether_addr(fip->data_src_addr))
-                dev_unicast_delete(netdev, fip->data_src_addr);
         if (fip->spma)
                 dev_unicast_delete(netdev, fip->ctl_src_addr);
         dev_mc_delete(netdev, FIP_ALL_ENODE_MACS, ETH_ALEN, 0);
+
+        /* Tell the LLD we are done w/ FCoE */
+        ops = netdev->netdev_ops;
+        if (ops->ndo_fcoe_disable) {
+                if (ops->ndo_fcoe_disable(netdev))
+                        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
+ * @kref: Embedded reference count in an fcoe_interface struct
  */
 static void fcoe_interface_release(struct kref *kref)
 {
@@ -301,8 +427,8 @@ static void fcoe_interface_release(struct kref *kref)
 }
 
 /**
- * fcoe_interface_get()
- * @fcoe:
+ * 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)
 {
@@ -310,8 +436,8 @@ static inline void fcoe_interface_get(struct fcoe_interface *fcoe)
 }
 
 /**
- * fcoe_interface_put()
- * @fcoe:
+ * 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)
 {
@@ -319,15 +445,16 @@ static inline void fcoe_interface_put(struct fcoe_interface *fcoe)
 }
 
 /**
- * fcoe_fip_recv - handle a received FIP frame.
- * @skb: the receive skb
- * @dev: associated &net_device
- * @ptype: the &packet_type structure which was used to register this handler.
- * @orig_dev: original receive &net_device, in case @dev is a bond.
+ * fcoe_fip_recv() - Handler for received FIP frames
+ * @skb:      The receive skb
+ * @netdev:   The associated net device
+ * @ptype:    The packet_type structure which was used to register this handler
+ * @orig_dev: The original net_device the the skb was received on.
+ *            (in case dev is a bond)
  *
  * Returns: 0 for success
  */
-static int fcoe_fip_recv(struct sk_buff *skb, struct net_device *dev,
+static int fcoe_fip_recv(struct sk_buff *skb, struct net_device *netdev,
                          struct packet_type *ptype,
                          struct net_device *orig_dev)
 {
@@ -339,9 +466,9 @@ static int fcoe_fip_recv(struct sk_buff *skb, struct net_device *dev,
 }
 
 /**
- * fcoe_fip_send() - send an Ethernet-encapsulated FIP frame.
- * @fip: FCoE controller.
- * @skb: FIP Packet.
+ * fcoe_fip_send() - Send an Ethernet-encapsulated FIP frame
+ * @fip: The FCoE controller
+ * @skb: The FIP packet to be sent
  */
 static void fcoe_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
 {
@@ -350,88 +477,118 @@ static void fcoe_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
 }
 
 /**
- * fcoe_update_src_mac() - Update Ethernet MAC filters.
- * @fip: FCoE controller.
- * @old: Unicast MAC address to delete if the MAC is non-zero.
- * @new: Unicast MAC address to add.
+ * fcoe_update_src_mac() - Update the Ethernet MAC filters
+ * @lport: The local port to update the source MAC on
+ * @addr:  Unicast MAC address to add
  *
  * Remove any previously-set unicast MAC filter.
  * Add secondary FCoE MAC address filter for our OUI.
  */
-static void fcoe_update_src_mac(struct fcoe_ctlr *fip, u8 *old, u8 *new)
+static void fcoe_update_src_mac(struct fc_lport *lport, u8 *addr)
 {
-        struct fcoe_interface *fcoe;
+        struct fcoe_port *port = lport_priv(lport);
+        struct fcoe_interface *fcoe = port->fcoe;
 
-        fcoe = fcoe_from_ctlr(fip);
         rtnl_lock();
-        if (!is_zero_ether_addr(old))
-                dev_unicast_delete(fcoe->netdev, old);
-        dev_unicast_add(fcoe->netdev, new);
+        if (!is_zero_ether_addr(port->data_src_addr))
+                dev_unicast_delete(fcoe->netdev, port->data_src_addr);
+        if (!is_zero_ether_addr(addr))
+                dev_unicast_add(fcoe->netdev, addr);
+        memcpy(port->data_src_addr, addr, ETH_ALEN);
         rtnl_unlock();
 }
 
 /**
- * fcoe_lport_config() - sets up the fc_lport
- * @lp: ptr to the fc_lport
+ * fcoe_get_src_mac() - return the Ethernet source address for an lport
+ * @lport: libfc lport
+ */
+static u8 *fcoe_get_src_mac(struct fc_lport *lport)
+{
+        struct fcoe_port *port = lport_priv(lport);
+
+        return port->data_src_addr;
+}
+
+/**
+ * fcoe_lport_config() - Set up a local port
+ * @lport: The local port to be setup
  *
  * Returns: 0 for success
  */
-static int fcoe_lport_config(struct fc_lport *lp)
+static int fcoe_lport_config(struct fc_lport *lport)
 {
-        lp->link_up = 0;
-        lp->qfull = 0;
-        lp->max_retry_count = 3;
-        lp->max_rport_retry_count = 3;
-        lp->e_d_tov = 2 * 1000; /* FC-FS default */
-        lp->r_a_tov = 2 * 2 * 1000;
-        lp->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS |
-                              FCP_SPPF_RETRY | FCP_SPPF_CONF_COMPL);
-
-        fc_lport_init_stats(lp);
+        lport->link_up = 0;
+        lport->qfull = 0;
+        lport->max_retry_count = 3;
+        lport->max_rport_retry_count = 3;
+        lport->e_d_tov = 2 * 1000;      /* FC-FS default */
+        lport->r_a_tov = 2 * 2 * 1000;
+        lport->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS |
+                                 FCP_SPPF_RETRY | FCP_SPPF_CONF_COMPL);
+        lport->does_npiv = 1;
+
+        fc_lport_init_stats(lport);
 
         /* lport fc_lport related configuration */
-        fc_lport_config(lp);
+        fc_lport_config(lport);
 
         /* offload related configuration */
-        lp->crc_offload = 0;
-        lp->seq_offload = 0;
-        lp->lro_enabled = 0;
-        lp->lro_xid = 0;
-        lp->lso_max = 0;
+        lport->crc_offload = 0;
+        lport->seq_offload = 0;
+        lport->lro_enabled = 0;
+        lport->lro_xid = 0;
+        lport->lso_max = 0;
 
         return 0;
 }
 
 /**
- * fcoe_queue_timer() - fcoe queue timer
- * @lp: the fc_lport pointer
+ * fcoe_queue_timer() - The fcoe queue timer
+ * @lport: The local port
  *
  * Calls fcoe_check_wait_queue on timeout
+ */
+static void fcoe_queue_timer(ulong lport)
+{
+        fcoe_check_wait_queue((struct fc_lport *)lport, NULL);
+}
+
+/**
+ * fcoe_get_wwn() - Get the world wide name from LLD if it supports it
+ * @netdev: the associated net device
+ * @wwn: the output WWN
+ * @type: the type of WWN (WWPN or WWNN)
  *
+ * Returns: 0 for success
  */
-static void fcoe_queue_timer(ulong lp)
+static int fcoe_get_wwn(struct net_device *netdev, u64 *wwn, int type)
 {
-        fcoe_check_wait_queue((struct fc_lport *)lp, NULL);
+        const struct net_device_ops *ops = netdev->netdev_ops;
+
+        if (ops->ndo_fcoe_get_wwn)
+                return ops->ndo_fcoe_get_wwn(netdev, wwn, type);
+        return -EINVAL;
 }
 
 /**
- * fcoe_netdev_config() - Set up netdev for SW FCoE
- * @lp : ptr to the fc_lport
- * @netdev : ptr to the associated netdevice struct
+ * fcoe_netdev_config() - Set up net devive for SW FCoE
+ * @lport:  The local port that is associated with the net device
+ * @netdev: The associated net device
  *
- * Must be called after fcoe_lport_config() as it will use lport mutex
+ * Must be called after fcoe_lport_config() as it will use local port mutex
  *
- * Returns : 0 for success
+ * Returns: 0 for success
  */
-static int fcoe_netdev_config(struct fc_lport *lp, struct net_device *netdev)
+static int fcoe_netdev_config(struct fc_lport *lport, struct net_device *netdev)
 {
         u32 mfs;
         u64 wwnn, wwpn;
         struct fcoe_interface *fcoe;
         struct fcoe_port *port;
+        int vid = 0;
 
         /* Setup lport private data to point to fcoe softc */
-        port = lport_priv(lp);
+        port = lport_priv(lport);
         fcoe = port->fcoe;
 
         /*
@@ -439,86 +596,116 @@ static int fcoe_netdev_config(struct fc_lport *lp, struct net_device *netdev)
          * user-configured limit.  If the MFS is too low, fcoe_link_ok()
          * will return 0, so do this first.
          */
-        mfs = netdev->mtu - (sizeof(struct fcoe_hdr) +
-                             sizeof(struct fcoe_crc_eof));
-        if (fc_set_mfs(lp, mfs))
+        mfs = netdev->mtu;
+        if (netdev->features & NETIF_F_FCOE_MTU) {
+                mfs = FCOE_MTU;
+                FCOE_NETDEV_DBG(netdev, "Supports FCOE_MTU of %d bytes\n", mfs);
+        }
+        mfs -= (sizeof(struct fcoe_hdr) + sizeof(struct fcoe_crc_eof));
+        if (fc_set_mfs(lport, mfs))
                 return -EINVAL;
 
         /* offload features support */
         if (netdev->features & NETIF_F_SG)
-                lp->sg_supp = 1;
+                lport->sg_supp = 1;
 
         if (netdev->features & NETIF_F_FCOE_CRC) {
-                lp->crc_offload = 1;
+                lport->crc_offload = 1;
                 FCOE_NETDEV_DBG(netdev, "Supports FCCRC offload\n");
         }
         if (netdev->features & NETIF_F_FSO) {
-                lp->seq_offload = 1;
-                lp->lso_max = netdev->gso_max_size;
+                lport->seq_offload = 1;
+                lport->lso_max = netdev->gso_max_size;
                 FCOE_NETDEV_DBG(netdev, "Supports LSO for max len 0x%x\n",
-                                lp->lso_max);
+                                lport->lso_max);
         }
         if (netdev->fcoe_ddp_xid) {
-                lp->lro_enabled = 1;
-                lp->lro_xid = netdev->fcoe_ddp_xid;
+                lport->lro_enabled = 1;
+                lport->lro_xid = netdev->fcoe_ddp_xid;
                 FCOE_NETDEV_DBG(netdev, "Supports LRO for max xid 0x%x\n",
-                                lp->lro_xid);
+                                lport->lro_xid);
         }
         skb_queue_head_init(&port->fcoe_pending_queue);
         port->fcoe_pending_queue_active = 0;
-        setup_timer(&port->timer, fcoe_queue_timer, (unsigned long)lp);
+        setup_timer(&port->timer, fcoe_queue_timer, (unsigned long)lport);
 
-        wwnn = fcoe_wwn_from_mac(netdev->dev_addr, 1, 0);
-        fc_set_wwnn(lp, wwnn);
-        /* XXX - 3rd arg needs to be vlan id */
-        wwpn = fcoe_wwn_from_mac(netdev->dev_addr, 2, 0);
-        fc_set_wwpn(lp, wwpn);
+        if (!lport->vport) {
+                /*
+                 * Use NAA 1&2 (FC-FS Rev. 2.0, Sec. 15) to generate WWNN/WWPN:
+                 * For WWNN, we use NAA 1 w/ bit 27-16 of word 0 as 0.
+                 * For WWPN, we use NAA 2 w/ bit 27-16 of word 0 from VLAN ID
+                 */
+                if (netdev->priv_flags & IFF_802_1Q_VLAN)
+                        vid = vlan_dev_vlan_id(netdev);
+
+                if (fcoe_get_wwn(netdev, &wwnn, NETDEV_FCOE_WWNN))
+                        wwnn = fcoe_wwn_from_mac(fcoe->ctlr.ctl_src_addr, 1, 0);
+                fc_set_wwnn(lport, wwnn);
+                if (fcoe_get_wwn(netdev, &wwpn, NETDEV_FCOE_WWPN))
+                        wwpn = fcoe_wwn_from_mac(fcoe->ctlr.ctl_src_addr,
+                                                 2, vid);
+                fc_set_wwpn(lport, wwpn);
+        }
 
         return 0;
 }
 
 /**
- * fcoe_shost_config() - Sets up fc_lport->host
- * @lp : ptr to the fc_lport
- * @shost : ptr to the associated scsi host
- * @dev : device associated to scsi host
+ * fcoe_shost_config() - Set up the SCSI host associated with a local port
+ * @lport: The local port
+ * @shost: The SCSI host to associate with the local port
+ * @dev:   The device associated with the SCSI host
  *
  * Must be called after fcoe_lport_config() and fcoe_netdev_config()
  *
- * Returns : 0 for success
+ * Returns: 0 for success
  */
-static int fcoe_shost_config(struct fc_lport *lp, struct Scsi_Host *shost,
-                                struct device *dev)
+static int fcoe_shost_config(struct fc_lport *lport, struct Scsi_Host *shost,
+                             struct device *dev)
 {
         int rc = 0;
 
         /* lport scsi host config */
-        lp->host = shost;
-
-        lp->host->max_lun = FCOE_MAX_LUN;
-        lp->host->max_id = FCOE_MAX_FCP_TARGET;
-        lp->host->max_channel = 0;
-        lp->host->transportt = scsi_transport_fcoe_sw;
+        lport->host->max_lun = FCOE_MAX_LUN;
+        lport->host->max_id = FCOE_MAX_FCP_TARGET;
+        lport->host->max_channel = 0;
+        if (lport->vport)
+                lport->host->transportt = fcoe_vport_transport_template;
+        else
+                lport->host->transportt = fcoe_transport_template;
 
         /* add the new host to the SCSI-ml */
-        rc = scsi_add_host(lp->host, dev);
+        rc = scsi_add_host(lport->host, dev);
         if (rc) {
-                FCOE_NETDEV_DBG(fcoe_netdev(lp), "fcoe_shost_config: "
+                FCOE_NETDEV_DBG(fcoe_netdev(lport), "fcoe_shost_config: "
                                 "error on scsi_add_host\n");
                 return rc;
         }
-        sprintf(fc_host_symbolic_name(lp->host), "%s v%s over %s",
-                FCOE_NAME, FCOE_VERSION,
-                fcoe_netdev(lp)->name);
+
+        if (!lport->vport)
+                fc_host_max_npiv_vports(lport->host) = USHORT_MAX;
+
+        snprintf(fc_host_symbolic_name(lport->host), FC_SYMBOLIC_NAME_SIZE,
+                 "%s v%s over %s", FCOE_NAME, FCOE_VERSION,
+                 fcoe_netdev(lport)->name);
 
         return 0;
 }
 
-/*
- * fcoe_oem_match() - match for read types IO
- * @fp: the fc_frame for new IO.
+/**
+ * fcoe_oem_match() - The match routine for the offloaded exchange manager
+ * @fp: The I/O frame
+ *
+ * This routine will be associated with an exchange manager (EM). When
+ * the libfc exchange handling code is looking for an EM to use it will
+ * call this routine and pass it the frame that it wishes to send. This
+ * routine will return True if the associated EM is to be used and False
+ * if the echange code should continue looking for an EM.
+ *
+ * The offload EM that this routine is associated with will handle any
+ * packets that are for SCSI read requests.
  *
- * Returns : true for read types IO, otherwise returns false.
+ * Returns: True for read types I/O, otherwise returns false.
  */
 bool fcoe_oem_match(struct fc_frame *fp)
 {
@@ -527,14 +714,14 @@ bool fcoe_oem_match(struct fc_frame *fp)
 }
 
 /**
- * fcoe_em_config() - allocates em for this lport
- * @lp: the fcoe that em is to allocated for
+ * fcoe_em_config() - Allocate and configure an exchange manager
+ * @lport: The local port that the new EM will be associated with
  *
- * Returns : 0 on success
+ * Returns: 0 on success
  */
-static inline int fcoe_em_config(struct fc_lport *lp)
+static inline int fcoe_em_config(struct fc_lport *lport)
 {
-        struct fcoe_port *port = lport_priv(lp);
+        struct fcoe_port *port = lport_priv(lport);
         struct fcoe_interface *fcoe = port->fcoe;
         struct fcoe_interface *oldfcoe = NULL;
         struct net_device *old_real_dev, *cur_real_dev;
@@ -545,8 +732,9 @@ static inline int fcoe_em_config(struct fc_lport *lp)
          * Check if need to allocate an em instance for
          * offload exchange ids to be shared across all VN_PORTs/lport.
          */
-        if (!lp->lro_enabled || !lp->lro_xid || (lp->lro_xid >= max_xid)) {
-                lp->lro_xid = 0;
+        if (!lport->lro_enabled || !lport->lro_xid ||
+            (lport->lro_xid >= max_xid)) {
+                lport->lro_xid = 0;
                 goto skip_oem;
         }
 
@@ -572,16 +760,16 @@ static inline int fcoe_em_config(struct fc_lport *lp)
         }
 
         if (fcoe->oem) {
-                if (!fc_exch_mgr_add(lp, fcoe->oem, fcoe_oem_match)) {
+                if (!fc_exch_mgr_add(lport, fcoe->oem, fcoe_oem_match)) {
                         printk(KERN_ERR "fcoe_em_config: failed to add "
                                "offload em:%p on interface:%s\n",
                                fcoe->oem, fcoe->netdev->name);
                         return -ENOMEM;
                 }
         } else {
-                fcoe->oem = fc_exch_mgr_alloc(lp, FC_CLASS_3,
-                                            FCOE_MIN_XID, lp->lro_xid,
-                                            fcoe_oem_match);
+                fcoe->oem = fc_exch_mgr_alloc(lport, FC_CLASS_3,
+                                              FCOE_MIN_XID, lport->lro_xid,
+                                              fcoe_oem_match);
                 if (!fcoe->oem) {
                         printk(KERN_ERR "fcoe_em_config: failed to allocate "
                                "em for offload exches on interface:%s\n",
@@ -593,10 +781,10 @@ static inline int fcoe_em_config(struct fc_lport *lp)
         /*
          * Exclude offload EM xid range from next EM xid range.
          */
-        min_xid += lp->lro_xid + 1;
+        min_xid += lport->lro_xid + 1;
 
 skip_oem:
-        if (!fc_exch_mgr_alloc(lp, FC_CLASS_3, min_xid, max_xid, NULL)) {
+        if (!fc_exch_mgr_alloc(lport, FC_CLASS_3, min_xid, max_xid, NULL)) {
                 printk(KERN_ERR "fcoe_em_config: failed to "
                        "allocate em on interface %s\n", fcoe->netdev->name);
                 return -ENOMEM;
@@ -606,8 +794,8 @@ skip_oem:
 }
 
 /**
- * fcoe_if_destroy() - FCoE software HBA tear-down function
- * @lport: fc_lport to destroy
+ * fcoe_if_destroy() - Tear down a SW FCoE instance
+ * @lport: The local port to be destroyed
  */
 static void fcoe_if_destroy(struct fc_lport *lport)
 {
@@ -630,6 +818,11 @@ static void fcoe_if_destroy(struct fc_lport *lport)
         /* Free existing transmit skbs */
         fcoe_clean_pending_queue(lport);
 
+        rtnl_lock();
+        if (!is_zero_ether_addr(port->data_src_addr))
+                dev_unicast_delete(netdev, port->data_src_addr);
+        rtnl_unlock();
+
         /* receives may not be stopped until after this */
         fcoe_interface_put(fcoe);
 
@@ -650,82 +843,89 @@ static void fcoe_if_destroy(struct fc_lport *lport)
         scsi_host_put(lport->host);
 }
 
-/*
- * fcoe_ddp_setup - calls LLD's ddp_setup through net_device
- * @lp: the corresponding fc_lport
- * @xid: the exchange id for this ddp transfer
- * @sgl: the scatterlist describing this transfer
- * @sgc: number of sg items
+/**
+ * fcoe_ddp_setup() - Call a LLD's ddp_setup through the net device
+ * @lport: The local port to setup DDP for
+ * @xid:   The exchange ID for this DDP transfer
+ * @sgl:   The scatterlist describing this transfer
+ * @sgc:   The number of sg items
  *
- * Returns : 0 no ddp
+ * Returns: 0 if the DDP context was not configured
  */
-static int fcoe_ddp_setup(struct fc_lport *lp, u16 xid,
-                             struct scatterlist *sgl, unsigned int sgc)
+static int fcoe_ddp_setup(struct fc_lport *lport, u16 xid,
+                          struct scatterlist *sgl, unsigned int sgc)
 {
-        struct net_device *n = fcoe_netdev(lp);
+        struct net_device *netdev = fcoe_netdev(lport);
 
-        if (n->netdev_ops && n->netdev_ops->ndo_fcoe_ddp_setup)
-                return n->netdev_ops->ndo_fcoe_ddp_setup(n, xid, sgl, sgc);
+        if (netdev->netdev_ops->ndo_fcoe_ddp_setup)
+                return netdev->netdev_ops->ndo_fcoe_ddp_setup(netdev,
+                                                              xid, sgl,
+                                                              sgc);
 
         return 0;
 }
 
-/*
- * fcoe_ddp_done - calls LLD's ddp_done through net_device
- * @lp: the corresponding fc_lport
- * @xid: the exchange id for this ddp transfer
+/**
+ * fcoe_ddp_done() - Call a LLD's ddp_done through the net device
+ * @lport: The local port to complete DDP on
+ * @xid:   The exchange ID for this DDP transfer
  *
- * Returns : the length of data that have been completed by ddp
+ * Returns: the length of data that have been completed by DDP
  */
-static int fcoe_ddp_done(struct fc_lport *lp, u16 xid)
+static int fcoe_ddp_done(struct fc_lport *lport, u16 xid)
 {
-        struct net_device *n = fcoe_netdev(lp);
+        struct net_device *netdev = fcoe_netdev(lport);
 
-        if (n->netdev_ops && n->netdev_ops->ndo_fcoe_ddp_done)
-                return n->netdev_ops->ndo_fcoe_ddp_done(n, xid);
+        if (netdev->netdev_ops->ndo_fcoe_ddp_done)
+                return netdev->netdev_ops->ndo_fcoe_ddp_done(netdev, xid);
         return 0;
 }
 
-static struct libfc_function_template fcoe_libfc_fcn_templ = {
-        .frame_send = fcoe_xmit,
-        .ddp_setup = fcoe_ddp_setup,
-        .ddp_done = fcoe_ddp_done,
-};
-
 /**
- * fcoe_if_create() - this function creates the fcoe port
- * @fcoe: fcoe_interface structure to create an fc_lport instance on
- * @parent: device pointer to be the parent in sysfs for the SCSI host
+ * fcoe_if_create() - Create a FCoE instance on an interface
+ * @fcoe:   The FCoE interface to create a local port on
+ * @parent: The device pointer to be the parent in sysfs for the SCSI host
+ * @npiv:   Indicates if the port is a vport or not
  *
- * Creates fc_lport struct and scsi_host for lport, configures lport.
+ * Creates a fc_lport instance and a Scsi_Host instance and configure them.
  *
- * Returns : The allocated fc_lport or an error pointer
+ * Returns: The allocated fc_lport or an error pointer
  */
 static struct fc_lport *fcoe_if_create(struct fcoe_interface *fcoe,
-                                       struct device *parent)
+                                       struct device *parent, int npiv)
 {
-        int rc;
+        struct net_device *netdev = fcoe->netdev;
         struct fc_lport *lport = NULL;
         struct fcoe_port *port;
         struct Scsi_Host *shost;
-        struct net_device *netdev = fcoe->netdev;
+        int rc;
+        /*
+         * parent is only a vport if npiv is 1,
+         * but we'll only use vport in that case so go ahead and set it
+         */
+        struct fc_vport *vport = dev_to_vport(parent);
 
         FCOE_NETDEV_DBG(netdev, "Create Interface\n");
 
-        shost = libfc_host_alloc(&fcoe_shost_template,
-                                 sizeof(struct fcoe_port));
-        if (!shost) {
+        if (!npiv) {
+                lport = libfc_host_alloc(&fcoe_shost_template,
+                                         sizeof(struct fcoe_port));
+        } else  {
+                lport = libfc_vport_create(vport,
+                                           sizeof(struct fcoe_port));
+        }
+        if (!lport) {
                 FCOE_NETDEV_DBG(netdev, "Could not allocate host structure\n");
                 rc = -ENOMEM;
                 goto out;
         }
-        lport = shost_priv(shost);
+        shost = lport->host;
         port = lport_priv(lport);
         port->lport = lport;
         port->fcoe = fcoe;
         INIT_WORK(&port->destroy_work, fcoe_destroy_work);
 
-        /* configure fc_lport, e.g., em */
+        /* configure a fc_lport including the exchange manager */
         rc = fcoe_lport_config(lport);
         if (rc) {
                 FCOE_NETDEV_DBG(netdev, "Could not configure lport for the "
@@ -733,6 +933,13 @@ static struct fc_lport *fcoe_if_create(struct fcoe_interface *fcoe,
                 goto out_host_put;
         }
 
+        if (npiv) {
+                FCOE_NETDEV_DBG(netdev, "Setting vport names, 0x%llX 0x%llX\n",
+                                vport->node_name, vport->port_name);
+                fc_set_wwnn(lport, vport->node_name);
+                fc_set_wwpn(lport, vport->port_name);
+        }
+
         /* configure lport network properties */
         rc = fcoe_netdev_config(lport, netdev);
         if (rc) {
@@ -757,21 +964,24 @@ static struct fc_lport *fcoe_if_create(struct fcoe_interface *fcoe,
                 goto out_lp_destroy;
         }
 
-        /*
-         * fcoe_em_alloc() and fcoe_hostlist_add() both
-         * need to be atomic with respect to other changes to the hostlist
-         * since fcoe_em_alloc() looks for an existing EM
-         * instance on host list updated by fcoe_hostlist_add().
-         *
-         * This is currently handled through the fcoe_config_mutex begin held.
-         */
+        if (!npiv) {
+                /*
+                 * fcoe_em_alloc() and fcoe_hostlist_add() both
+                 * need to be atomic with respect to other changes to the
+                 * hostlist since fcoe_em_alloc() looks for an existing EM
+                 * instance on host list updated by fcoe_hostlist_add().
+                 *
+                 * This is currently handled through the fcoe_config_mutex
+                 * begin held.
+                 */
 
-        /* lport exch manager allocation */
-        rc = fcoe_em_config(lport);
-        if (rc) {
-                FCOE_NETDEV_DBG(netdev, "Could not configure the EM for the "
-                                "interface\n");
-                goto out_lp_destroy;
+                /* lport exch manager allocation */
+                rc = fcoe_em_config(lport);
+                if (rc) {
+                        FCOE_NETDEV_DBG(netdev, "Could not configure the EM "
+                                        "for the interface\n");
+                        goto out_lp_destroy;
+                }
         }
 
         fcoe_interface_get(fcoe);
@@ -786,17 +996,20 @@ out:
 }
 
 /**
- * fcoe_if_init() - attach to scsi transport
+ * fcoe_if_init() - Initialization routine for fcoe.ko
  *
- * Returns : 0 on success
+ * Attaches the SW FCoE transport to the FC transport
+ *
+ * Returns: 0 on success
  */
 static int __init fcoe_if_init(void)
 {
         /* attach to scsi transport */
-        scsi_transport_fcoe_sw =
-                fc_attach_transport(&fcoe_transport_function);
+        fcoe_transport_template = fc_attach_transport(&fcoe_transport_function);
+        fcoe_vport_transport_template =
+                fc_attach_transport(&fcoe_vport_transport_function);
 
-        if (!scsi_transport_fcoe_sw) {
+        if (!fcoe_transport_template) {
                 printk(KERN_ERR "fcoe: Failed to attach to the FC transport\n");
                 return -ENODEV;
         }
@@ -805,20 +1018,24 @@ static int __init fcoe_if_init(void)
 }
 
 /**
- * fcoe_if_exit() - detach from scsi transport
+ * fcoe_if_exit() - Tear down fcoe.ko
+ *
+ * Detaches the SW FCoE transport from the FC transport
  *
- * Returns : 0 on success
+ * Returns: 0 on success
  */
 int __exit fcoe_if_exit(void)
 {
-        fc_release_transport(scsi_transport_fcoe_sw);
-        scsi_transport_fcoe_sw = NULL;
+        fc_release_transport(fcoe_transport_template);
+        fc_release_transport(fcoe_vport_transport_template);
+        fcoe_transport_template = NULL;
+        fcoe_vport_transport_template = NULL;
         return 0;
 }
 
 /**
- * fcoe_percpu_thread_create() - Create a receive thread for an online cpu
- * @cpu: cpu index for the online cpu
+ * fcoe_percpu_thread_create() - Create a receive thread for an online CPU
+ * @cpu: The CPU index of the CPU to create a receive thread for
  */
 static void fcoe_percpu_thread_create(unsigned int cpu)
 {
@@ -841,8 +1058,8 @@ static void fcoe_percpu_thread_create(unsigned int cpu)
 }
 
 /**
- * fcoe_percpu_thread_destroy() - removes the rx thread for the given cpu
- * @cpu: cpu index the rx thread is to be removed
+ * fcoe_percpu_thread_destroy() - Remove the receive thread of a CPU
+ * @cpu: The CPU index of the CPU whose receive thread is to be destroyed
  *
  * Destroys a per-CPU Rx thread. Any pending skbs are moved to the
  * current CPU's Rx thread. If the thread being destroyed is bound to
@@ -890,7 +1107,7 @@ static void fcoe_percpu_thread_destroy(unsigned int cpu)
                 } else {
                         /*
                          * The targeted CPU is not initialized and cannot accept
-                         * new  skbs. Unlock the targeted CPU and drop the skbs
+                         * new  skbs. Unlock the targeted CPU and drop the skbs
                          * on the CPU that is going offline.
                          */
                         while ((skb = __skb_dequeue(&p->fcoe_rx_list)) != NULL)
@@ -931,12 +1148,12 @@ static void fcoe_percpu_thread_destroy(unsigned int cpu)
 }
 
 /**
- * fcoe_cpu_callback() - fcoe cpu hotplug event callback
- * @nfb: callback data block
- * @action: event triggering the callback
- * @hcpu: index for the cpu of this event
+ * fcoe_cpu_callback() - Handler for CPU hotplug events
+ * @nfb:    The callback data block
+ * @action: The event triggering the callback
+ * @hcpu:   The index of the CPU that the event is for
  *
- * This creates or destroys per cpu data for fcoe
+ * This creates or destroys per-CPU data for fcoe
  *
  * Returns NOTIFY_OK always.
  */
@@ -962,25 +1179,22 @@ static int fcoe_cpu_callback(struct notifier_block *nfb,
         return NOTIFY_OK;
 }
 
-static struct notifier_block fcoe_cpu_notifier = {
-        .notifier_call = fcoe_cpu_callback,
-};
-
 /**
- * fcoe_rcv() - this is the fcoe receive function called by NET_RX_SOFTIRQ
- * @skb: the receive skb
- * @dev: associated net device
- * @ptype: context
- * @olddev: last device
+ * fcoe_rcv() - Receive packets from a net device
+ * @skb:    The received packet
+ * @netdev: The net device that the packet was received on
+ * @ptype:  The packet type context
+ * @olddev: The last device net device
  *
- * this function will receive the packet and build fc frame and pass it up
+ * This routine is called by NET_RX_SOFTIRQ. It receives a packet, builds a
+ * FC frame and passes the frame to libfc.
  *
  * Returns: 0 for success
  */
-int fcoe_rcv(struct sk_buff *skb, struct net_device *dev,
+int fcoe_rcv(struct sk_buff *skb, struct net_device *netdev,
              struct packet_type *ptype, struct net_device *olddev)
 {
-        struct fc_lport *lp;
+        struct fc_lport *lport;
         struct fcoe_rcv_info *fr;
         struct fcoe_interface *fcoe;
         struct fc_frame_header *fh;
@@ -988,15 +1202,15 @@ int fcoe_rcv(struct sk_buff *skb, struct net_device *dev,
         unsigned int cpu;
 
         fcoe = container_of(ptype, struct fcoe_interface, fcoe_packet_type);
-        lp = fcoe->ctlr.lp;
-        if (unlikely(lp == NULL)) {
-                FCOE_NETDEV_DBG(dev, "Cannot find hba structure");
+        lport = fcoe->ctlr.lp;
+        if (unlikely(!lport)) {
+                FCOE_NETDEV_DBG(netdev, "Cannot find hba structure");
                 goto err2;
         }
-        if (!lp->link_up)
+        if (!lport->link_up)
                 goto err2;
 
-        FCOE_NETDEV_DBG(dev, "skb_info: len:%d data_len:%d head:%p "
+        FCOE_NETDEV_DBG(netdev, "skb_info: len:%d data_len:%d head:%p "
                         "data:%p tail:%p end:%p sum:%d dev:%s",
                         skb->len, skb->data_len, skb->head, skb->data,
                         skb_tail_pointer(skb), skb_end_pointer(skb),
@@ -1004,7 +1218,7 @@ int fcoe_rcv(struct sk_buff *skb, struct net_device *dev,
 
         /* check for FCOE packet type */
         if (unlikely(eth_hdr(skb)->h_proto != htons(ETH_P_FCOE))) {
-                FCOE_NETDEV_DBG(dev, "Wrong FC type frame");
+                FCOE_NETDEV_DBG(netdev, "Wrong FC type frame");
                 goto err;
         }
 
@@ -1013,14 +1227,14 @@ int fcoe_rcv(struct sk_buff *skb, struct net_device *dev,
          * and FC headers are pulled into the linear data area.
          */
         if (unlikely((skb->len < FCOE_MIN_FRAME) ||
-            !pskb_may_pull(skb, FCOE_HEADER_LEN)))
+                     !pskb_may_pull(skb, FCOE_HEADER_LEN)))
                 goto err;
 
         skb_set_transport_header(skb, sizeof(struct fcoe_hdr));
         fh = (struct fc_frame_header *) skb_transport_header(skb);
 
         fr = fcoe_dev_from_skb(skb);
-        fr->fr_dev = lp;
+        fr->fr_dev = lport;
         fr->ptype = ptype;
 
         /*
@@ -1042,12 +1256,12 @@ int fcoe_rcv(struct sk_buff *skb, struct net_device *dev,
                  * the first CPU now. For non-SMP systems this
                  * will check the same CPU twice.
                  */
-                FCOE_NETDEV_DBG(dev, "CPU is online, but no receive thread "
+                FCOE_NETDEV_DBG(netdev, "CPU is online, but no receive thread "
                                 "ready for incoming skb- using first online "
                                 "CPU.\n");
 
                 spin_unlock_bh(&fps->fcoe_rx_list.lock);
-                cpu = first_cpu(cpu_online_map);
+                cpu = cpumask_first(cpu_online_mask);
                 fps = &per_cpu(fcoe_percpu, cpu);
                 spin_lock_bh(&fps->fcoe_rx_list.lock);
                 if (!fps->thread) {
@@ -1061,15 +1275,29 @@ int fcoe_rcv(struct sk_buff *skb, struct net_device *dev,
          * this skb. We also have this receive thread locked,
          * so we're free to queue skbs into it's queue.
          */
-        __skb_queue_tail(&fps->fcoe_rx_list, skb);
-        if (fps->fcoe_rx_list.qlen == 1)
-                wake_up_process(fps->thread);
 
-        spin_unlock_bh(&fps->fcoe_rx_list.lock);
+        /* If this is a SCSI-FCP frame, and this is already executing on the
+         * correct CPU, and the queue for this CPU is empty, then go ahead
+         * and process the frame directly in the softirq context.
+         * This lets us process completions without context switching from the
+         * NET_RX softirq, to our receive processing thread, and then back to
+         * BLOCK softirq context.
+         */
+        if (fh->fh_type == FC_TYPE_FCP &&
+            cpu == smp_processor_id() &&
+            skb_queue_empty(&fps->fcoe_rx_list)) {
+                spin_unlock_bh(&fps->fcoe_rx_list.lock);
+                fcoe_recv_frame(skb);
+        } else {
+                __skb_queue_tail(&fps->fcoe_rx_list, skb);
+                if (fps->fcoe_rx_list.qlen == 1)
+                        wake_up_process(fps->thread);
+                spin_unlock_bh(&fps->fcoe_rx_list.lock);
+        }
 
         return 0;
 err:
-        fc_lport_get_stats(lp)->ErrorFrames++;
+        fc_lport_get_stats(lport)->ErrorFrames++;
 
 err2:
         kfree_skb(skb);
@@ -1077,17 +1305,21 @@ err2:
 }
 
 /**
- * fcoe_start_io() - pass to netdev to start xmit for fcoe
- * @skb: the skb to be xmitted
+ * fcoe_start_io() - Start FCoE I/O
+ * @skb: The packet to be transmitted
+ *
+ * This routine is called from the net device to start transmitting
+ * FCoE packets.
  *
  * Returns: 0 for success
  */
 static inline int fcoe_start_io(struct sk_buff *skb)
 {
+        struct sk_buff *nskb;
         int rc;
 
-        skb_get(skb);
-        rc = dev_queue_xmit(skb);
+        nskb = skb_clone(skb, GFP_ATOMIC);
+        rc = dev_queue_xmit(nskb);
         if (rc != 0)
                 return rc;
         kfree_skb(skb);
@@ -1095,9 +1327,15 @@ static inline int fcoe_start_io(struct sk_buff *skb)
 }
 
 /**
- * fcoe_get_paged_crc_eof() - in case we need to alloc a page for crc_eof
- * @skb: the skb to be xmitted
- * @tlen: total len
+ * fcoe_get_paged_crc_eof() - Allocate a page to be used for the trailer CRC
+ * @skb:  The packet to be transmitted
+ * @tlen: The total length of the trailer
+ *
+ * This routine allocates a page for frame trailers. The page is re-used if
+ * there is enough room left on it for the current trailer. If there isn't
+ * enough buffer left a new page is allocated for the trailer. Reference to
+ * the page from this function as well as the skbs using the page fragments
+ * ensure that the page is freed at the appropriate time.
  *
  * Returns: 0 for success
  */
@@ -1136,11 +1374,12 @@ static int fcoe_get_paged_crc_eof(struct sk_buff *skb, int tlen)
 }
 
 /**
- * fcoe_fc_crc() - calculates FC CRC in this fcoe skb
- * @fp: the fc_frame containing data to be checksummed
+ * fcoe_fc_crc() - Calculates the CRC for a given frame
+ * @fp: The frame to be checksumed
  *
- * This uses crc32() to calculate the crc for port frame
- * Return   : 32 bit crc
+ * This uses crc32() routine to calculate the CRC for a frame
+ *
+ * Return: The 32 bit CRC value
  */
 u32 fcoe_fc_crc(struct fc_frame *fp)
 {
@@ -1171,13 +1410,13 @@ u32 fcoe_fc_crc(struct fc_frame *fp)
 }
 
 /**
- * fcoe_xmit() - FCoE frame transmit function
- * @lp: the associated local fcoe
- * @fp: the fc_frame to be transmitted
+ * fcoe_xmit() - Transmit a FCoE frame
+ * @lport: The local port that the frame is to be transmitted for
+ * @fp:    The frame to be transmitted
  *
- * Return   : 0 for success
+ * Return: 0 for success
  */
-int fcoe_xmit(struct fc_lport *lp, struct fc_frame *fp)
+int fcoe_xmit(struct fc_lport *lport, struct fc_frame *fp)
 {
         int wlen;
         u32 crc;
@@ -1189,7 +1428,7 @@ int fcoe_xmit(struct fc_lport *lp, struct fc_frame *fp)
         unsigned int hlen;              /* header length implies the version */
         unsigned int tlen;              /* trailer length */
         unsigned int elen;              /* eth header, may include vlan */
-        struct fcoe_port *port = lport_priv(lp);
+        struct fcoe_port *port = lport_priv(lport);
         struct fcoe_interface *fcoe = port->fcoe;
         u8 sof, eof;
         struct fcoe_hdr *hp;
@@ -1200,13 +1439,13 @@ int fcoe_xmit(struct fc_lport *lp, struct fc_frame *fp)
         skb = fp_skb(fp);
         wlen = skb->len / FCOE_WORD_TO_BYTE;
 
-        if (!lp->link_up) {
+        if (!lport->link_up) {
                 kfree_skb(skb);
                 return 0;
         }
 
         if (unlikely(fh->fh_r_ctl == FC_RCTL_ELS_REQ) &&
-            fcoe_ctlr_els_send(&fcoe->ctlr, skb))
+            fcoe_ctlr_els_send(&fcoe->ctlr, lport, skb))
                 return 0;
 
         sof = fr_sof(fp);
@@ -1218,7 +1457,7 @@ int fcoe_xmit(struct fc_lport *lp, struct fc_frame *fp)
         wlen = (skb->len - tlen + sizeof(crc)) / FCOE_WORD_TO_BYTE;
 
         /* crc offload */
-        if (likely(lp->crc_offload)) {
+        if (likely(lport->crc_offload)) {
                 skb->ip_summed = CHECKSUM_PARTIAL;
                 skb->csum_start = skb_headroom(skb);
                 skb->csum_offset = skb->len;
@@ -1271,7 +1510,7 @@ int fcoe_xmit(struct fc_lport *lp, struct fc_frame *fp)
         if (unlikely(fcoe->ctlr.flogi_oxid != FC_XID_UNKNOWN))
                 memcpy(eh->h_source, fcoe->ctlr.ctl_src_addr, ETH_ALEN);
         else
-                memcpy(eh->h_source, fcoe->ctlr.data_src_addr, ETH_ALEN);
+                memcpy(eh->h_source, port->data_src_addr, ETH_ALEN);
 
         hp = (struct fcoe_hdr *)(eh + 1);
         memset(hp, 0, sizeof(*hp));
@@ -1280,7 +1519,7 @@ int fcoe_xmit(struct fc_lport *lp, struct fc_frame *fp)
         hp->fcoe_sof = sof;
 
         /* fcoe lso, mss is in max_payload which is non-zero for FCP data */
-        if (lp->seq_offload && fr_max_payload(fp)) {
+        if (lport->seq_offload && fr_max_payload(fp)) {
                 skb_shinfo(skb)->gso_type = SKB_GSO_FCOE;
                 skb_shinfo(skb)->gso_size = fr_max_payload(fp);
         } else {
@@ -1288,23 +1527,23 @@ int fcoe_xmit(struct fc_lport *lp, struct fc_frame *fp)
                 skb_shinfo(skb)->gso_size = 0;
         }
         /* update tx stats: regardless if LLD fails */
-        stats = fc_lport_get_stats(lp);
+        stats = fc_lport_get_stats(lport);
         stats->TxFrames++;
         stats->TxWords += wlen;
 
         /* send down to lld */
-        fr_dev(fp) = lp;
+        fr_dev(fp) = lport;
         if (port->fcoe_pending_queue.qlen)
-                fcoe_check_wait_queue(lp, skb);
+                fcoe_check_wait_queue(lport, skb);
         else if (fcoe_start_io(skb))
-                fcoe_check_wait_queue(lp, skb);
+                fcoe_check_wait_queue(lport, skb);
 
         return 0;
 }
 
 /**
- * fcoe_percpu_flush_done() - Indicate percpu queue flush completion.
- * @skb: the skb being completed.
+ * fcoe_percpu_flush_done() - Indicate per-CPU queue flush completion
+ * @skb: The completed skb (argument required by destructor)
  */
 static void fcoe_percpu_flush_done(struct sk_buff *skb)
 {
@@ -1312,26 +1551,134 @@ static void fcoe_percpu_flush_done(struct sk_buff *skb)
 }
 
 /**
- * fcoe_percpu_receive_thread() - recv thread per cpu
- * @arg: ptr to the fcoe per cpu struct
- *
- * Return: 0 for success
+ * fcoe_recv_frame() - process a single received frame
+ * @skb: frame to process
  */
-int fcoe_percpu_receive_thread(void *arg)
+static void fcoe_recv_frame(struct sk_buff *skb)
 {
-        struct fcoe_percpu_s *p = arg;
         u32 fr_len;
-        struct fc_lport *lp;
+        struct fc_lport *lport;
         struct fcoe_rcv_info *fr;
         struct fcoe_dev_stats *stats;
         struct fc_frame_header *fh;
-        struct sk_buff *skb;
         struct fcoe_crc_eof crc_eof;
         struct fc_frame *fp;
         u8 *mac = NULL;
         struct fcoe_port *port;
         struct fcoe_hdr *hp;
 
+        fr = fcoe_dev_from_skb(skb);
+        lport = fr->fr_dev;
+        if (unlikely(!lport)) {
+                if (skb->destructor != fcoe_percpu_flush_done)
+                        FCOE_NETDEV_DBG(skb->dev, "NULL lport in skb");
+                kfree_skb(skb);
+                return;
+        }
+
+        FCOE_NETDEV_DBG(skb->dev, "skb_info: len:%d data_len:%d "
+                        "head:%p data:%p tail:%p end:%p sum:%d dev:%s",
+                        skb->len, skb->data_len,
+                        skb->head, skb->data, skb_tail_pointer(skb),
+                        skb_end_pointer(skb), skb->csum,
+                        skb->dev ? skb->dev->name : "<NULL>");
+
+        /*
+         * Save source MAC address before discarding header.
+         */
+        port = lport_priv(lport);
+        if (skb_is_nonlinear(skb))
+                skb_linearize(skb);     /* not ideal */
+        mac = eth_hdr(skb)->h_source;
+
+        /*
+         * Frame length checks and setting up the header pointers
+         * was done in fcoe_rcv already.
+         */
+        hp = (struct fcoe_hdr *) skb_network_header(skb);
+        fh = (struct fc_frame_header *) skb_transport_header(skb);
+
+        stats = fc_lport_get_stats(lport);
+        if (unlikely(FC_FCOE_DECAPS_VER(hp) != FC_FCOE_VER)) {
+                if (stats->ErrorFrames < 5)
+                        printk(KERN_WARNING "fcoe: FCoE version "
+                               "mismatch: The frame has "
+                               "version %x, but the "
+                               "initiator supports version "
+                               "%x\n", FC_FCOE_DECAPS_VER(hp),
+                               FC_FCOE_VER);
+                stats->ErrorFrames++;
+                kfree_skb(skb);
+                return;
+        }
+
+        skb_pull(skb, sizeof(struct fcoe_hdr));
+        fr_len = skb->len - sizeof(struct fcoe_crc_eof);
+
+        stats->RxFrames++;
+        stats->RxWords += fr_len / FCOE_WORD_TO_BYTE;
+
+        fp = (struct fc_frame *)skb;
+        fc_frame_init(fp);
+        fr_dev(fp) = lport;
+        fr_sof(fp) = hp->fcoe_sof;
+
+        /* Copy out the CRC and EOF trailer for access */
+        if (skb_copy_bits(skb, fr_len, &crc_eof, sizeof(crc_eof))) {
+                kfree_skb(skb);
+                return;
+        }
+        fr_eof(fp) = crc_eof.fcoe_eof;
+        fr_crc(fp) = crc_eof.fcoe_crc32;
+        if (pskb_trim(skb, fr_len)) {
+                kfree_skb(skb);
+                return;
+        }
+
+        /*
+         * We only check CRC if no offload is available and if it is
+         * it's solicited data, in which case, the FCP layer would
+         * check it during the copy.
+         */
+        if (lport->crc_offload &&
+            skb->ip_summed == CHECKSUM_UNNECESSARY)
+                fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
+        else
+                fr_flags(fp) |= FCPHF_CRC_UNCHECKED;
+
+        fh = fc_frame_header_get(fp);
+        if (fh->fh_r_ctl == FC_RCTL_DD_SOL_DATA &&
+            fh->fh_type == FC_TYPE_FCP) {
+                fc_exch_recv(lport, fp);
+                return;
+        }
+        if (fr_flags(fp) & FCPHF_CRC_UNCHECKED) {
+                if (le32_to_cpu(fr_crc(fp)) !=
+                    ~crc32(~0, skb->data, fr_len)) {
+                        if (stats->InvalidCRCCount < 5)
+                                printk(KERN_WARNING "fcoe: dropping "
+                                       "frame with CRC error\n");
+                        stats->InvalidCRCCount++;
+                        stats->ErrorFrames++;
+                        fc_frame_free(fp);
+                        return;
+                }
+                fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
+        }
+        fc_exch_recv(lport, fp);
+}
+
+/**
+ * fcoe_percpu_receive_thread() - The per-CPU packet receive thread
+ * @arg: The per-CPU context
+ *
+ * Return: 0 for success
+ */
+int fcoe_percpu_receive_thread(void *arg)
+{
+        struct fcoe_percpu_s *p = arg;
+        struct sk_buff *skb;
+
         set_user_nice(current, -20);
 
         while (!kthread_should_stop()) {
@@ -1347,129 +1694,27 @@ int fcoe_percpu_receive_thread(void *arg)
                         spin_lock_bh(&p->fcoe_rx_list.lock);
                 }
                 spin_unlock_bh(&p->fcoe_rx_list.lock);
-                fr = fcoe_dev_from_skb(skb);
-                lp = fr->fr_dev;
-                if (unlikely(lp == NULL)) {
-                        if (skb->destructor != fcoe_percpu_flush_done)
-                                FCOE_NETDEV_DBG(skb->dev, "NULL lport in skb");
-                        kfree_skb(skb);
-                        continue;
-                }
-
-                FCOE_NETDEV_DBG(skb->dev, "skb_info: len:%d data_len:%d "
-                                "head:%p data:%p tail:%p end:%p sum:%d dev:%s",
-                                skb->len, skb->data_len,
-                                skb->head, skb->data, skb_tail_pointer(skb),
-                                skb_end_pointer(skb), skb->csum,
-                                skb->dev ? skb->dev->name : "<NULL>");
-
-                /*
-                 * Save source MAC address before discarding header.
-                 */
-                port = lport_priv(lp);
-                if (skb_is_nonlinear(skb))
-                        skb_linearize(skb);     /* not ideal */
-                mac = eth_hdr(skb)->h_source;
-
-                /*
-                 * Frame length checks and setting up the header pointers
-                 * was done in fcoe_rcv already.
-                 */
-                hp = (struct fcoe_hdr *) skb_network_header(skb);
-                fh = (struct fc_frame_header *) skb_transport_header(skb);
-
-                stats = fc_lport_get_stats(lp);
-                if (unlikely(FC_FCOE_DECAPS_VER(hp) != FC_FCOE_VER)) {
-                        if (stats->ErrorFrames < 5)
-                                printk(KERN_WARNING "fcoe: FCoE version "
-                                       "mismatch: The frame has "
-                                       "version %x, but the "
-                                       "initiator supports version "
-                                       "%x\n", FC_FCOE_DECAPS_VER(hp),
-                                       FC_FCOE_VER);
-                        stats->ErrorFrames++;
-                        kfree_skb(skb);
-                        continue;
-                }
-
-                skb_pull(skb, sizeof(struct fcoe_hdr));
-                fr_len = skb->len - sizeof(struct fcoe_crc_eof);
-
-                stats->RxFrames++;
-                stats->RxWords += fr_len / FCOE_WORD_TO_BYTE;
-
-                fp = (struct fc_frame *)skb;
-                fc_frame_init(fp);
-                fr_dev(fp) = lp;
-                fr_sof(fp) = hp->fcoe_sof;
-
-                /* Copy out the CRC and EOF trailer for access */
-                if (skb_copy_bits(skb, fr_len, &crc_eof, sizeof(crc_eof))) {
-                        kfree_skb(skb);
-                        continue;
-                }
-                fr_eof(fp) = crc_eof.fcoe_eof;
-                fr_crc(fp) = crc_eof.fcoe_crc32;
-                if (pskb_trim(skb, fr_len)) {
-                        kfree_skb(skb);
-                        continue;
-                }
-
-                /*
-                 * We only check CRC if no offload is available and if it is
-                 * it's solicited data, in which case, the FCP layer would
-                 * check it during the copy.
-                 */
-                if (lp->crc_offload && skb->ip_summed == CHECKSUM_UNNECESSARY)
-                        fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
-                else
-                        fr_flags(fp) |= FCPHF_CRC_UNCHECKED;
-
-                fh = fc_frame_header_get(fp);
-                if (fh->fh_r_ctl == FC_RCTL_DD_SOL_DATA &&
-                    fh->fh_type == FC_TYPE_FCP) {
-                        fc_exch_recv(lp, fp);
-                        continue;
-                }
-                if (fr_flags(fp) & FCPHF_CRC_UNCHECKED) {
-                        if (le32_to_cpu(fr_crc(fp)) !=
-                            ~crc32(~0, skb->data, fr_len)) {
-                                if (stats->InvalidCRCCount < 5)
-                                        printk(KERN_WARNING "fcoe: dropping "
-                                               "frame with CRC error\n");
-                                stats->InvalidCRCCount++;
-                                stats->ErrorFrames++;
-                                fc_frame_free(fp);
-                                continue;
-                        }
-                        fr_flags(fp) &= ~FCPHF_CRC_UNCHECKED;
-                }
-                if (unlikely(port->fcoe->ctlr.flogi_oxid != FC_XID_UNKNOWN) &&
-                    fcoe_ctlr_recv_flogi(&port->fcoe->ctlr, fp, mac)) {
-                        fc_frame_free(fp);
-                        continue;
-                }
-                fc_exch_recv(lp, fp);
+                fcoe_recv_frame(skb);
         }
         return 0;
 }
 
 /**
- * fcoe_check_wait_queue() - attempt to clear the transmit backlog
- * @lp: the fc_lport
+ * fcoe_check_wait_queue() - Attempt to clear the transmit backlog
+ * @lport: The local port whose backlog is to be cleared
  *
- * This empties the wait_queue, dequeue the head of the wait_queue queue
- * and calls fcoe_start_io() for each packet, if all skb have been
- * transmitted, return qlen or -1 if a error occurs, then restore
- * wait_queue and try again later.
+ * This empties the wait_queue, dequeues the head of the wait_queue queue
+ * and calls fcoe_start_io() for each packet. If all skb have been
+ * transmitted it returns the qlen. If an error occurs it restores
+ * wait_queue (to try again later) and returns -1.
  *
- * The wait_queue is used when the skb transmit fails. skb will go
- * in the wait_queue which will be emptied by the timer function or
+ * The wait_queue is used when the skb transmit fails. The failed skb
+ * will go in the wait_queue which will be emptied by the timer function or
  * by the next skb transmit.
  */
-static void fcoe_check_wait_queue(struct fc_lport *lp, struct sk_buff *skb)
+static void fcoe_check_wait_queue(struct fc_lport *lport, struct sk_buff *skb)
 {
-        struct fcoe_port *port = lport_priv(lp);
+        struct fcoe_port *port = lport_priv(lport);
         int rc;
 
         spin_lock_bh(&port->fcoe_pending_queue.lock);
@@ -1501,19 +1746,19 @@ static void fcoe_check_wait_queue(struct fc_lport *lp, struct sk_buff *skb)
         }
 
         if (port->fcoe_pending_queue.qlen < FCOE_LOW_QUEUE_DEPTH)
-                lp->qfull = 0;
+                lport->qfull = 0;
         if (port->fcoe_pending_queue.qlen && !timer_pending(&port->timer))
                 mod_timer(&port->timer, jiffies + 2);
         port->fcoe_pending_queue_active = 0;
 out:
         if (port->fcoe_pending_queue.qlen > FCOE_MAX_QUEUE_DEPTH)
-                lp->qfull = 1;
+                lport->qfull = 1;
         spin_unlock_bh(&port->fcoe_pending_queue.lock);
         return;
 }
 
 /**
- * fcoe_dev_setup() - setup link change notification interface
+ * fcoe_dev_setup() - Setup the link change notification interface
  */
 static void fcoe_dev_setup(void)
 {
@@ -1521,7 +1766,7 @@ static void fcoe_dev_setup(void)
 }
 
 /**
- * fcoe_dev_cleanup() - cleanup link change notification interface
+ * fcoe_dev_cleanup() - Cleanup the link change notification interface
  */
 static void fcoe_dev_cleanup(void)
 {
@@ -1529,19 +1774,19 @@ static void fcoe_dev_cleanup(void)
 }
 
 /**
- * fcoe_device_notification() - netdev event notification callback
- * @notifier: context of the notification
- * @event: type of event
- * @ptr: fixed array for output parsed ifname
+ * fcoe_device_notification() - Handler for net device events
+ * @notifier: The context of the notification
+ * @event:    The type of event
+ * @ptr:      The net device that the event was on
  *
- * This function is called by the ethernet driver in case of link change event
+ * This function is called by the Ethernet driver in case of link change event.
  *
  * Returns: 0 for success
  */
 static int fcoe_device_notification(struct notifier_block *notifier,
                                     ulong event, void *ptr)
 {
-        struct fc_lport *lp = NULL;
+        struct fc_lport *lport = NULL;
         struct net_device *netdev = ptr;
         struct fcoe_interface *fcoe;
         struct fcoe_port *port;
@@ -1552,11 +1797,11 @@ static int fcoe_device_notification(struct notifier_block *notifier,
 
         list_for_each_entry(fcoe, &fcoe_hostlist, list) {
                 if (fcoe->netdev == netdev) {
-                        lp = fcoe->ctlr.lp;
+                        lport = fcoe->ctlr.lp;
                         break;
                 }
         }
-        if (lp == NULL) {
+        if (!lport) {
                 rc = NOTIFY_DONE;
                 goto out;
         }
@@ -1570,10 +1815,12 @@ static int fcoe_device_notification(struct notifier_block *notifier,
         case NETDEV_CHANGE:
                 break;
         case NETDEV_CHANGEMTU:
+                if (netdev->features & NETIF_F_FCOE_MTU)
+                        break;
                 mfs = netdev->mtu - (sizeof(struct fcoe_hdr) +
                                      sizeof(struct fcoe_crc_eof));
                 if (mfs >= FC_MIN_MAX_FRAME)
-                        fc_set_mfs(lp, mfs);
+                        fc_set_mfs(lport, mfs);
                 break;
         case NETDEV_REGISTER:
                 break;
@@ -1588,22 +1835,22 @@ static int fcoe_device_notification(struct notifier_block *notifier,
                 FCOE_NETDEV_DBG(netdev, "Unknown event %ld "
                                 "from netdev netlink\n", event);
         }
-        if (link_possible && !fcoe_link_ok(lp))
+        if (link_possible && !fcoe_link_ok(lport))
                 fcoe_ctlr_link_up(&fcoe->ctlr);
         else if (fcoe_ctlr_link_down(&fcoe->ctlr)) {
-                stats = fc_lport_get_stats(lp);
+                stats = fc_lport_get_stats(lport);
                 stats->LinkFailureCount++;
-                fcoe_clean_pending_queue(lp);
+                fcoe_clean_pending_queue(lport);
         }
 out:
         return rc;
 }
 
 /**
- * fcoe_if_to_netdev() - parse a name buffer to get netdev
- * @buffer: incoming buffer to be copied
+ * fcoe_if_to_netdev() - Parse a name buffer to get a net device
+ * @buffer: The name of the net device
  *
- * Returns: NULL or ptr to net_device
+ * Returns: NULL or a ptr to net_device
  */
 static struct net_device *fcoe_if_to_netdev(const char *buffer)
 {
@@ -1621,9 +1868,109 @@ static struct net_device *fcoe_if_to_netdev(const char *buffer)
 }
 
 /**
- * fcoe_destroy() - handles the destroy from sysfs
- * @buffer: expected to be an eth if name
- * @kp: associated kernel param
+ * fcoe_disable() - Disables a FCoE interface
+ * @buffer: The name of the Ethernet interface to be disabled
+ * @kp:     The associated kernel parameter
+ *
+ * Called from sysfs.
+ *
+ * Returns: 0 for success
+ */
+static int fcoe_disable(const char *buffer, struct kernel_param *kp)
+{
+        struct fcoe_interface *fcoe;
+        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
+
+        netdev = fcoe_if_to_netdev(buffer);
+        if (!netdev) {
+                rc = -ENODEV;
+                goto out_nodev;
+        }
+
+        rtnl_lock();
+        fcoe = fcoe_hostlist_lookup_port(netdev);
+        rtnl_unlock();
+
+        if (fcoe)
+                fc_fabric_logoff(fcoe->ctlr.lp);
+        else
+                rc = -ENODEV;
+
+        dev_put(netdev);
+out_nodev:
+        mutex_unlock(&fcoe_config_mutex);
+        return rc;
+}
+
+/**
+ * fcoe_enable() - Enables a FCoE interface
+ * @buffer: The name of the Ethernet interface to be enabled
+ * @kp:     The associated kernel parameter
+ *
+ * Called from sysfs.
+ *
+ * Returns: 0 for success
+ */
+static int fcoe_enable(const char *buffer, struct kernel_param *kp)
+{
+        struct fcoe_interface *fcoe;
+        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
+
+        netdev = fcoe_if_to_netdev(buffer);
+        if (!netdev) {
+                rc = -ENODEV;
+                goto out_nodev;
+        }
+
+        rtnl_lock();
+        fcoe = fcoe_hostlist_lookup_port(netdev);
+        rtnl_unlock();
+
+        if (fcoe)
+                rc = fc_fabric_login(fcoe->ctlr.lp);
+        else
+                rc = -ENODEV;
+
+        dev_put(netdev);
+out_nodev:
+        mutex_unlock(&fcoe_config_mutex);
+        return rc;
+}
+
+/**
+ * fcoe_destroy() - Destroy a FCoE interface
+ * @buffer: The name of the Ethernet interface to be destroyed
+ * @kp:     The associated kernel parameter
+ *
+ * Called from sysfs.
  *
  * Returns: 0 for success
  */
@@ -1631,7 +1978,7 @@ static int fcoe_destroy(const char *buffer, struct kernel_param *kp)
 {
         struct fcoe_interface *fcoe;
         struct net_device *netdev;
-        int rc;
+        int rc = 0;
 
         mutex_lock(&fcoe_config_mutex);
 #ifdef CONFIG_FCOE_MODULE
@@ -1663,6 +2010,8 @@ static int fcoe_destroy(const char *buffer, struct kernel_param *kp)
         fcoe_interface_cleanup(fcoe);
         rtnl_unlock();
         fcoe_if_destroy(fcoe->ctlr.lp);
+        module_put(THIS_MODULE);
+
 out_putdev:
         dev_put(netdev);
 out_nodev:
@@ -1670,6 +2019,10 @@ out_nodev:
         return rc;
 }
 
+/**
+ * fcoe_destroy_work() - Destroy a FCoE port in a deferred work context
+ * @work: Handle to the FCoE port to be destroyed
+ */
 static void fcoe_destroy_work(struct work_struct *work)
 {
         struct fcoe_port *port;
@@ -1681,9 +2034,11 @@ static void fcoe_destroy_work(struct work_struct *work)
 }
 
 /**
- * fcoe_create() - Handles the create call from sysfs
- * @buffer: expected to be an eth if name
- * @kp: associated kernel param
+ * fcoe_create() - Create a fcoe interface
+ * @buffer: The name of the Ethernet interface to create on
+ * @kp:     The associated kernel param
+ *
+ * Called from sysfs.
  *
  * Returns: 0 for success
  */
@@ -1707,6 +2062,11 @@ static int fcoe_create(const char *buffer, struct kernel_param *kp)
         }
 #endif
 
+        if (!try_module_get(THIS_MODULE)) {
+                rc = -EINVAL;
+                goto out_nomod;
+        }
+
         rtnl_lock();
         netdev = fcoe_if_to_netdev(buffer);
         if (!netdev) {
@@ -1726,7 +2086,7 @@ static int fcoe_create(const char *buffer, struct kernel_param *kp)
                 goto out_putdev;
         }
 
-        lport = fcoe_if_create(fcoe, &netdev->dev);
+        lport = fcoe_if_create(fcoe, &netdev->dev, 0);
         if (IS_ERR(lport)) {
                 printk(KERN_ERR "fcoe: Failed to create interface (%s)\n",
                        netdev->name);
@@ -1747,31 +2107,31 @@ static int fcoe_create(const char *buffer, struct kernel_param *kp)
         if (!fcoe_link_ok(lport))
                 fcoe_ctlr_link_up(&fcoe->ctlr);
 
-        rc = 0;
-out_free:
         /*
          * Release from init in fcoe_interface_create(), on success lport
          * should be holding a reference taken in fcoe_if_create().
          */
         fcoe_interface_put(fcoe);
+        dev_put(netdev);
+        rtnl_unlock();
+        mutex_unlock(&fcoe_config_mutex);
+
+        return 0;
+out_free:
+        fcoe_interface_put(fcoe);
 out_putdev:
         dev_put(netdev);
 out_nodev:
         rtnl_unlock();
+        module_put(THIS_MODULE);
+out_nomod:
         mutex_unlock(&fcoe_config_mutex);
         return rc;
 }
 
-module_param_call(create, fcoe_create, NULL, NULL, S_IWUSR);
-__MODULE_PARM_TYPE(create, "string");
-MODULE_PARM_DESC(create, "Create fcoe fcoe using net device passed in.");
-module_param_call(destroy, fcoe_destroy, NULL, NULL, S_IWUSR);
-__MODULE_PARM_TYPE(destroy, "string");
-MODULE_PARM_DESC(destroy, "Destroy fcoe fcoe");
-
 /**
- * fcoe_link_ok() - Check if link is ok for the fc_lport
- * @lp: ptr to the fc_lport
+ * fcoe_link_ok() - Check if the link is OK for a local port
+ * @lport: The local port to check link on
  *
  * Any permanently-disqualifying conditions have been previously checked.
  * This also updates the speed setting, which may change with link for 100/1000.
@@ -1783,26 +2143,26 @@ MODULE_PARM_DESC(destroy, "Destroy fcoe fcoe");
  * Returns: 0 if link is OK for use by FCoE.
  *
  */
-int fcoe_link_ok(struct fc_lport *lp)
+int fcoe_link_ok(struct fc_lport *lport)
 {
-        struct fcoe_port *port = lport_priv(lp);
-        struct net_device *dev = port->fcoe->netdev;
+        struct fcoe_port *port = lport_priv(lport);
+        struct net_device *netdev = port->fcoe->netdev;
         struct ethtool_cmd ecmd = { ETHTOOL_GSET };
 
-        if ((dev->flags & IFF_UP) && netif_carrier_ok(dev) &&
-            (!dev_ethtool_get_settings(dev, &ecmd))) {
-                lp->link_supported_speeds &=
+        if ((netdev->flags & IFF_UP) && netif_carrier_ok(netdev) &&
+            (!dev_ethtool_get_settings(netdev, &ecmd))) {
+                lport->link_supported_speeds &=
                         ~(FC_PORTSPEED_1GBIT | FC_PORTSPEED_10GBIT);
                 if (ecmd.supported & (SUPPORTED_1000baseT_Half |
                                       SUPPORTED_1000baseT_Full))
-                        lp->link_supported_speeds |= FC_PORTSPEED_1GBIT;
+                        lport->link_supported_speeds |= FC_PORTSPEED_1GBIT;
                 if (ecmd.supported & SUPPORTED_10000baseT_Full)
-                        lp->link_supported_speeds |=
+                        lport->link_supported_speeds |=
                                 FC_PORTSPEED_10GBIT;
                 if (ecmd.speed == SPEED_1000)
-                        lp->link_speed = FC_PORTSPEED_1GBIT;
+                        lport->link_speed = FC_PORTSPEED_1GBIT;
                 if (ecmd.speed == SPEED_10000)
-                        lp->link_speed = FC_PORTSPEED_10GBIT;
+                        lport->link_speed = FC_PORTSPEED_10GBIT;
 
                 return 0;
         }
@@ -1810,8 +2170,8 @@ int fcoe_link_ok(struct fc_lport *lp)
 }
 
 /**
- * fcoe_percpu_clean() - Clear the pending skbs for an lport
- * @lp: the fc_lport
+ * fcoe_percpu_clean() - Clear all pending skbs for an local port
+ * @lport: The local port whose skbs are to be cleared
  *
  * Must be called with fcoe_create_mutex held to single-thread completion.
  *
@@ -1820,7 +2180,7 @@ int fcoe_link_ok(struct fc_lport *lp)
  * there no packets that will be handled by the lport, but also that any
  * threads already handling packet have returned.
  */
-void fcoe_percpu_clean(struct fc_lport *lp)
+void fcoe_percpu_clean(struct fc_lport *lport)
 {
         struct fcoe_percpu_s *pp;
         struct fcoe_rcv_info *fr;
@@ -1838,7 +2198,7 @@ void fcoe_percpu_clean(struct fc_lport *lp)
                      skb = next) {
                         next = skb->next;
                         fr = fcoe_dev_from_skb(skb);
-                        if (fr->fr_dev == lp) {
+                        if (fr->fr_dev == lport) {
                                 __skb_unlink(skb, list);
                                 kfree_skb(skb);
                         }
@@ -1867,13 +2227,11 @@ void fcoe_percpu_clean(struct fc_lport *lp)
 
 /**
  * fcoe_clean_pending_queue() - Dequeue a skb and free it
- * @lp: the corresponding fc_lport
- *
- * Returns: none
+ * @lport: The local port to dequeue a skb on
  */
-void fcoe_clean_pending_queue(struct fc_lport *lp)
+void fcoe_clean_pending_queue(struct fc_lport *lport)
 {
-        struct fcoe_port  *port = lport_priv(lp);
+        struct fcoe_port  *port = lport_priv(lport);
         struct sk_buff *skb;
 
         spin_lock_bh(&port->fcoe_pending_queue.lock);
@@ -1886,10 +2244,10 @@ void fcoe_clean_pending_queue(struct fc_lport *lp)
 }
 
 /**
- * fcoe_reset() - Resets the fcoe
- * @shost: shost the reset is from
+ * fcoe_reset() - Reset a local port
+ * @shost: The SCSI host associated with the local port to be reset
  *
- * Returns: always 0
+ * Returns: Always 0 (return value required by FC transport template)
  */
 int fcoe_reset(struct Scsi_Host *shost)
 {
@@ -1899,30 +2257,33 @@ int fcoe_reset(struct Scsi_Host *shost)
 }
 
 /**
- * fcoe_hostlist_lookup_port() - find the corresponding lport by a given device
- * @dev: this is currently ptr to net_device
+ * fcoe_hostlist_lookup_port() - Find the FCoE interface associated with a net device
+ * @netdev: The net device used as a key
  *
- * Returns: NULL or the located fcoe_port
- * Locking: must be called with the RNL mutex held
+ * Locking: Must be called with the RNL mutex held.
+ *
+ * Returns: NULL or the FCoE interface
  */
 static struct fcoe_interface *
-fcoe_hostlist_lookup_port(const struct net_device *dev)
+fcoe_hostlist_lookup_port(const struct net_device *netdev)
 {
         struct fcoe_interface *fcoe;
 
         list_for_each_entry(fcoe, &fcoe_hostlist, list) {
-                if (fcoe->netdev == dev)
+                if (fcoe->netdev == netdev)
                         return fcoe;
         }
         return NULL;
 }
 
 /**
- * fcoe_hostlist_lookup() - Find the corresponding lport by netdev
- * @netdev: ptr to net_device
+ * fcoe_hostlist_lookup() - Find the local port associated with a
+ *                          given net device
+ * @netdev: The netdevice used as a key
  *
- * Returns: 0 for success
- * Locking: must be called with the RTNL mutex held
+ * Locking: Must be called with the RTNL mutex held
+ *
+ * Returns: NULL or the local port
  */
 static struct fc_lport *fcoe_hostlist_lookup(const struct net_device *netdev)
 {
@@ -1933,11 +2294,13 @@ static struct fc_lport *fcoe_hostlist_lookup(const struct net_device *netdev)
 }
 
 /**
- * fcoe_hostlist_add() - Add a lport to lports list
- * @lp: ptr to the fc_lport to be added
+ * fcoe_hostlist_add() - Add the FCoE interface identified by a local
+ *                       port to the hostlist
+ * @lport: The local port that identifies the FCoE interface to be added
  *
- * Returns: 0 for success
  * Locking: must be called with the RTNL mutex held
+ *
+ * Returns: 0 for success
  */
 static int fcoe_hostlist_add(const struct fc_lport *lport)
 {
@@ -1954,15 +2317,15 @@ static int fcoe_hostlist_add(const struct fc_lport *lport)
 }
 
 /**
- * fcoe_init() - fcoe module loading initialization
+ * fcoe_init() - Initialize fcoe.ko
  *
- * Returns 0 on success, negative on failure
+ * Returns: 0 on success, or a negative value on failure
  */
 static int __init fcoe_init(void)
 {
+        struct fcoe_percpu_s *p;
         unsigned int cpu;
         int rc = 0;
-        struct fcoe_percpu_s *p;
 
         mutex_lock(&fcoe_config_mutex);
 
@@ -1999,15 +2362,15 @@ out_free:
 module_init(fcoe_init);
 
 /**
- * fcoe_exit() - fcoe module unloading cleanup
+ * fcoe_exit() - Clean up fcoe.ko
  *
- * Returns 0 on success, negative on failure
+ * Returns: 0 on success or a  negative value on failure
  */
 static void __exit fcoe_exit(void)
 {
-        unsigned int cpu;
         struct fcoe_interface *fcoe, *tmp;
         struct fcoe_port *port;
+        unsigned int cpu;
 
         mutex_lock(&fcoe_config_mutex);
 
@@ -2033,9 +2396,238 @@ static void __exit fcoe_exit(void)
         /* flush any asyncronous interface destroys,
          * this should happen after the netdev notifier is unregistered */
         flush_scheduled_work();
+        /* That will flush out all the N_Ports on the hostlist, but now we
+         * may have NPIV VN_Ports scheduled for destruction */
+        flush_scheduled_work();
 
         /* detach from scsi transport
          * must happen after all destroys are done, therefor after the flush */
         fcoe_if_exit();
 }
 module_exit(fcoe_exit);
+
+/**
+ * fcoe_flogi_resp() - FCoE specific FLOGI and FDISC response handler
+ * @seq: active sequence in the FLOGI or FDISC exchange
+ * @fp: response frame, or error encoded in a pointer (timeout)
+ * @arg: pointer the the fcoe_ctlr structure
+ *
+ * This handles MAC address managment for FCoE, then passes control on to
+ * the libfc FLOGI response handler.
+ */
+static void fcoe_flogi_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
+{
+        struct fcoe_ctlr *fip = arg;
+        struct fc_exch *exch = fc_seq_exch(seq);
+        struct fc_lport *lport = exch->lp;
+        u8 *mac;
+
+        if (IS_ERR(fp))
+                goto done;
+
+        mac = fr_cb(fp)->granted_mac;
+        if (is_zero_ether_addr(mac)) {
+                /* pre-FIP */
+                if (fcoe_ctlr_recv_flogi(fip, lport, fp)) {
+                        fc_frame_free(fp);
+                        return;
+                }
+        }
+        fcoe_update_src_mac(lport, mac);
+done:
+        fc_lport_flogi_resp(seq, fp, lport);
+}
+
+/**
+ * fcoe_logo_resp() - FCoE specific LOGO response handler
+ * @seq: active sequence in the LOGO exchange
+ * @fp: response frame, or error encoded in a pointer (timeout)
+ * @arg: pointer the the fcoe_ctlr structure
+ *
+ * This handles MAC address managment for FCoE, then passes control on to
+ * the libfc LOGO response handler.
+ */
+static void fcoe_logo_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
+{
+        struct fc_lport *lport = arg;
+        static u8 zero_mac[ETH_ALEN] = { 0 };
+
+        if (!IS_ERR(fp))
+                fcoe_update_src_mac(lport, zero_mac);
+        fc_lport_logo_resp(seq, fp, lport);
+}
+
+/**
+ * fcoe_elsct_send - FCoE specific ELS handler
+ *
+ * This does special case handling of FIP encapsualted ELS exchanges for FCoE,
+ * using FCoE specific response handlers and passing the FIP controller as
+ * the argument (the lport is still available from the exchange).
+ *
+ * Most of the work here is just handed off to the libfc routine.
+ */
+static struct fc_seq *fcoe_elsct_send(struct fc_lport *lport, u32 did,
+                                      struct fc_frame *fp, unsigned int op,
+                                      void (*resp)(struct fc_seq *,
+                                                   struct fc_frame *,
+                                                   void *),
+                                      void *arg, u32 timeout)
+{
+        struct fcoe_port *port = lport_priv(lport);
+        struct fcoe_interface *fcoe = port->fcoe;
+        struct fcoe_ctlr *fip = &fcoe->ctlr;
+        struct fc_frame_header *fh = fc_frame_header_get(fp);
+
+        switch (op) {
+        case ELS_FLOGI:
+        case ELS_FDISC:
+                return fc_elsct_send(lport, did, fp, op, fcoe_flogi_resp,
+                                     fip, timeout);
+        case ELS_LOGO:
+                /* only hook onto fabric logouts, not port logouts */
+                if (ntoh24(fh->fh_d_id) != FC_FID_FLOGI)
+                        break;
+                return fc_elsct_send(lport, did, fp, op, fcoe_logo_resp,
+                                     lport, timeout);
+        }
+        return fc_elsct_send(lport, did, fp, op, resp, arg, timeout);
+}
+
+/**
+ * fcoe_vport_create() - create an fc_host/scsi_host for a vport
+ * @vport: fc_vport object to create a new fc_host for
+ * @disabled: start the new fc_host in a disabled state by default?
+ *
+ * Returns: 0 for success
+ */
+static int fcoe_vport_create(struct fc_vport *vport, bool disabled)
+{
+        struct Scsi_Host *shost = vport_to_shost(vport);
+        struct fc_lport *n_port = shost_priv(shost);
+        struct fcoe_port *port = lport_priv(n_port);
+        struct fcoe_interface *fcoe = port->fcoe;
+        struct net_device *netdev = fcoe->netdev;
+        struct fc_lport *vn_port;
+
+        mutex_lock(&fcoe_config_mutex);
+        vn_port = fcoe_if_create(fcoe, &vport->dev, 1);
+        mutex_unlock(&fcoe_config_mutex);
+
+        if (IS_ERR(vn_port)) {
+                printk(KERN_ERR "fcoe: fcoe_vport_create(%s) failed\n",
+                       netdev->name);
+                return -EIO;
+        }
+
+        if (disabled) {
+                fc_vport_set_state(vport, FC_VPORT_DISABLED);
+        } else {
+                vn_port->boot_time = jiffies;
+                fc_fabric_login(vn_port);
+                fc_vport_setlink(vn_port);
+        }
+        return 0;
+}
+
+/**
+ * fcoe_vport_destroy() - destroy the fc_host/scsi_host for a vport
+ * @vport: fc_vport object that is being destroyed
+ *
+ * Returns: 0 for success
+ */
+static int fcoe_vport_destroy(struct fc_vport *vport)
+{
+        struct Scsi_Host *shost = vport_to_shost(vport);
+        struct fc_lport *n_port = shost_priv(shost);
+        struct fc_lport *vn_port = vport->dd_data;
+        struct fcoe_port *port = lport_priv(vn_port);
+
+        mutex_lock(&n_port->lp_mutex);
+        list_del(&vn_port->list);
+        mutex_unlock(&n_port->lp_mutex);
+        schedule_work(&port->destroy_work);
+        return 0;
+}
+
+/**
+ * fcoe_vport_disable() - change vport state
+ * @vport: vport to bring online/offline
+ * @disable: should the vport be disabled?
+ */
+static int fcoe_vport_disable(struct fc_vport *vport, bool disable)
+{
+        struct fc_lport *lport = vport->dd_data;
+
+        if (disable) {
+                fc_vport_set_state(vport, FC_VPORT_DISABLED);
+                fc_fabric_logoff(lport);
+        } else {
+                lport->boot_time = jiffies;
+                fc_fabric_login(lport);
+                fc_vport_setlink(lport);
+        }
+
+        return 0;
+}
+
+/**
+ * fcoe_vport_set_symbolic_name() - append vport string to symbolic name
+ * @vport: fc_vport with a new symbolic name string
+ *
+ * After generating a new symbolic name string, a new RSPN_ID request is
+ * sent to the name server.  There is no response handler, so if it fails
+ * for some reason it will not be retried.
+ */
+static void fcoe_set_vport_symbolic_name(struct fc_vport *vport)
+{
+        struct fc_lport *lport = vport->dd_data;
+        struct fc_frame *fp;
+        size_t len;
+
+        snprintf(fc_host_symbolic_name(lport->host), FC_SYMBOLIC_NAME_SIZE,
+                 "%s v%s over %s : %s", FCOE_NAME, FCOE_VERSION,
+                 fcoe_netdev(lport)->name, vport->symbolic_name);
+
+        if (lport->state != LPORT_ST_READY)
+                return;
+
+        len = strnlen(fc_host_symbolic_name(lport->host), 255);
+        fp = fc_frame_alloc(lport,
+                            sizeof(struct fc_ct_hdr) +
+                            sizeof(struct fc_ns_rspn) + len);
+        if (!fp)
+                return;
+        lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, FC_NS_RSPN_ID,
+                             NULL, NULL, 3 * lport->r_a_tov);
+}
+
+/**
+ * fcoe_get_lesb() - Fill the FCoE Link Error Status Block
+ * @lport: the local port
+ * @fc_lesb: the link error status block
+ */
+static void fcoe_get_lesb(struct fc_lport *lport,
+                         struct fc_els_lesb *fc_lesb)
+{
+        unsigned int cpu;
+        u32 lfc, vlfc, mdac;
+        struct fcoe_dev_stats *devst;
+        struct fcoe_fc_els_lesb *lesb;
+        struct net_device *netdev = fcoe_netdev(lport);
+
+        lfc = 0;
+        vlfc = 0;
+        mdac = 0;
+        lesb = (struct fcoe_fc_els_lesb *)fc_lesb;
+        memset(lesb, 0, sizeof(*lesb));
+        for_each_possible_cpu(cpu) {
+                devst = per_cpu_ptr(lport->dev_stats, cpu);
+                lfc += devst->LinkFailureCount;
+                vlfc += devst->VLinkFailureCount;
+                mdac += devst->MissDiscAdvCount;
+        }
+        lesb->lesb_link_fail = htonl(lfc);
+        lesb->lesb_vlink_fail = htonl(vlfc);
+        lesb->lesb_miss_fka = htonl(mdac);
+        lesb->lesb_fcs_error = htonl(dev_get_stats(netdev)->rx_crc_errors);
+}
diff --git a/drivers/scsi/fcoe/fcoe.h b/drivers/scsi/fcoe/fcoe.h
index ce7f60fb1bc0..c69b2c56c2d1 100644
--- a/drivers/scsi/fcoe/fcoe.h
+++ b/drivers/scsi/fcoe/fcoe.h
@@ -32,7 +32,7 @@
 #define FCOE_NAME       "fcoe"
 #define FCOE_VENDOR     "Open-FCoE.org"
 
-#define FCOE_MAX_LUN            255
+#define FCOE_MAX_LUN            0xFFFF
 #define FCOE_MAX_FCP_TARGET     256
 
 #define FCOE_MAX_OUTSTANDING_COMMANDS   1024
@@ -40,11 +40,17 @@
 #define FCOE_MIN_XID            0x0000  /* the min xid supported by fcoe_sw */
 #define FCOE_MAX_XID            0x0FFF  /* the max xid supported by fcoe_sw */
 
+/*
+ * Max MTU for FCoE: 14 (FCoE header) + 24 (FC header) + 2112 (max FC payload)
+ * + 4 (FC CRC) + 4 (FCoE trailer) =  2158 bytes
+ */
+#define FCOE_MTU        2158
+
 unsigned int fcoe_debug_logging;
 module_param_named(debug_logging, fcoe_debug_logging, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
 
-#define FCOE_LOGGING        0x01 /* General logging, not categorized */
+#define FCOE_LOGGING        0x01 /* General logging, not categorized */
 #define FCOE_NETDEV_LOGGING 0x02 /* Netdevice logging */
 
 #define FCOE_CHECK_LOGGING(LEVEL, CMD)                                  \
@@ -64,8 +70,13 @@ do {                                                            	\
                            printk(KERN_INFO "fcoe: %s: " fmt,   \
                                   netdev->name, ##args);)
 
-/*
- * this percpu struct for fcoe
+/**
+ * struct fcoe_percpu_s - The per-CPU context for FCoE receive threads
+ * @thread:         The thread context
+ * @fcoe_rx_list:   The queue of pending packets to process
+ * @page:           The memory page for calculating frame trailer CRCs
+ * @crc_eof_offset: The offset into the CRC page pointing to available
+ *                  memory for a new trailer
  */
 struct fcoe_percpu_s {
         struct task_struct *thread;
@@ -74,37 +85,62 @@ struct fcoe_percpu_s {
         int crc_eof_offset;
 };
 
-/*
- * an FCoE interface, 1:1 with netdev
+/**
+ * struct fcoe_interface - A FCoE interface
+ * @list:             Handle for a list of FCoE interfaces
+ * @netdev:           The associated net device
+ * @fcoe_packet_type: FCoE packet type
+ * @fip_packet_type:  FIP packet type
+ * @ctlr:             The FCoE controller (for FIP)
+ * @oem:              The offload exchange manager for all local port
+ *                    instances associated with this port
+ * @kref:             The kernel reference
+ *
+ * This structure is 1:1 with a net devive.
  */
 struct fcoe_interface {
-        struct list_head list;
-        struct net_device *netdev;
-        struct packet_type  fcoe_packet_type;
-        struct packet_type  fip_packet_type;
-        struct fcoe_ctlr ctlr;
-        struct fc_exch_mgr *oem;                /* offload exchange manager */
-        struct kref kref;
+        struct list_head   list;
+        struct net_device  *netdev;
+        struct packet_type fcoe_packet_type;
+        struct packet_type fip_packet_type;
+        struct fcoe_ctlr   ctlr;
+        struct fc_exch_mgr *oem;
+        struct kref        kref;
 };
 
-/*
- * the FCoE private structure that's allocated along with the
- * Scsi_Host and libfc fc_lport structures
+/**
+ * struct fcoe_port - The FCoE private structure
+ * @fcoe:                      The associated fcoe interface
+ * @lport:                     The associated local port
+ * @fcoe_pending_queue:        The pending Rx queue of skbs
+ * @fcoe_pending_queue_active: Indicates if the pending queue is active
+ * @timer:                     The queue timer
+ * @destroy_work:              Handle for work context
+ *                             (to prevent RTNL deadlocks)
+ * @data_srt_addr:             Source address for data
+ *
+ * An instance of this structure is to be allocated along with the
+ * Scsi_Host and libfc fc_lport structures.
  */
 struct fcoe_port {
         struct fcoe_interface *fcoe;
-        struct fc_lport *lport;
-        struct sk_buff_head fcoe_pending_queue;
-        u8      fcoe_pending_queue_active;
-        struct timer_list timer;                /* queue timer */
-        struct work_struct destroy_work;        /* to prevent rtnl deadlocks */
+        struct fc_lport       *lport;
+        struct sk_buff_head   fcoe_pending_queue;
+        u8                    fcoe_pending_queue_active;
+        struct timer_list     timer;
+        struct work_struct    destroy_work;
+        u8                    data_src_addr[ETH_ALEN];
 };
 
 #define fcoe_from_ctlr(fip) container_of(fip, struct fcoe_interface, ctlr)
 
-static inline struct net_device *fcoe_netdev(const struct fc_lport *lp)
+/**
+ * fcoe_netdev() - Return the net device associated with a local port
+ * @lport: The local port to get the net device from
+ */
+static inline struct net_device *fcoe_netdev(const struct fc_lport *lport)
 {
-        return ((struct fcoe_port *)lport_priv(lp))->fcoe->netdev;
+        return ((struct fcoe_port *)lport_priv(lport))->fcoe->netdev;
 }
 
 #endif /* _FCOE_H_ */
diff --git a/drivers/scsi/fcoe/libfcoe.c b/drivers/scsi/fcoe/libfcoe.c
index 11ae5c94608b..3440da48d169 100644
--- a/drivers/scsi/fcoe/libfcoe.c
+++ b/drivers/scsi/fcoe/libfcoe.c
@@ -31,6 +31,7 @@
 #include <linux/if_vlan.h>
 #include <linux/errno.h>
 #include <linux/bitops.h>
+#include <linux/slab.h>
 #include <net/rtnetlink.h>
 
 #include <scsi/fc/fc_els.h>
@@ -59,26 +60,30 @@ unsigned int libfcoe_debug_logging;
 module_param_named(debug_logging, libfcoe_debug_logging, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
 
-#define LIBFCOE_LOGGING     0x01 /* General logging, not categorized */
+#define LIBFCOE_LOGGING     0x01 /* General logging, not categorized */
 #define LIBFCOE_FIP_LOGGING 0x02 /* FIP logging */
 
-#define LIBFCOE_CHECK_LOGGING(LEVEL, CMD)                               \
-do {                                                                    \
-        if (unlikely(libfcoe_debug_logging & LEVEL))                    \
-                do {                                                    \
-                        CMD;                                            \
-                } while (0);                                            \
+#define LIBFCOE_CHECK_LOGGING(LEVEL, CMD)               \
+do {                                                    \
+        if (unlikely(libfcoe_debug_logging & LEVEL))    \
+                do {                                    \
+                        CMD;                            \
+                } while (0);                            \
 } while (0)
 
 #define LIBFCOE_DBG(fmt, args...)                                       \
         LIBFCOE_CHECK_LOGGING(LIBFCOE_LOGGING,                          \
                               printk(KERN_INFO "libfcoe: " fmt, ##args);)
 
-#define LIBFCOE_FIP_DBG(fmt, args...)                                   \
+#define LIBFCOE_FIP_DBG(fip, fmt, args...)                              \
         LIBFCOE_CHECK_LOGGING(LIBFCOE_FIP_LOGGING,                      \
-                              printk(KERN_INFO "fip: " fmt, ##args);)
+                              printk(KERN_INFO "host%d: fip: " fmt,     \
+                                     (fip)->lp->host->host_no, ##args);)
 
-/*
+/**
+ * fcoe_ctlr_mtu_valid() - Check if a FCF's MTU is valid
+ * @fcf: The FCF to check
+ *
  * Return non-zero if FCF fcoe_size has been validated.
  */
 static inline int fcoe_ctlr_mtu_valid(const struct fcoe_fcf *fcf)
@@ -86,7 +91,10 @@ static inline int fcoe_ctlr_mtu_valid(const struct fcoe_fcf *fcf)
         return (fcf->flags & FIP_FL_SOL) != 0;
 }
 
-/*
+/**
+ * fcoe_ctlr_fcf_usable() - Check if a FCF is usable
+ * @fcf: The FCF to check
+ *
  * Return non-zero if the FCF is usable.
  */
 static inline int fcoe_ctlr_fcf_usable(struct fcoe_fcf *fcf)
@@ -97,12 +105,13 @@ static inline int fcoe_ctlr_fcf_usable(struct fcoe_fcf *fcf)
 }
 
 /**
- * fcoe_ctlr_init() - Initialize the FCoE Controller instance.
- * @fip:        FCoE controller.
+ * fcoe_ctlr_init() - Initialize the FCoE Controller instance
+ * @fip: The FCoE controller to initialize
  */
 void fcoe_ctlr_init(struct fcoe_ctlr *fip)
 {
         fip->state = FIP_ST_LINK_WAIT;
+        fip->mode = FIP_ST_AUTO;
         INIT_LIST_HEAD(&fip->fcfs);
         spin_lock_init(&fip->lock);
         fip->flogi_oxid = FC_XID_UNKNOWN;
@@ -114,8 +123,8 @@ void fcoe_ctlr_init(struct fcoe_ctlr *fip)
 EXPORT_SYMBOL(fcoe_ctlr_init);
 
 /**
- * fcoe_ctlr_reset_fcfs() - Reset and free all FCFs for a controller.
- * @fip:        FCoE controller.
+ * fcoe_ctlr_reset_fcfs() - Reset and free all FCFs for a controller
+ * @fip: The FCoE controller whose FCFs are to be reset
  *
  * Called with &fcoe_ctlr lock held.
  */
@@ -134,8 +143,8 @@ static void fcoe_ctlr_reset_fcfs(struct fcoe_ctlr *fip)
 }
 
 /**
- * fcoe_ctlr_destroy() - Disable and tear-down the FCoE controller.
- * @fip:        FCoE controller.
+ * fcoe_ctlr_destroy() - Disable and tear down a FCoE controller
+ * @fip: The FCoE controller to tear down
  *
  * This is called by FCoE drivers before freeing the &fcoe_ctlr.
  *
@@ -148,9 +157,7 @@ static void fcoe_ctlr_reset_fcfs(struct fcoe_ctlr *fip)
 void fcoe_ctlr_destroy(struct fcoe_ctlr *fip)
 {
         cancel_work_sync(&fip->recv_work);
-        spin_lock_bh(&fip->fip_recv_list.lock);
-        __skb_queue_purge(&fip->fip_recv_list);
-        spin_unlock_bh(&fip->fip_recv_list.lock);
+        skb_queue_purge(&fip->fip_recv_list);
 
         spin_lock_bh(&fip->lock);
         fip->state = FIP_ST_DISABLED;
@@ -162,8 +169,8 @@ void fcoe_ctlr_destroy(struct fcoe_ctlr *fip)
 EXPORT_SYMBOL(fcoe_ctlr_destroy);
 
 /**
- * fcoe_ctlr_fcoe_size() - Return the maximum FCoE size required for VN_Port.
- * @fip:        FCoE controller.
+ * fcoe_ctlr_fcoe_size() - Return the maximum FCoE size required for VN_Port
+ * @fip: The FCoE controller to get the maximum FCoE size from
  *
  * Returns the maximum packet size including the FCoE header and trailer,
  * but not including any Ethernet or VLAN headers.
@@ -180,9 +187,9 @@ static inline u32 fcoe_ctlr_fcoe_size(struct fcoe_ctlr *fip)
 }
 
 /**
- * fcoe_ctlr_solicit() - Send a solicitation.
- * @fip:        FCoE controller.
- * @fcf:        Destination FCF.  If NULL, a multicast solicitation is sent.
+ * fcoe_ctlr_solicit() - Send a FIP solicitation
+ * @fip: The FCoE controller to send the solicitation on
+ * @fcf: The destination FCF (if NULL, a multicast solicitation is sent)
  */
 static void fcoe_ctlr_solicit(struct fcoe_ctlr *fip, struct fcoe_fcf *fcf)
 {
@@ -241,8 +248,8 @@ static void fcoe_ctlr_solicit(struct fcoe_ctlr *fip, struct fcoe_fcf *fcf)
 }
 
 /**
- * fcoe_ctlr_link_up() - Start FCoE controller.
- * @fip:        FCoE controller.
+ * fcoe_ctlr_link_up() - Start FCoE controller
+ * @fip: The FCoE controller to start
  *
  * Called from the LLD when the network link is ready.
  */
@@ -255,11 +262,12 @@ void fcoe_ctlr_link_up(struct fcoe_ctlr *fip)
                 spin_unlock_bh(&fip->lock);
                 fc_linkup(fip->lp);
         } else if (fip->state == FIP_ST_LINK_WAIT) {
-                fip->state = FIP_ST_AUTO;
+                fip->state = fip->mode;
                 fip->last_link = 1;
                 fip->link = 1;
                 spin_unlock_bh(&fip->lock);
-                LIBFCOE_FIP_DBG("%s", "setting AUTO mode.\n");
+                if (fip->state == FIP_ST_AUTO)
+                        LIBFCOE_FIP_DBG(fip, "%s", "setting AUTO mode.\n");
                 fc_linkup(fip->lp);
                 fcoe_ctlr_solicit(fip, NULL);
         } else
@@ -268,45 +276,23 @@ void fcoe_ctlr_link_up(struct fcoe_ctlr *fip)
 EXPORT_SYMBOL(fcoe_ctlr_link_up);
 
 /**
- * fcoe_ctlr_reset() - Reset FIP.
- * @fip:        FCoE controller.
- * @new_state:  FIP state to be entered.
- *
- * Returns non-zero if the link was up and now isn't.
+ * fcoe_ctlr_reset() - Reset a FCoE controller
+ * @fip:       The FCoE controller to reset
  */
-static int fcoe_ctlr_reset(struct fcoe_ctlr *fip, enum fip_state new_state)
+static void fcoe_ctlr_reset(struct fcoe_ctlr *fip)
 {
-        struct fc_lport *lp = fip->lp;
-        int link_dropped;
-
-        spin_lock_bh(&fip->lock);
         fcoe_ctlr_reset_fcfs(fip);
         del_timer(&fip->timer);
-        fip->state = new_state;
         fip->ctlr_ka_time = 0;
         fip->port_ka_time = 0;
         fip->sol_time = 0;
         fip->flogi_oxid = FC_XID_UNKNOWN;
         fip->map_dest = 0;
-        fip->last_link = 0;
-        link_dropped = fip->link;
-        fip->link = 0;
-        spin_unlock_bh(&fip->lock);
-
-        if (link_dropped)
-                fc_linkdown(lp);
-
-        if (new_state == FIP_ST_ENABLED) {
-                fcoe_ctlr_solicit(fip, NULL);
-                fc_linkup(lp);
-                link_dropped = 0;
-        }
-        return link_dropped;
 }
 
 /**
- * fcoe_ctlr_link_down() - Stop FCoE controller.
- * @fip:        FCoE controller.
+ * fcoe_ctlr_link_down() - Stop a FCoE controller
+ * @fip: The FCoE controller to be stopped
  *
  * Returns non-zero if the link was up and now isn't.
  *
@@ -315,15 +301,29 @@ static int fcoe_ctlr_reset(struct fcoe_ctlr *fip, enum fip_state new_state)
  */
 int fcoe_ctlr_link_down(struct fcoe_ctlr *fip)
 {
-        return fcoe_ctlr_reset(fip, FIP_ST_LINK_WAIT);
+        int link_dropped;
+
+        LIBFCOE_FIP_DBG(fip, "link down.\n");
+        spin_lock_bh(&fip->lock);
+        fcoe_ctlr_reset(fip);
+        link_dropped = fip->link;
+        fip->link = 0;
+        fip->last_link = 0;
+        fip->state = FIP_ST_LINK_WAIT;
+        spin_unlock_bh(&fip->lock);
+
+        if (link_dropped)
+                fc_linkdown(fip->lp);
+        return link_dropped;
 }
 EXPORT_SYMBOL(fcoe_ctlr_link_down);
 
 /**
- * fcoe_ctlr_send_keep_alive() - Send a keep-alive to the selected FCF.
- * @fip:        FCoE controller.
- * @ports:      0 for controller keep-alive, 1 for port keep-alive.
- * @sa:         source MAC address.
+ * fcoe_ctlr_send_keep_alive() - Send a keep-alive to the selected FCF
+ * @fip:   The FCoE controller to send the FKA on
+ * @lport: libfc fc_lport to send from
+ * @ports: 0 for controller keep-alive, 1 for port keep-alive
+ * @sa:    The source MAC address
  *
  * A controller keep-alive is sent every fka_period (typically 8 seconds).
  * The source MAC is the native MAC address.
@@ -332,7 +332,9 @@ EXPORT_SYMBOL(fcoe_ctlr_link_down);
  * The source MAC is the assigned mapped source address.
  * The destination is the FCF's F-port.
  */
-static void fcoe_ctlr_send_keep_alive(struct fcoe_ctlr *fip, int ports, u8 *sa)
+static void fcoe_ctlr_send_keep_alive(struct fcoe_ctlr *fip,
+                                      struct fc_lport *lport,
+                                      int ports, u8 *sa)
 {
         struct sk_buff *skb;
         struct fip_kal {
@@ -350,8 +352,7 @@ static void fcoe_ctlr_send_keep_alive(struct fcoe_ctlr *fip, int ports, u8 *sa)
         if (!fcf || !fc_host_port_id(lp->host))
                 return;
 
-        len = fcoe_ctlr_fcoe_size(fip) + sizeof(struct ethhdr);
-        BUG_ON(len < sizeof(*kal) + sizeof(*vn));
+        len = sizeof(*kal) + ports * sizeof(*vn);
         skb = dev_alloc_skb(len);
         if (!skb)
                 return;
@@ -366,7 +367,7 @@ static void fcoe_ctlr_send_keep_alive(struct fcoe_ctlr *fip, int ports, u8 *sa)
         kal->fip.fip_op = htons(FIP_OP_CTRL);
         kal->fip.fip_subcode = FIP_SC_KEEP_ALIVE;
         kal->fip.fip_dl_len = htons((sizeof(kal->mac) +
-                                    ports * sizeof(*vn)) / FIP_BPW);
+                                     ports * sizeof(*vn)) / FIP_BPW);
         kal->fip.fip_flags = htons(FIP_FL_FPMA);
         if (fip->spma)
                 kal->fip.fip_flags |= htons(FIP_FL_SPMA);
@@ -374,16 +375,14 @@ static void fcoe_ctlr_send_keep_alive(struct fcoe_ctlr *fip, int ports, u8 *sa)
         kal->mac.fd_desc.fip_dtype = FIP_DT_MAC;
         kal->mac.fd_desc.fip_dlen = sizeof(kal->mac) / FIP_BPW;
         memcpy(kal->mac.fd_mac, fip->ctl_src_addr, ETH_ALEN);
-
         if (ports) {
                 vn = (struct fip_vn_desc *)(kal + 1);
                 vn->fd_desc.fip_dtype = FIP_DT_VN_ID;
                 vn->fd_desc.fip_dlen = sizeof(*vn) / FIP_BPW;
-                memcpy(vn->fd_mac, fip->data_src_addr, ETH_ALEN);
+                memcpy(vn->fd_mac, fip->get_src_addr(lport), ETH_ALEN);
                 hton24(vn->fd_fc_id, fc_host_port_id(lp->host));
                 put_unaligned_be64(lp->wwpn, &vn->fd_wwpn);
         }
-
         skb_put(skb, len);
         skb->protocol = htons(ETH_P_FIP);
         skb_reset_mac_header(skb);
@@ -392,10 +391,10 @@ static void fcoe_ctlr_send_keep_alive(struct fcoe_ctlr *fip, int ports, u8 *sa)
 }
 
 /**
- * fcoe_ctlr_encaps() - Encapsulate an ELS frame for FIP, without sending it.
- * @fip:        FCoE controller.
- * @dtype:      FIP descriptor type for the frame.
- * @skb:        FCoE ELS frame including FC header but no FCoE headers.
+ * fcoe_ctlr_encaps() - Encapsulate an ELS frame for FIP, without sending it
+ * @fip:   The FCoE controller for the ELS frame
+ * @dtype: The FIP descriptor type for the frame
+ * @skb:   The FCoE ELS frame including FC header but no FCoE headers
  *
  * Returns non-zero error code on failure.
  *
@@ -405,7 +404,7 @@ static void fcoe_ctlr_send_keep_alive(struct fcoe_ctlr *fip, int ports, u8 *sa)
  * Headroom includes the FIP encapsulation description, FIP header, and
  * Ethernet header.  The tailroom is for the FIP MAC descriptor.
  */
-static int fcoe_ctlr_encaps(struct fcoe_ctlr *fip,
+static int fcoe_ctlr_encaps(struct fcoe_ctlr *fip, struct fc_lport *lport,
                             u8 dtype, struct sk_buff *skb)
 {
         struct fip_encaps_head {
@@ -449,8 +448,8 @@ static int fcoe_ctlr_encaps(struct fcoe_ctlr *fip,
         memset(mac, 0, sizeof(mac));
         mac->fd_desc.fip_dtype = FIP_DT_MAC;
         mac->fd_desc.fip_dlen = sizeof(*mac) / FIP_BPW;
-        if (dtype != FIP_DT_FLOGI)
-                memcpy(mac->fd_mac, fip->data_src_addr, ETH_ALEN);
+        if (dtype != FIP_DT_FLOGI && dtype != FIP_DT_FDISC)
+                memcpy(mac->fd_mac, fip->get_src_addr(lport), ETH_ALEN);
         else if (fip->spma)
                 memcpy(mac->fd_mac, fip->ctl_src_addr, ETH_ALEN);
 
@@ -463,6 +462,7 @@ static int fcoe_ctlr_encaps(struct fcoe_ctlr *fip,
 /**
  * fcoe_ctlr_els_send() - Send an ELS frame encapsulated by FIP if appropriate.
  * @fip:        FCoE controller.
+ * @lport:      libfc fc_lport to send from
  * @skb:        FCoE ELS frame including FC header but no FCoE headers.
  *
  * Returns a non-zero error code if the frame should not be sent.
@@ -471,11 +471,13 @@ static int fcoe_ctlr_encaps(struct fcoe_ctlr *fip,
  * The caller must check that the length is a multiple of 4.
  * The SKB must have enough headroom (28 bytes) and tailroom (8 bytes).
  */
-int fcoe_ctlr_els_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
+int fcoe_ctlr_els_send(struct fcoe_ctlr *fip, struct fc_lport *lport,
+                       struct sk_buff *skb)
 {
         struct fc_frame_header *fh;
         u16 old_xid;
         u8 op;
+        u8 mac[ETH_ALEN];
 
         fh = (struct fc_frame_header *)skb->data;
         op = *(u8 *)(fh + 1);
@@ -498,6 +500,8 @@ int fcoe_ctlr_els_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
 
         if (fip->state == FIP_ST_NON_FIP)
                 return 0;
+        if (!fip->sel_fcf)
+                goto drop;
 
         switch (op) {
         case ELS_FLOGI:
@@ -530,14 +534,15 @@ int fcoe_ctlr_els_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
                  * FLOGI.
                  */
                 fip->flogi_oxid = FC_XID_UNKNOWN;
-                fc_fcoe_set_mac(fip->data_src_addr, fh->fh_s_id);
+                fc_fcoe_set_mac(mac, fh->fh_d_id);
+                fip->update_mac(lport, mac);
                 return 0;
         default:
                 if (fip->state != FIP_ST_ENABLED)
                         goto drop;
                 return 0;
         }
-        if (fcoe_ctlr_encaps(fip, op, skb))
+        if (fcoe_ctlr_encaps(fip, lport, op, skb))
                 goto drop;
         fip->send(fip, skb);
         return -EINPROGRESS;
@@ -547,9 +552,9 @@ drop:
 }
 EXPORT_SYMBOL(fcoe_ctlr_els_send);
 
-/*
- * fcoe_ctlr_age_fcfs() - Reset and free all old FCFs for a controller.
- * @fip:        FCoE controller.
+/**
+ * fcoe_ctlr_age_fcfs() - Reset and free all old FCFs for a controller
+ * @fip: The FCoE controller to free FCFs on
  *
  * Called with lock held.
  *
@@ -558,14 +563,28 @@ EXPORT_SYMBOL(fcoe_ctlr_els_send);
  * times its keep-alive period including fuzz.
  *
  * In addition, determine the time when an FCF selection can occur.
+ *
+ * Also, increment the MissDiscAdvCount when no advertisement is received
+ * for the corresponding FCF for 1.5 * FKA_ADV_PERIOD (FC-BB-5 LESB).
  */
 static void fcoe_ctlr_age_fcfs(struct fcoe_ctlr *fip)
 {
         struct fcoe_fcf *fcf;
         struct fcoe_fcf *next;
         unsigned long sel_time = 0;
+        unsigned long mda_time = 0;
 
         list_for_each_entry_safe(fcf, next, &fip->fcfs, list) {
+                mda_time = fcf->fka_period + (fcf->fka_period >> 1);
+                if ((fip->sel_fcf == fcf) &&
+                    (time_after(jiffies, fcf->time + mda_time))) {
+                        mod_timer(&fip->timer, jiffies + mda_time);
+                        fc_lport_get_stats(fip->lp)->MissDiscAdvCount++;
+                        printk(KERN_INFO "libfcoe: host%d: Missing Discovery "
+                               "Advertisement for fab %llx count %lld\n",
+                               fip->lp->host->host_no, fcf->fabric_name,
+                               fc_lport_get_stats(fip->lp)->MissDiscAdvCount);
+                }
                 if (time_after(jiffies, fcf->time + fcf->fka_period * 3 +
                                msecs_to_jiffies(FIP_FCF_FUZZ * 3))) {
                         if (fip->sel_fcf == fcf)
@@ -574,6 +593,7 @@ static void fcoe_ctlr_age_fcfs(struct fcoe_ctlr *fip)
                         WARN_ON(!fip->fcf_count);
                         fip->fcf_count--;
                         kfree(fcf);
+                        fc_lport_get_stats(fip->lp)->VLinkFailureCount++;
                 } else if (fcoe_ctlr_mtu_valid(fcf) &&
                            (!sel_time || time_before(sel_time, fcf->time))) {
                         sel_time = fcf->time;
@@ -590,14 +610,16 @@ static void fcoe_ctlr_age_fcfs(struct fcoe_ctlr *fip)
 }
 
 /**
- * fcoe_ctlr_parse_adv() - Decode a FIP advertisement into a new FCF entry.
- * @skb:        received FIP advertisement frame
- * @fcf:        resulting FCF entry.
+ * fcoe_ctlr_parse_adv() - Decode a FIP advertisement into a new FCF entry
+ * @fip: The FCoE controller receiving the advertisement
+ * @skb: The received FIP advertisement frame
+ * @fcf: The resulting FCF entry
  *
  * Returns zero on a valid parsed advertisement,
  * otherwise returns non zero value.
  */
-static int fcoe_ctlr_parse_adv(struct sk_buff *skb, struct fcoe_fcf *fcf)
+static int fcoe_ctlr_parse_adv(struct fcoe_ctlr *fip,
+                               struct sk_buff *skb, struct fcoe_fcf *fcf)
 {
         struct fip_header *fiph;
         struct fip_desc *desc = NULL;
@@ -636,7 +658,7 @@ static int fcoe_ctlr_parse_adv(struct sk_buff *skb, struct fcoe_fcf *fcf)
                                ((struct fip_mac_desc *)desc)->fd_mac,
                                ETH_ALEN);
                         if (!is_valid_ether_addr(fcf->fcf_mac)) {
-                                LIBFCOE_FIP_DBG("Invalid MAC address "
+                                LIBFCOE_FIP_DBG(fip, "Invalid MAC address "
                                                 "in FIP adv\n");
                                 return -EINVAL;
                         }
@@ -659,6 +681,8 @@ static int fcoe_ctlr_parse_adv(struct sk_buff *skb, struct fcoe_fcf *fcf)
                         if (dlen != sizeof(struct fip_fka_desc))
                                 goto len_err;
                         fka = (struct fip_fka_desc *)desc;
+                        if (fka->fd_flags & FIP_FKA_ADV_D)
+                                fcf->fd_flags = 1;
                         t = ntohl(fka->fd_fka_period);
                         if (t >= FCOE_CTLR_MIN_FKA)
                                 fcf->fka_period = msecs_to_jiffies(t);
@@ -670,7 +694,7 @@ static int fcoe_ctlr_parse_adv(struct sk_buff *skb, struct fcoe_fcf *fcf)
                 case FIP_DT_LOGO:
                 case FIP_DT_ELP:
                 default:
-                        LIBFCOE_FIP_DBG("unexpected descriptor type %x "
+                        LIBFCOE_FIP_DBG(fip, "unexpected descriptor type %x "
                                         "in FIP adv\n", desc->fip_dtype);
                         /* standard says ignore unknown descriptors >= 128 */
                         if (desc->fip_dtype < FIP_DT_VENDOR_BASE)
@@ -687,15 +711,15 @@ static int fcoe_ctlr_parse_adv(struct sk_buff *skb, struct fcoe_fcf *fcf)
         return 0;
 
 len_err:
-        LIBFCOE_FIP_DBG("FIP length error in descriptor type %x len %zu\n",
+        LIBFCOE_FIP_DBG(fip, "FIP length error in descriptor type %x len %zu\n",
                         desc->fip_dtype, dlen);
         return -EINVAL;
 }
 
 /**
- * fcoe_ctlr_recv_adv() - Handle an incoming advertisement.
- * @fip:        FCoE controller.
- * @skb:        Received FIP packet.
+ * fcoe_ctlr_recv_adv() - Handle an incoming advertisement
+ * @fip: The FCoE controller receiving the advertisement
+ * @skb: The received FIP packet
  */
 static void fcoe_ctlr_recv_adv(struct fcoe_ctlr *fip, struct sk_buff *skb)
 {
@@ -706,7 +730,7 @@ static void fcoe_ctlr_recv_adv(struct fcoe_ctlr *fip, struct sk_buff *skb)
         int first = 0;
         int mtu_valid;
 
-        if (fcoe_ctlr_parse_adv(skb, &new))
+        if (fcoe_ctlr_parse_adv(fip, skb, &new))
                 return;
 
         spin_lock_bh(&fip->lock);
@@ -752,7 +776,7 @@ static void fcoe_ctlr_recv_adv(struct fcoe_ctlr *fip, struct sk_buff *skb)
         mtu_valid = fcoe_ctlr_mtu_valid(fcf);
         fcf->time = jiffies;
         if (!found) {
-                LIBFCOE_FIP_DBG("New FCF for fab %llx map %x val %d\n",
+                LIBFCOE_FIP_DBG(fip, "New FCF for fab %llx map %x val %d\n",
                                 fcf->fabric_name, fcf->fc_map, mtu_valid);
         }
 
@@ -778,7 +802,7 @@ static void fcoe_ctlr_recv_adv(struct fcoe_ctlr *fip, struct sk_buff *skb)
          */
         if (mtu_valid && !fip->sel_time && fcoe_ctlr_fcf_usable(fcf)) {
                 fip->sel_time = jiffies +
-                                msecs_to_jiffies(FCOE_CTLR_START_DELAY);
+                        msecs_to_jiffies(FCOE_CTLR_START_DELAY);
                 if (!timer_pending(&fip->timer) ||
                     time_before(fip->sel_time, fip->timer.expires))
                         mod_timer(&fip->timer, fip->sel_time);
@@ -788,15 +812,15 @@ out:
 }
 
 /**
- * fcoe_ctlr_recv_els() - Handle an incoming FIP-encapsulated ELS frame.
- * @fip:        FCoE controller.
- * @skb:        Received FIP packet.
+ * fcoe_ctlr_recv_els() - Handle an incoming FIP encapsulated ELS frame
+ * @fip: The FCoE controller which received the packet
+ * @skb: The received FIP packet
  */
 static void fcoe_ctlr_recv_els(struct fcoe_ctlr *fip, struct sk_buff *skb)
 {
-        struct fc_lport *lp = fip->lp;
+        struct fc_lport *lport = fip->lp;
         struct fip_header *fiph;
-        struct fc_frame *fp;
+        struct fc_frame *fp = (struct fc_frame *)skb;
         struct fc_frame_header *fh = NULL;
         struct fip_desc *desc;
         struct fip_encaps *els;
@@ -831,10 +855,11 @@ static void fcoe_ctlr_recv_els(struct fcoe_ctlr *fip, struct sk_buff *skb)
                                ((struct fip_mac_desc *)desc)->fd_mac,
                                ETH_ALEN);
                         if (!is_valid_ether_addr(granted_mac)) {
-                                LIBFCOE_FIP_DBG("Invalid MAC address "
+                                LIBFCOE_FIP_DBG(fip, "Invalid MAC address "
                                                 "in FIP ELS\n");
                                 goto drop;
                         }
+                        memcpy(fr_cb(fp)->granted_mac, granted_mac, ETH_ALEN);
                         break;
                 case FIP_DT_FLOGI:
                 case FIP_DT_FDISC:
@@ -850,7 +875,7 @@ static void fcoe_ctlr_recv_els(struct fcoe_ctlr *fip, struct sk_buff *skb)
                         els_dtype = desc->fip_dtype;
                         break;
                 default:
-                        LIBFCOE_FIP_DBG("unexpected descriptor type %x "
+                        LIBFCOE_FIP_DBG(fip, "unexpected descriptor type %x "
                                         "in FIP adv\n", desc->fip_dtype);
                         /* standard says ignore unknown descriptors >= 128 */
                         if (desc->fip_dtype < FIP_DT_VENDOR_BASE)
@@ -867,11 +892,8 @@ static void fcoe_ctlr_recv_els(struct fcoe_ctlr *fip, struct sk_buff *skb)
 
         if (els_dtype == FIP_DT_FLOGI && sub == FIP_SC_REP &&
             fip->flogi_oxid == ntohs(fh->fh_ox_id) &&
-            els_op == ELS_LS_ACC && is_valid_ether_addr(granted_mac)) {
+            els_op == ELS_LS_ACC && is_valid_ether_addr(granted_mac))
                 fip->flogi_oxid = FC_XID_UNKNOWN;
-                fip->update_mac(fip, fip->data_src_addr, granted_mac);
-                memcpy(fip->data_src_addr, granted_mac, ETH_ALEN);
-        }
 
         /*
          * Convert skb into an fc_frame containing only the ELS.
@@ -882,32 +904,32 @@ static void fcoe_ctlr_recv_els(struct fcoe_ctlr *fip, struct sk_buff *skb)
         fc_frame_init(fp);
         fr_sof(fp) = FC_SOF_I3;
         fr_eof(fp) = FC_EOF_T;
-        fr_dev(fp) = lp;
+        fr_dev(fp) = lport;
 
-        stats = fc_lport_get_stats(lp);
+        stats = fc_lport_get_stats(lport);
         stats->RxFrames++;
         stats->RxWords += skb->len / FIP_BPW;
 
-        fc_exch_recv(lp, fp);
+        fc_exch_recv(lport, fp);
         return;
 
 len_err:
-        LIBFCOE_FIP_DBG("FIP length error in descriptor type %x len %zu\n",
+        LIBFCOE_FIP_DBG(fip, "FIP length error in descriptor type %x len %zu\n",
                         desc->fip_dtype, dlen);
 drop:
         kfree_skb(skb);
 }
 
 /**
- * fcoe_ctlr_recv_els() - Handle an incoming link reset frame.
- * @fip:        FCoE controller.
- * @fh:         Received FIP header.
+ * fcoe_ctlr_recv_els() - Handle an incoming link reset frame
+ * @fip: The FCoE controller that received the frame
+ * @fh:  The received FIP header
  *
  * There may be multiple VN_Port descriptors.
  * The overall length has already been checked.
  */
 static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,
-                                      struct fip_header *fh)
+                                     struct fip_header *fh)
 {
         struct fip_desc *desc;
         struct fip_mac_desc *mp;
@@ -916,13 +938,13 @@ static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,
         size_t rlen;
         size_t dlen;
         struct fcoe_fcf *fcf = fip->sel_fcf;
-        struct fc_lport *lp = fip->lp;
+        struct fc_lport *lport = fip->lp;
         u32     desc_mask;
 
-        LIBFCOE_FIP_DBG("Clear Virtual Link received\n");
+        LIBFCOE_FIP_DBG(fip, "Clear Virtual Link received\n");
         if (!fcf)
                 return;
-        if (!fcf || !fc_host_port_id(lp->host))
+        if (!fcf || !fc_host_port_id(lport->host))
                 return;
 
         /*
@@ -958,9 +980,10 @@ static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,
                         if (dlen < sizeof(*vp))
                                 return;
                         if (compare_ether_addr(vp->fd_mac,
-                            fip->data_src_addr) == 0 &&
-                            get_unaligned_be64(&vp->fd_wwpn) == lp->wwpn &&
-                            ntoh24(vp->fd_fc_id) == fc_host_port_id(lp->host))
+                                               fip->get_src_addr(lport)) == 0 &&
+                            get_unaligned_be64(&vp->fd_wwpn) == lport->wwpn &&
+                            ntoh24(vp->fd_fc_id) ==
+                            fc_host_port_id(lport->host))
                                 desc_mask &= ~BIT(FIP_DT_VN_ID);
                         break;
                 default:
@@ -977,33 +1000,39 @@ static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,
          * reset only if all required descriptors were present and valid.
          */
         if (desc_mask) {
-                LIBFCOE_FIP_DBG("missing descriptors mask %x\n", desc_mask);
+                LIBFCOE_FIP_DBG(fip, "missing descriptors mask %x\n",
+                                desc_mask);
         } else {
-                LIBFCOE_FIP_DBG("performing Clear Virtual Link\n");
-                fcoe_ctlr_reset(fip, FIP_ST_ENABLED);
+                LIBFCOE_FIP_DBG(fip, "performing Clear Virtual Link\n");
+
+                spin_lock_bh(&fip->lock);
+                fc_lport_get_stats(lport)->VLinkFailureCount++;
+                fcoe_ctlr_reset(fip);
+                spin_unlock_bh(&fip->lock);
+
+                fc_lport_reset(fip->lp);
+                fcoe_ctlr_solicit(fip, NULL);
         }
 }
 
 /**
- * fcoe_ctlr_recv() - Receive a FIP frame.
- * @fip:        FCoE controller.
- * @skb:        Received FIP packet.
+ * fcoe_ctlr_recv() - Receive a FIP packet
+ * @fip: The FCoE controller that received the packet
+ * @skb: The received FIP packet
  *
- * This is called from NET_RX_SOFTIRQ.
+ * This may be called from either NET_RX_SOFTIRQ or IRQ.
  */
 void fcoe_ctlr_recv(struct fcoe_ctlr *fip, struct sk_buff *skb)
 {
-        spin_lock_bh(&fip->fip_recv_list.lock);
-        __skb_queue_tail(&fip->fip_recv_list, skb);
-        spin_unlock_bh(&fip->fip_recv_list.lock);
+        skb_queue_tail(&fip->fip_recv_list, skb);
         schedule_work(&fip->recv_work);
 }
 EXPORT_SYMBOL(fcoe_ctlr_recv);
 
 /**
- * fcoe_ctlr_recv_handler() - Receive a FIP frame.
- * @fip:        FCoE controller.
- * @skb:        Received FIP packet.
+ * fcoe_ctlr_recv_handler() - Receive a FIP frame
+ * @fip: The FCoE controller that received the frame
+ * @skb: The received FIP frame
  *
  * Returns non-zero if the frame is dropped.
  */
@@ -1038,7 +1067,7 @@ static int fcoe_ctlr_recv_handler(struct fcoe_ctlr *fip, struct sk_buff *skb)
                 fip->map_dest = 0;
                 fip->state = FIP_ST_ENABLED;
                 state = FIP_ST_ENABLED;
-                LIBFCOE_FIP_DBG("Using FIP mode\n");
+                LIBFCOE_FIP_DBG(fip, "Using FIP mode\n");
         }
         spin_unlock_bh(&fip->lock);
         if (state != FIP_ST_ENABLED)
@@ -1060,8 +1089,8 @@ drop:
 }
 
 /**
- * fcoe_ctlr_select() - Select the best FCF, if possible.
- * @fip:        FCoE controller.
+ * fcoe_ctlr_select() - Select the best FCF (if possible)
+ * @fip: The FCoE controller
  *
  * If there are conflicting advertisements, no FCF can be chosen.
  *
@@ -1073,11 +1102,11 @@ static void fcoe_ctlr_select(struct fcoe_ctlr *fip)
         struct fcoe_fcf *best = NULL;
 
         list_for_each_entry(fcf, &fip->fcfs, list) {
-                LIBFCOE_FIP_DBG("consider FCF for fab %llx VFID %d map %x "
+                LIBFCOE_FIP_DBG(fip, "consider FCF for fab %llx VFID %d map %x "
                                 "val %d\n", fcf->fabric_name, fcf->vfid,
                                 fcf->fc_map, fcoe_ctlr_mtu_valid(fcf));
                 if (!fcoe_ctlr_fcf_usable(fcf)) {
-                        LIBFCOE_FIP_DBG("FCF for fab %llx map %x %svalid "
+                        LIBFCOE_FIP_DBG(fip, "FCF for fab %llx map %x %svalid "
                                         "%savailable\n", fcf->fabric_name,
                                         fcf->fc_map, (fcf->flags & FIP_FL_SOL)
                                         ? "" : "in", (fcf->flags & FIP_FL_AVAIL)
@@ -1091,7 +1120,7 @@ static void fcoe_ctlr_select(struct fcoe_ctlr *fip)
                 if (fcf->fabric_name != best->fabric_name ||
                     fcf->vfid != best->vfid ||
                     fcf->fc_map != best->fc_map) {
-                        LIBFCOE_FIP_DBG("Conflicting fabric, VFID, "
+                        LIBFCOE_FIP_DBG(fip, "Conflicting fabric, VFID, "
                                         "or FC-MAP\n");
                         return;
                 }
@@ -1102,8 +1131,8 @@ static void fcoe_ctlr_select(struct fcoe_ctlr *fip)
 }
 
 /**
- * fcoe_ctlr_timeout() - FIP timer function.
- * @arg:        &fcoe_ctlr pointer.
+ * fcoe_ctlr_timeout() - FIP timeout handler
+ * @arg: The FCoE controller that timed out
  *
  * Ages FCFs.  Triggers FCF selection if possible.  Sends keep-alives.
  */
@@ -1113,8 +1142,6 @@ static void fcoe_ctlr_timeout(unsigned long arg)
         struct fcoe_fcf *sel;
         struct fcoe_fcf *fcf;
         unsigned long next_timer = jiffies + msecs_to_jiffies(FIP_VN_KA_PERIOD);
-        u8 send_ctlr_ka;
-        u8 send_port_ka;
 
         spin_lock_bh(&fip->lock);
         if (fip->state == FIP_ST_DISABLED) {
@@ -1140,53 +1167,47 @@ static void fcoe_ctlr_timeout(unsigned long arg)
                                fip->lp->host->host_no, sel->fcf_mac);
                         memcpy(fip->dest_addr, sel->fcf_mac, ETH_ALEN);
                         fip->port_ka_time = jiffies +
-                                            msecs_to_jiffies(FIP_VN_KA_PERIOD);
+                                msecs_to_jiffies(FIP_VN_KA_PERIOD);
                         fip->ctlr_ka_time = jiffies + sel->fka_period;
-                        fip->link = 1;
                 } else {
                         printk(KERN_NOTICE "libfcoe: host%d: "
-                               "FIP Fibre-Channel Forwarder timed out.  "
+                               "FIP Fibre-Channel Forwarder timed out.  "
                                "Starting FCF discovery.\n",
                                fip->lp->host->host_no);
-                        fip->link = 0;
+                        fip->reset_req = 1;
+                        schedule_work(&fip->link_work);
                 }
-                schedule_work(&fip->link_work);
         }
 
-        send_ctlr_ka = 0;
-        send_port_ka = 0;
-        if (sel) {
+        if (sel && !sel->fd_flags) {
                 if (time_after_eq(jiffies, fip->ctlr_ka_time)) {
                         fip->ctlr_ka_time = jiffies + sel->fka_period;
-                        send_ctlr_ka = 1;
+                        fip->send_ctlr_ka = 1;
                 }
                 if (time_after(next_timer, fip->ctlr_ka_time))
                         next_timer = fip->ctlr_ka_time;
 
                 if (time_after_eq(jiffies, fip->port_ka_time)) {
-                        fip->port_ka_time += jiffies +
-                                        msecs_to_jiffies(FIP_VN_KA_PERIOD);
-                        send_port_ka = 1;
+                        fip->port_ka_time = jiffies +
+                                msecs_to_jiffies(FIP_VN_KA_PERIOD);
+                        fip->send_port_ka = 1;
                 }
                 if (time_after(next_timer, fip->port_ka_time))
                         next_timer = fip->port_ka_time;
                 mod_timer(&fip->timer, next_timer);
         } else if (fip->sel_time) {
                 next_timer = fip->sel_time +
-                                msecs_to_jiffies(FCOE_CTLR_START_DELAY);
+                        msecs_to_jiffies(FCOE_CTLR_START_DELAY);
                 mod_timer(&fip->timer, next_timer);
         }
+        if (fip->send_ctlr_ka || fip->send_port_ka)
+                schedule_work(&fip->link_work);
         spin_unlock_bh(&fip->lock);
-
-        if (send_ctlr_ka)
-                fcoe_ctlr_send_keep_alive(fip, 0, fip->ctl_src_addr);
-        if (send_port_ka)
-                fcoe_ctlr_send_keep_alive(fip, 1, fip->data_src_addr);
 }
 
 /**
- * fcoe_ctlr_link_work() - worker thread function for link changes.
- * @work:       pointer to link_work member inside &fcoe_ctlr.
+ * fcoe_ctlr_link_work() - Worker thread function for link changes
+ * @work: Handle to a FCoE controller
  *
  * See if the link status has changed and if so, report it.
  *
@@ -1196,27 +1217,49 @@ static void fcoe_ctlr_timeout(unsigned long arg)
 static void fcoe_ctlr_link_work(struct work_struct *work)
 {
         struct fcoe_ctlr *fip;
+        struct fc_lport *vport;
+        u8 *mac;
         int link;
         int last_link;
+        int reset;
 
         fip = container_of(work, struct fcoe_ctlr, link_work);
         spin_lock_bh(&fip->lock);
         last_link = fip->last_link;
         link = fip->link;
         fip->last_link = link;
+        reset = fip->reset_req;
+        fip->reset_req = 0;
         spin_unlock_bh(&fip->lock);
 
         if (last_link != link) {
                 if (link)
                         fc_linkup(fip->lp);
                 else
-                        fcoe_ctlr_reset(fip, FIP_ST_LINK_WAIT);
+                        fc_linkdown(fip->lp);
+        } else if (reset && link)
+                fc_lport_reset(fip->lp);
+
+        if (fip->send_ctlr_ka) {
+                fip->send_ctlr_ka = 0;
+                fcoe_ctlr_send_keep_alive(fip, NULL, 0, fip->ctl_src_addr);
+        }
+        if (fip->send_port_ka) {
+                fip->send_port_ka = 0;
+                mutex_lock(&fip->lp->lp_mutex);
+                mac = fip->get_src_addr(fip->lp);
+                fcoe_ctlr_send_keep_alive(fip, fip->lp, 1, mac);
+                list_for_each_entry(vport, &fip->lp->vports, list) {
+                        mac = fip->get_src_addr(vport);
+                        fcoe_ctlr_send_keep_alive(fip, vport, 1, mac);
+                }
+                mutex_unlock(&fip->lp->lp_mutex);
         }
 }
 
 /**
- * fcoe_ctlr_recv_work() - Worker thread function for receiving FIP frames.
- * @recv_work:  pointer to recv_work member inside &fcoe_ctlr.
+ * fcoe_ctlr_recv_work() - Worker thread function for receiving FIP frames
+ * @recv_work: Handle to a FCoE controller
  */
 static void fcoe_ctlr_recv_work(struct work_struct *recv_work)
 {
@@ -1224,20 +1267,14 @@ static void fcoe_ctlr_recv_work(struct work_struct *recv_work)
         struct sk_buff *skb;
 
         fip = container_of(recv_work, struct fcoe_ctlr, recv_work);
-        spin_lock_bh(&fip->fip_recv_list.lock);
-        while ((skb = __skb_dequeue(&fip->fip_recv_list))) {
-                spin_unlock_bh(&fip->fip_recv_list.lock);
+        while ((skb = skb_dequeue(&fip->fip_recv_list)))
                 fcoe_ctlr_recv_handler(fip, skb);
-                spin_lock_bh(&fip->fip_recv_list.lock);
-        }
-        spin_unlock_bh(&fip->fip_recv_list.lock);
 }
 
 /**
- * fcoe_ctlr_recv_flogi() - snoop Pre-FIP receipt of FLOGI response or request.
- * @fip:        FCoE controller.
- * @fp:         FC frame.
- * @sa:         Ethernet source MAC address from received FCoE frame.
+ * fcoe_ctlr_recv_flogi() - Snoop pre-FIP receipt of FLOGI response
+ * @fip: The FCoE controller
+ * @fp:  The FC frame to snoop
  *
  * Snoop potential response to FLOGI or even incoming FLOGI.
  *
@@ -1245,15 +1282,18 @@ static void fcoe_ctlr_recv_work(struct work_struct *recv_work)
  * by fip->flogi_oxid != FC_XID_UNKNOWN.
  *
  * The caller is responsible for freeing the frame.
+ * Fill in the granted_mac address.
  *
  * Return non-zero if the frame should not be delivered to libfc.
  */
-int fcoe_ctlr_recv_flogi(struct fcoe_ctlr *fip, struct fc_frame *fp, u8 *sa)
+int fcoe_ctlr_recv_flogi(struct fcoe_ctlr *fip, struct fc_lport *lport,
+                         struct fc_frame *fp)
 {
         struct fc_frame_header *fh;
         u8 op;
-        u8 mac[ETH_ALEN];
+        u8 *sa;
 
+        sa = eth_hdr(&fp->skb)->h_source;
         fh = fc_frame_header_get(fp);
         if (fh->fh_type != FC_TYPE_ELS)
                 return 0;
@@ -1268,7 +1308,8 @@ int fcoe_ctlr_recv_flogi(struct fcoe_ctlr *fip, struct fc_frame *fp, u8 *sa)
                         return -EINVAL;
                 }
                 fip->state = FIP_ST_NON_FIP;
-                LIBFCOE_FIP_DBG("received FLOGI LS_ACC using non-FIP mode\n");
+                LIBFCOE_FIP_DBG(fip,
+                                "received FLOGI LS_ACC using non-FIP mode\n");
 
                 /*
                  * FLOGI accepted.
@@ -1283,11 +1324,8 @@ int fcoe_ctlr_recv_flogi(struct fcoe_ctlr *fip, struct fc_frame *fp, u8 *sa)
                         fip->map_dest = 0;
                 }
                 fip->flogi_oxid = FC_XID_UNKNOWN;
-                memcpy(mac, fip->data_src_addr, ETH_ALEN);
-                fc_fcoe_set_mac(fip->data_src_addr, fh->fh_d_id);
                 spin_unlock_bh(&fip->lock);
-
-                fip->update_mac(fip, mac, fip->data_src_addr);
+                fc_fcoe_set_mac(fr_cb(fp)->granted_mac, fh->fh_d_id);
         } else if (op == ELS_FLOGI && fh->fh_r_ctl == FC_RCTL_ELS_REQ && sa) {
                 /*
                  * Save source MAC for point-to-point responses.
@@ -1297,7 +1335,7 @@ int fcoe_ctlr_recv_flogi(struct fcoe_ctlr *fip, struct fc_frame *fp, u8 *sa)
                         memcpy(fip->dest_addr, sa, ETH_ALEN);
                         fip->map_dest = 0;
                         if (fip->state == FIP_ST_NON_FIP)
-                                LIBFCOE_FIP_DBG("received FLOGI REQ, "
+                                LIBFCOE_FIP_DBG(fip, "received FLOGI REQ, "
                                                 "using non-FIP mode\n");
                         fip->state = FIP_ST_NON_FIP;
                 }
@@ -1308,10 +1346,10 @@ int fcoe_ctlr_recv_flogi(struct fcoe_ctlr *fip, struct fc_frame *fp, u8 *sa)
 EXPORT_SYMBOL(fcoe_ctlr_recv_flogi);
 
 /**
- * fcoe_wwn_from_mac() - Converts 48-bit IEEE MAC address to 64-bit FC WWN.
- * @mac: mac address
- * @scheme: check port
- * @port: port indicator for converting
+ * fcoe_wwn_from_mac() - Converts a 48-bit IEEE MAC address to a 64-bit FC WWN
+ * @mac:    The MAC address to convert
+ * @scheme: The scheme to use when converting
+ * @port:   The port indicator for converting
  *
  * Returns: u64 fc world wide name
  */
@@ -1349,24 +1387,26 @@ u64 fcoe_wwn_from_mac(unsigned char mac[MAX_ADDR_LEN],
 EXPORT_SYMBOL_GPL(fcoe_wwn_from_mac);
 
 /**
- * fcoe_libfc_config() - sets up libfc related properties for lport
- * @lp: ptr to the fc_lport
- * @tt: libfc function template
+ * fcoe_libfc_config() - Sets up libfc related properties for local port
+ * @lp: The local port to configure libfc for
+ * @tt: The libfc function template
  *
  * Returns : 0 for success
  */
-int fcoe_libfc_config(struct fc_lport *lp, struct libfc_function_template *tt)
+int fcoe_libfc_config(struct fc_lport *lport,
+                      struct libfc_function_template *tt)
 {
         /* Set the function pointers set by the LLDD */
-        memcpy(&lp->tt, tt, sizeof(*tt));
-        if (fc_fcp_init(lp))
+        memcpy(&lport->tt, tt, sizeof(*tt));
+        if (fc_fcp_init(lport))
                 return -ENOMEM;
-        fc_exch_init(lp);
-        fc_elsct_init(lp);
-        fc_lport_init(lp);
-        fc_rport_init(lp);
-        fc_disc_init(lp);
+        fc_exch_init(lport);
+        fc_elsct_init(lport);
+        fc_lport_init(lport);
+        fc_rport_init(lport);
+        fc_disc_init(lport);
 
         return 0;
 }
 EXPORT_SYMBOL_GPL(fcoe_libfc_config);
+
diff --git a/drivers/scsi/fd_mcs.c b/drivers/scsi/fd_mcs.c
index 85bd54c77b50..2ad95aa8f585 100644
--- a/drivers/scsi/fd_mcs.c
+++ b/drivers/scsi/fd_mcs.c
@@ -88,6 +88,7 @@
 #include <linux/delay.h>
 #include <linux/mca.h>
 #include <linux/spinlock.h>
+#include <linux/slab.h>
 #include <scsi/scsicam.h>
 #include <linux/mca-legacy.h>
 
diff --git a/drivers/scsi/fdomain.c b/drivers/scsi/fdomain.c
index 32eef66114c7..e296bcc57d5c 100644
--- a/drivers/scsi/fdomain.c
+++ b/drivers/scsi/fdomain.c
@@ -279,6 +279,7 @@
 #include <linux/stat.h>
 #include <linux/delay.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 #include <scsi/scsicam.h>
 
 #include <asm/system.h>
diff --git a/drivers/scsi/fnic/fnic.h b/drivers/scsi/fnic/fnic.h
index e4c0a3d7d87b..3966c71d0095 100644
--- a/drivers/scsi/fnic/fnic.h
+++ b/drivers/scsi/fnic/fnic.h
@@ -22,6 +22,7 @@
 #include <linux/netdevice.h>
 #include <linux/workqueue.h>
 #include <scsi/libfc.h>
+#include <scsi/libfcoe.h>
 #include "fnic_io.h"
 #include "fnic_res.h"
 #include "vnic_dev.h"
@@ -35,7 +36,7 @@
 
 #define DRV_NAME                "fnic"
 #define DRV_DESCRIPTION         "Cisco FCoE HBA Driver"
-#define DRV_VERSION             "1.0.0.1121"
+#define DRV_VERSION             "1.4.0.98"
 #define PFX                     DRV_NAME ": "
 #define DFX                     DRV_NAME "%d: "
 
@@ -44,7 +45,7 @@
 #define FNIC_IO_LOCKS           64 /* IO locks: power of 2 */
 #define FNIC_DFLT_QUEUE_DEPTH   32
 #define FNIC_STATS_RATE_LIMIT   4 /* limit rate at which stats are pulled up */
-
+#define FNIC_MAX_CMD_LEN        16 /* Supported CDB length */
 /*
  * Tag bits used for special requests.
  */
@@ -145,6 +146,7 @@ struct mempool;
 /* Per-instance private data structure */
 struct fnic {
         struct fc_lport *lport;
+        struct fcoe_ctlr ctlr;          /* FIP FCoE controller structure */
         struct vnic_dev_bar bar0;
 
         struct msix_entry msix_entry[FNIC_MSIX_INTR_MAX];
@@ -162,23 +164,16 @@ struct fnic {
         unsigned int wq_count;
         unsigned int cq_count;
 
-        u32 fcoui_mode:1;               /* use fcoui address*/
         u32 vlan_hw_insert:1;           /* let hw insert the tag */
         u32 in_remove:1;                /* fnic device in removal */
         u32 stop_rx_link_events:1;      /* stop proc. rx frames, link events */
 
         struct completion *remove_wait; /* device remove thread blocks */
 
-        struct fc_frame *flogi;
-        struct fc_frame *flogi_resp;
-        u16 flogi_oxid;
-        unsigned long s_id;
         enum fnic_state state;
         spinlock_t fnic_lock;
 
         u16 vlan_id;                    /* VLAN tag including priority */
-        u8 mac_addr[ETH_ALEN];
-        u8 dest_addr[ETH_ALEN];
         u8 data_src_addr[ETH_ALEN];
         u64 fcp_input_bytes;            /* internal statistic */
         u64 fcp_output_bytes;           /* internal statistic */
@@ -205,6 +200,7 @@ struct fnic {
         struct work_struct link_work;
         struct work_struct frame_work;
         struct sk_buff_head frame_queue;
+        struct sk_buff_head tx_queue;
 
         /* copy work queue cache line section */
         ____cacheline_aligned struct vnic_wq_copy wq_copy[FNIC_WQ_COPY_MAX];
@@ -224,6 +220,11 @@ struct fnic {
         ____cacheline_aligned struct vnic_intr intr[FNIC_MSIX_INTR_MAX];
 };
 
+static inline struct fnic *fnic_from_ctlr(struct fcoe_ctlr *fip)
+{
+        return container_of(fip, struct fnic, ctlr);
+}
+
 extern struct workqueue_struct *fnic_event_queue;
 extern struct device_attribute *fnic_attrs[];
 
@@ -239,7 +240,11 @@ void fnic_handle_link(struct work_struct *work);
 int fnic_rq_cmpl_handler(struct fnic *fnic, int);
 int fnic_alloc_rq_frame(struct vnic_rq *rq);
 void fnic_free_rq_buf(struct vnic_rq *rq, struct vnic_rq_buf *buf);
-int fnic_send_frame(struct fnic *fnic, struct fc_frame *fp);
+void fnic_flush_tx(struct fnic *);
+void fnic_eth_send(struct fcoe_ctlr *, struct sk_buff *skb);
+void fnic_set_port_id(struct fc_lport *, u32, struct fc_frame *);
+void fnic_update_mac(struct fc_lport *, u8 *new);
+void fnic_update_mac_locked(struct fnic *, u8 *new);
 
 int fnic_queuecommand(struct scsi_cmnd *, void (*done)(struct scsi_cmnd *));
 int fnic_abort_cmd(struct scsi_cmnd *);
@@ -252,7 +257,7 @@ void fnic_empty_scsi_cleanup(struct fc_lport *);
 void fnic_exch_mgr_reset(struct fc_lport *, u32, u32);
 int fnic_wq_copy_cmpl_handler(struct fnic *fnic, int);
 int fnic_wq_cmpl_handler(struct fnic *fnic, int);
-int fnic_flogi_reg_handler(struct fnic *fnic);
+int fnic_flogi_reg_handler(struct fnic *fnic, u32);
 void fnic_wq_copy_cleanup_handler(struct vnic_wq_copy *wq,
                                   struct fcpio_host_req *desc);
 int fnic_fw_reset_handler(struct fnic *fnic);
diff --git a/drivers/scsi/fnic/fnic_fcs.c b/drivers/scsi/fnic/fnic_fcs.c
index 50db3e36a619..5259888fbfb1 100644
--- a/drivers/scsi/fnic/fnic_fcs.c
+++ b/drivers/scsi/fnic/fnic_fcs.c
@@ -17,12 +17,14 @@
  */
 #include <linux/errno.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <linux/skbuff.h>
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
 #include <linux/if_ether.h>
 #include <linux/if_vlan.h>
 #include <linux/workqueue.h>
+#include <scsi/fc/fc_fip.h>
 #include <scsi/fc/fc_els.h>
 #include <scsi/fc/fc_fcoe.h>
 #include <scsi/fc_frame.h>
@@ -34,6 +36,8 @@
 
 struct workqueue_struct *fnic_event_queue;
 
+static void fnic_set_eth_mode(struct fnic *);
+
 void fnic_handle_link(struct work_struct *work)
 {
         struct fnic *fnic = container_of(work, struct fnic, link_work);
@@ -64,10 +68,10 @@ void fnic_handle_link(struct work_struct *work)
                                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
                                 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
                                              "link down\n");
-                                fc_linkdown(fnic->lport);
+                                fcoe_ctlr_link_down(&fnic->ctlr);
                                 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
                                              "link up\n");
-                                fc_linkup(fnic->lport);
+                                fcoe_ctlr_link_up(&fnic->ctlr);
                         } else
                                 /* UP -> UP */
                                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
@@ -76,13 +80,13 @@ void fnic_handle_link(struct work_struct *work)
                 /* DOWN -> UP */
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
                 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "link up\n");
-                fc_linkup(fnic->lport);
+                fcoe_ctlr_link_up(&fnic->ctlr);
         } else {
                 /* UP -> DOWN */
                 fnic->lport->host_stats.link_failure_count++;
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
                 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "link down\n");
-                fc_linkdown(fnic->lport);
+                fcoe_ctlr_link_down(&fnic->ctlr);
         }
 
 }
@@ -107,197 +111,179 @@ void fnic_handle_frame(struct work_struct *work)
                         return;
                 }
                 fp = (struct fc_frame *)skb;
-                /* if Flogi resp frame, register the address */
-                if (fr_flags(fp)) {
-                        vnic_dev_add_addr(fnic->vdev,
-                                          fnic->data_src_addr);
-                        fr_flags(fp) = 0;
+
+                /*
+                 * If we're in a transitional state, just re-queue and return.
+                 * The queue will be serviced when we get to a stable state.
+                 */
+                if (fnic->state != FNIC_IN_FC_MODE &&
+                    fnic->state != FNIC_IN_ETH_MODE) {
+                        skb_queue_head(&fnic->frame_queue, skb);
+                        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+                        return;
                 }
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
                 fc_exch_recv(lp, fp);
         }
-
-}
-
-static inline void fnic_import_rq_fc_frame(struct sk_buff *skb,
-                                           u32 len, u8 sof, u8 eof)
-{
-        struct fc_frame *fp = (struct fc_frame *)skb;
-
-        skb_trim(skb, len);
-        fr_eof(fp) = eof;
-        fr_sof(fp) = sof;
 }
 
-
-static inline int fnic_import_rq_eth_pkt(struct sk_buff *skb, u32 len)
+/**
+ * fnic_import_rq_eth_pkt() - handle received FCoE or FIP frame.
+ * @fnic:       fnic instance.
+ * @skb:        Ethernet Frame.
+ */
+static inline int fnic_import_rq_eth_pkt(struct fnic *fnic, struct sk_buff *skb)
 {
         struct fc_frame *fp;
         struct ethhdr *eh;
-        struct vlan_ethhdr *vh;
         struct fcoe_hdr *fcoe_hdr;
         struct fcoe_crc_eof *ft;
-        u32    transport_len = 0;
 
+        /*
+         * Undo VLAN encapsulation if present.
+         */
         eh = (struct ethhdr *)skb->data;
-        vh = (struct vlan_ethhdr *)skb->data;
-        if (vh->h_vlan_proto == htons(ETH_P_8021Q) &&
-            vh->h_vlan_encapsulated_proto == htons(ETH_P_FCOE)) {
-                skb_pull(skb, sizeof(struct vlan_ethhdr));
-                transport_len += sizeof(struct vlan_ethhdr);
-        } else if (eh->h_proto == htons(ETH_P_FCOE)) {
-                transport_len += sizeof(struct ethhdr);
-                skb_pull(skb, sizeof(struct ethhdr));
-        } else
-                return -1;
+        if (eh->h_proto == htons(ETH_P_8021Q)) {
+                memmove((u8 *)eh + VLAN_HLEN, eh, ETH_ALEN * 2);
+                eh = (struct ethhdr *)skb_pull(skb, VLAN_HLEN);
+                skb_reset_mac_header(skb);
+        }
+        if (eh->h_proto == htons(ETH_P_FIP)) {
+                skb_pull(skb, sizeof(*eh));
+                fcoe_ctlr_recv(&fnic->ctlr, skb);
+                return 1;               /* let caller know packet was used */
+        }
+        if (eh->h_proto != htons(ETH_P_FCOE))
+                goto drop;
+        skb_set_network_header(skb, sizeof(*eh));
+        skb_pull(skb, sizeof(*eh));
 
         fcoe_hdr = (struct fcoe_hdr *)skb->data;
         if (FC_FCOE_DECAPS_VER(fcoe_hdr) != FC_FCOE_VER)
-                return -1;
+                goto drop;
 
         fp = (struct fc_frame *)skb;
         fc_frame_init(fp);
         fr_sof(fp) = fcoe_hdr->fcoe_sof;
         skb_pull(skb, sizeof(struct fcoe_hdr));
-        transport_len += sizeof(struct fcoe_hdr);
+        skb_reset_transport_header(skb);
 
-        ft = (struct fcoe_crc_eof *)(skb->data + len -
-                                     transport_len - sizeof(*ft));
+        ft = (struct fcoe_crc_eof *)(skb->data + skb->len - sizeof(*ft));
         fr_eof(fp) = ft->fcoe_eof;
-        skb_trim(skb, len - transport_len - sizeof(*ft));
+        skb_trim(skb, skb->len - sizeof(*ft));
         return 0;
+drop:
+        dev_kfree_skb_irq(skb);
+        return -1;
 }
 
-static inline int fnic_handle_flogi_resp(struct fnic *fnic,
-                                         struct fc_frame *fp)
+/**
+ * fnic_update_mac_locked() - set data MAC address and filters.
+ * @fnic:       fnic instance.
+ * @new:        newly-assigned FCoE MAC address.
+ *
+ * Called with the fnic lock held.
+ */
+void fnic_update_mac_locked(struct fnic *fnic, u8 *new)
 {
-        u8 mac[ETH_ALEN] = FC_FCOE_FLOGI_MAC;
-        struct ethhdr *eth_hdr;
-        struct fc_frame_header *fh;
-        int ret = 0;
-        unsigned long flags;
-        struct fc_frame *old_flogi_resp = NULL;
+        u8 *ctl = fnic->ctlr.ctl_src_addr;
+        u8 *data = fnic->data_src_addr;
 
-        fh = (struct fc_frame_header *)fr_hdr(fp);
+        if (is_zero_ether_addr(new))
+                new = ctl;
+        if (!compare_ether_addr(data, new))
+                return;
+        FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "update_mac %pM\n", new);
+        if (!is_zero_ether_addr(data) && compare_ether_addr(data, ctl))
+                vnic_dev_del_addr(fnic->vdev, data);
+        memcpy(data, new, ETH_ALEN);
+        if (compare_ether_addr(new, ctl))
+                vnic_dev_add_addr(fnic->vdev, new);
+}
 
-        spin_lock_irqsave(&fnic->fnic_lock, flags);
+/**
+ * fnic_update_mac() - set data MAC address and filters.
+ * @lport:      local port.
+ * @new:        newly-assigned FCoE MAC address.
+ */
+void fnic_update_mac(struct fc_lport *lport, u8 *new)
+{
+        struct fnic *fnic = lport_priv(lport);
 
-        if (fnic->state == FNIC_IN_ETH_MODE) {
+        spin_lock_irq(&fnic->fnic_lock);
+        fnic_update_mac_locked(fnic, new);
+        spin_unlock_irq(&fnic->fnic_lock);
+}
 
-                /*
-                 * Check if oxid matches on taking the lock. A new Flogi
-                 * issued by libFC might have changed the fnic cached oxid
-                 */
-                if (fnic->flogi_oxid != ntohs(fh->fh_ox_id)) {
-                        FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
-                                     "Flogi response oxid not"
-                                     " matching cached oxid, dropping frame"
-                                     "\n");
-                        ret = -1;
-                        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                        dev_kfree_skb_irq(fp_skb(fp));
-                        goto handle_flogi_resp_end;
-                }
+/**
+ * fnic_set_port_id() - set the port_ID after successful FLOGI.
+ * @lport:      local port.
+ * @port_id:    assigned FC_ID.
+ * @fp:         received frame containing the FLOGI accept or NULL.
+ *
+ * This is called from libfc when a new FC_ID has been assigned.
+ * This causes us to reset the firmware to FC_MODE and setup the new MAC
+ * address and FC_ID.
+ *
+ * It is also called with FC_ID 0 when we're logged off.
+ *
+ * If the FC_ID is due to point-to-point, fp may be NULL.
+ */
+void fnic_set_port_id(struct fc_lport *lport, u32 port_id, struct fc_frame *fp)
+{
+        struct fnic *fnic = lport_priv(lport);
+        u8 *mac;
+        int ret;
 
-                /* Drop older cached flogi response frame, cache this frame */
-                old_flogi_resp = fnic->flogi_resp;
-                fnic->flogi_resp = fp;
-                fnic->flogi_oxid = FC_XID_UNKNOWN;
+        FNIC_FCS_DBG(KERN_DEBUG, lport->host, "set port_id %x fp %p\n",
+                     port_id, fp);
 
-                /*
-                 * this frame is part of flogi get the src mac addr from this
-                 * frame if the src mac is fcoui based then we mark the
-                 * address mode flag to use fcoui base for dst mac addr
-                 * otherwise we have to store the fcoe gateway addr
-                 */
-                eth_hdr = (struct ethhdr *)skb_mac_header(fp_skb(fp));
-                memcpy(mac, eth_hdr->h_source, ETH_ALEN);
+        /*
+         * If we're clearing the FC_ID, change to use the ctl_src_addr.
+         * Set ethernet mode to send FLOGI.
+         */
+        if (!port_id) {
+                fnic_update_mac(lport, fnic->ctlr.ctl_src_addr);
+                fnic_set_eth_mode(fnic);
+                return;
+        }
 
-                if (ntoh24(mac) == FC_FCOE_OUI)
-                        fnic->fcoui_mode = 1;
-                else {
-                        fnic->fcoui_mode = 0;
-                        memcpy(fnic->dest_addr, mac, ETH_ALEN);
+        if (fp) {
+                mac = fr_cb(fp)->granted_mac;
+                if (is_zero_ether_addr(mac)) {
+                        /* non-FIP - FLOGI already accepted - ignore return */
+                        fcoe_ctlr_recv_flogi(&fnic->ctlr, lport, fp);
                 }
+                fnic_update_mac(lport, mac);
+        }
 
-                /*
-                 * Except for Flogi frame, all outbound frames from us have the
-                 * Eth Src address as FC_FCOE_OUI"our_sid". Flogi frame uses
-                 * the vnic MAC address as the Eth Src address
-                 */
-                fc_fcoe_set_mac(fnic->data_src_addr, fh->fh_d_id);
-
-                /* We get our s_id from the d_id of the flogi resp frame */
-                fnic->s_id = ntoh24(fh->fh_d_id);
-
-                /* Change state to reflect transition from Eth to FC mode */
+        /* Change state to reflect transition to FC mode */
+        spin_lock_irq(&fnic->fnic_lock);
+        if (fnic->state == FNIC_IN_ETH_MODE || fnic->state == FNIC_IN_FC_MODE)
                 fnic->state = FNIC_IN_ETH_TRANS_FC_MODE;
-
-        } else {
+        else {
                 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
                              "Unexpected fnic state %s while"
                              " processing flogi resp\n",
                              fnic_state_to_str(fnic->state));
-                ret = -1;
-                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                dev_kfree_skb_irq(fp_skb(fp));
-                goto handle_flogi_resp_end;
+                spin_unlock_irq(&fnic->fnic_lock);
+                return;
         }
-
-        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-
-        /* Drop older cached frame */
-        if (old_flogi_resp)
-                dev_kfree_skb_irq(fp_skb(old_flogi_resp));
+        spin_unlock_irq(&fnic->fnic_lock);
 
         /*
-         * send flogi reg request to firmware, this will put the fnic in
-         * in FC mode
+         * Send FLOGI registration to firmware to set up FC mode.
+         * The new address will be set up when registration completes.
          */
-        ret = fnic_flogi_reg_handler(fnic);
+        ret = fnic_flogi_reg_handler(fnic, port_id);
 
         if (ret < 0) {
-                int free_fp = 1;
-                spin_lock_irqsave(&fnic->fnic_lock, flags);
-                /*
-                 * free the frame is some other thread is not
-                 * pointing to it
-                 */
-                if (fnic->flogi_resp != fp)
-                        free_fp = 0;
-                else
-                        fnic->flogi_resp = NULL;
-
+                spin_lock_irq(&fnic->fnic_lock);
                 if (fnic->state == FNIC_IN_ETH_TRANS_FC_MODE)
                         fnic->state = FNIC_IN_ETH_MODE;
-                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                if (free_fp)
-                        dev_kfree_skb_irq(fp_skb(fp));
+                spin_unlock_irq(&fnic->fnic_lock);
         }
-
- handle_flogi_resp_end:
-        return ret;
-}
-
-/* Returns 1 for a response that matches cached flogi oxid */
-static inline int is_matching_flogi_resp_frame(struct fnic *fnic,
-                                               struct fc_frame *fp)
-{
-        struct fc_frame_header *fh;
-        int ret = 0;
-        u32 f_ctl;
-
-        fh = fc_frame_header_get(fp);
-        f_ctl = ntoh24(fh->fh_f_ctl);
-
-        if (fnic->flogi_oxid == ntohs(fh->fh_ox_id) &&
-            fh->fh_r_ctl == FC_RCTL_ELS_REP &&
-            (f_ctl & (FC_FC_EX_CTX | FC_FC_SEQ_CTX)) == FC_FC_EX_CTX &&
-            fh->fh_type == FC_TYPE_ELS)
-                ret = 1;
-
-        return ret;
 }
 
 static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
@@ -326,6 +312,7 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
         pci_unmap_single(fnic->pdev, buf->dma_addr, buf->len,
                          PCI_DMA_FROMDEVICE);
         skb = buf->os_buf;
+        fp = (struct fc_frame *)skb;
         buf->os_buf = NULL;
 
         cq_desc_dec(cq_desc, &type, &color, &q_number, &completed_index);
@@ -338,6 +325,9 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
                                    &fcoe_enc_error, &fcs_ok, &vlan_stripped,
                                    &vlan);
                 eth_hdrs_stripped = 1;
+                skb_trim(skb, fcp_bytes_written);
+                fr_sof(fp) = sof;
+                fr_eof(fp) = eof;
 
         } else if (type == CQ_DESC_TYPE_RQ_ENET) {
                 cq_enet_rq_desc_dec((struct cq_enet_rq_desc *)cq_desc,
@@ -352,6 +342,14 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
                                     &ipv4_csum_ok, &ipv6, &ipv4,
                                     &ipv4_fragment, &fcs_ok);
                 eth_hdrs_stripped = 0;
+                skb_trim(skb, bytes_written);
+                if (!fcs_ok) {
+                        FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
+                                     "fcs error.  dropping packet.\n");
+                        goto drop;
+                }
+                if (fnic_import_rq_eth_pkt(fnic, skb))
+                        return;
 
         } else {
                 /* wrong CQ type*/
@@ -370,43 +368,11 @@ static void fnic_rq_cmpl_frame_recv(struct vnic_rq *rq, struct cq_desc
                 goto drop;
         }
 
-        if (eth_hdrs_stripped)
-                fnic_import_rq_fc_frame(skb, fcp_bytes_written, sof, eof);
-        else if (fnic_import_rq_eth_pkt(skb, bytes_written))
-                goto drop;
-
-        fp = (struct fc_frame *)skb;
-
-        /*
-         * If frame is an ELS response that matches the cached FLOGI OX_ID,
-         * and is accept, issue flogi_reg_request copy wq request to firmware
-         * to register the S_ID and determine whether FC_OUI mode or GW mode.
-         */
-        if (is_matching_flogi_resp_frame(fnic, fp)) {
-                if (!eth_hdrs_stripped) {
-                        if (fc_frame_payload_op(fp) == ELS_LS_ACC) {
-                                fnic_handle_flogi_resp(fnic, fp);
-                                return;
-                        }
-                        /*
-                         * Recd. Flogi reject. No point registering
-                         * with fw, but forward to libFC
-                         */
-                        goto forward;
-                }
-                goto drop;
-        }
-        if (!eth_hdrs_stripped)
-                goto drop;
-
-forward:
         spin_lock_irqsave(&fnic->fnic_lock, flags);
         if (fnic->stop_rx_link_events) {
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
                 goto drop;
         }
-        /* Use fr_flags to indicate whether succ. flogi resp or not */
-        fr_flags(fp) = 0;
         fr_dev(fp) = fnic->lport;
         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
@@ -494,12 +460,49 @@ void fnic_free_rq_buf(struct vnic_rq *rq, struct vnic_rq_buf *buf)
         buf->os_buf = NULL;
 }
 
-static inline int is_flogi_frame(struct fc_frame_header *fh)
+/**
+ * fnic_eth_send() - Send Ethernet frame.
+ * @fip:        fcoe_ctlr instance.
+ * @skb:        Ethernet Frame, FIP, without VLAN encapsulation.
+ */
+void fnic_eth_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
 {
-        return fh->fh_r_ctl == FC_RCTL_ELS_REQ && *(u8 *)(fh + 1) == ELS_FLOGI;
+        struct fnic *fnic = fnic_from_ctlr(fip);
+        struct vnic_wq *wq = &fnic->wq[0];
+        dma_addr_t pa;
+        struct ethhdr *eth_hdr;
+        struct vlan_ethhdr *vlan_hdr;
+        unsigned long flags;
+
+        if (!fnic->vlan_hw_insert) {
+                eth_hdr = (struct ethhdr *)skb_mac_header(skb);
+                vlan_hdr = (struct vlan_ethhdr *)skb_push(skb,
+                                sizeof(*vlan_hdr) - sizeof(*eth_hdr));
+                memcpy(vlan_hdr, eth_hdr, 2 * ETH_ALEN);
+                vlan_hdr->h_vlan_proto = htons(ETH_P_8021Q);
+                vlan_hdr->h_vlan_encapsulated_proto = eth_hdr->h_proto;
+                vlan_hdr->h_vlan_TCI = htons(fnic->vlan_id);
+        }
+
+        pa = pci_map_single(fnic->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
+
+        spin_lock_irqsave(&fnic->wq_lock[0], flags);
+        if (!vnic_wq_desc_avail(wq)) {
+                pci_unmap_single(fnic->pdev, pa, skb->len, PCI_DMA_TODEVICE);
+                spin_unlock_irqrestore(&fnic->wq_lock[0], flags);
+                kfree_skb(skb);
+                return;
+        }
+
+        fnic_queue_wq_eth_desc(wq, skb, pa, skb->len,
+                               fnic->vlan_hw_insert, fnic->vlan_id, 1);
+        spin_unlock_irqrestore(&fnic->wq_lock[0], flags);
 }
 
-int fnic_send_frame(struct fnic *fnic, struct fc_frame *fp)
+/*
+ * Send FC frame.
+ */
+static int fnic_send_frame(struct fnic *fnic, struct fc_frame *fp)
 {
         struct vnic_wq *wq = &fnic->wq[0];
         struct sk_buff *skb;
@@ -515,6 +518,10 @@ int fnic_send_frame(struct fnic *fnic, struct fc_frame *fp)
         fh = fc_frame_header_get(fp);
         skb = fp_skb(fp);
 
+        if (unlikely(fh->fh_r_ctl == FC_RCTL_ELS_REQ) &&
+            fcoe_ctlr_els_send(&fnic->ctlr, fnic->lport, skb))
+                return 0;
+
         if (!fnic->vlan_hw_insert) {
                 eth_hdr_len = sizeof(*vlan_hdr) + sizeof(*fcoe_hdr);
                 vlan_hdr = (struct vlan_ethhdr *)skb_push(skb, eth_hdr_len);
@@ -530,16 +537,11 @@ int fnic_send_frame(struct fnic *fnic, struct fc_frame *fp)
                 fcoe_hdr = (struct fcoe_hdr *)(eth_hdr + 1);
         }
 
-        if (is_flogi_frame(fh)) {
+        if (fnic->ctlr.map_dest)
                 fc_fcoe_set_mac(eth_hdr->h_dest, fh->fh_d_id);
-                memcpy(eth_hdr->h_source, fnic->mac_addr, ETH_ALEN);
-        } else {
-                if (fnic->fcoui_mode)
-                        fc_fcoe_set_mac(eth_hdr->h_dest, fh->fh_d_id);
-                else
-                        memcpy(eth_hdr->h_dest, fnic->dest_addr, ETH_ALEN);
-                memcpy(eth_hdr->h_source, fnic->data_src_addr, ETH_ALEN);
-        }
+        else
+                memcpy(eth_hdr->h_dest, fnic->ctlr.dest_addr, ETH_ALEN);
+        memcpy(eth_hdr->h_source, fnic->data_src_addr, ETH_ALEN);
 
         tot_len = skb->len;
         BUG_ON(tot_len % 4);
@@ -578,109 +580,85 @@ fnic_send_frame_end:
 int fnic_send(struct fc_lport *lp, struct fc_frame *fp)
 {
         struct fnic *fnic = lport_priv(lp);
-        struct fc_frame_header *fh;
-        int ret = 0;
-        enum fnic_state old_state;
         unsigned long flags;
-        struct fc_frame *old_flogi = NULL;
-        struct fc_frame *old_flogi_resp = NULL;
 
         if (fnic->in_remove) {
                 dev_kfree_skb(fp_skb(fp));
-                ret = -1;
-                goto fnic_send_end;
+                return -1;
         }
 
-        fh = fc_frame_header_get(fp);
-        /* if not an Flogi frame, send it out, this is the common case */
-        if (!is_flogi_frame(fh))
-                return fnic_send_frame(fnic, fp);
+        /*
+         * Queue frame if in a transitional state.
+         * This occurs while registering the Port_ID / MAC address after FLOGI.
+         */
+        spin_lock_irqsave(&fnic->fnic_lock, flags);
+        if (fnic->state != FNIC_IN_FC_MODE && fnic->state != FNIC_IN_ETH_MODE) {
+                skb_queue_tail(&fnic->tx_queue, fp_skb(fp));
+                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+                return 0;
+        }
+        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
-        /* Flogi frame, now enter the state machine */
+        return fnic_send_frame(fnic, fp);
+}
 
-        spin_lock_irqsave(&fnic->fnic_lock, flags);
-again:
-        /* Get any old cached frames, free them after dropping lock */
-        old_flogi = fnic->flogi;
-        fnic->flogi = NULL;
-        old_flogi_resp = fnic->flogi_resp;
-        fnic->flogi_resp = NULL;
+/**
+ * fnic_flush_tx() - send queued frames.
+ * @fnic: fnic device
+ *
+ * Send frames that were waiting to go out in FC or Ethernet mode.
+ * Whenever changing modes we purge queued frames, so these frames should
+ * be queued for the stable mode that we're in, either FC or Ethernet.
+ *
+ * Called without fnic_lock held.
+ */
+void fnic_flush_tx(struct fnic *fnic)
+{
+        struct sk_buff *skb;
+        struct fc_frame *fp;
 
-        fnic->flogi_oxid = FC_XID_UNKNOWN;
+        while ((skb = skb_dequeue(&fnic->frame_queue))) {
+                fp = (struct fc_frame *)skb;
+                fnic_send_frame(fnic, fp);
+        }
+}
 
+/**
+ * fnic_set_eth_mode() - put fnic into ethernet mode.
+ * @fnic: fnic device
+ *
+ * Called without fnic lock held.
+ */
+static void fnic_set_eth_mode(struct fnic *fnic)
+{
+        unsigned long flags;
+        enum fnic_state old_state;
+        int ret;
+
+        spin_lock_irqsave(&fnic->fnic_lock, flags);
+again:
         old_state = fnic->state;
         switch (old_state) {
         case FNIC_IN_FC_MODE:
         case FNIC_IN_ETH_TRANS_FC_MODE:
         default:
                 fnic->state = FNIC_IN_FC_TRANS_ETH_MODE;
-                vnic_dev_del_addr(fnic->vdev, fnic->data_src_addr);
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
-                if (old_flogi) {
-                        dev_kfree_skb(fp_skb(old_flogi));
-                        old_flogi = NULL;
-                }
-                if (old_flogi_resp) {
-                        dev_kfree_skb(fp_skb(old_flogi_resp));
-                        old_flogi_resp = NULL;
-                }
-
                 ret = fnic_fw_reset_handler(fnic);
 
                 spin_lock_irqsave(&fnic->fnic_lock, flags);
                 if (fnic->state != FNIC_IN_FC_TRANS_ETH_MODE)
                         goto again;
-                if (ret) {
+                if (ret)
                         fnic->state = old_state;
-                        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                        dev_kfree_skb(fp_skb(fp));
-                        goto fnic_send_end;
-                }
-                old_flogi = fnic->flogi;
-                fnic->flogi = fp;
-                fnic->flogi_oxid = ntohs(fh->fh_ox_id);
-                old_flogi_resp = fnic->flogi_resp;
-                fnic->flogi_resp = NULL;
-                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
                 break;
 
         case FNIC_IN_FC_TRANS_ETH_MODE:
-                /*
-                 * A reset is pending with the firmware. Store the flogi
-                 * and its oxid. The transition out of this state happens
-                 * only when Firmware completes the reset, either with
-                 * success or failed. If success, transition to
-                 * FNIC_IN_ETH_MODE, if fail, then transition to
-                 * FNIC_IN_FC_MODE
-                 */
-                fnic->flogi = fp;
-                fnic->flogi_oxid = ntohs(fh->fh_ox_id);
-                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                break;
-
         case FNIC_IN_ETH_MODE:
-                /*
-                 * The fw/hw is already in eth mode. Store the oxid,
-                 * and send the flogi frame out. The transition out of this
-                 * state happens only we receive flogi response from the
-                 * network, and the oxid matches the cached oxid when the
-                 * flogi frame was sent out. If they match, then we issue
-                 * a flogi_reg request and transition to state
-                 * FNIC_IN_ETH_TRANS_FC_MODE
-                 */
-                fnic->flogi_oxid = ntohs(fh->fh_ox_id);
-                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                ret = fnic_send_frame(fnic, fp);
                 break;
         }
-
-fnic_send_end:
-        if (old_flogi)
-                dev_kfree_skb(fp_skb(old_flogi));
-        if (old_flogi_resp)
-                dev_kfree_skb(fp_skb(old_flogi_resp));
-        return ret;
+        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 }
 
 static void fnic_wq_complete_frame_send(struct vnic_wq *wq,
diff --git a/drivers/scsi/fnic/fnic_isr.c b/drivers/scsi/fnic/fnic_isr.c
index 2b3064828aea..5c1f223cabce 100644
--- a/drivers/scsi/fnic/fnic_isr.c
+++ b/drivers/scsi/fnic/fnic_isr.c
@@ -48,9 +48,9 @@ static irqreturn_t fnic_isr_legacy(int irq, void *data)
         }
 
         if (pba & (1 << FNIC_INTX_WQ_RQ_COPYWQ)) {
-                work_done += fnic_wq_copy_cmpl_handler(fnic, 8);
-                work_done += fnic_wq_cmpl_handler(fnic, 4);
-                work_done += fnic_rq_cmpl_handler(fnic, 4);
+                work_done += fnic_wq_copy_cmpl_handler(fnic, -1);
+                work_done += fnic_wq_cmpl_handler(fnic, -1);
+                work_done += fnic_rq_cmpl_handler(fnic, -1);
 
                 vnic_intr_return_credits(&fnic->intr[FNIC_INTX_WQ_RQ_COPYWQ],
                                          work_done,
@@ -66,9 +66,9 @@ static irqreturn_t fnic_isr_msi(int irq, void *data)
         struct fnic *fnic = data;
         unsigned long work_done = 0;
 
-        work_done += fnic_wq_copy_cmpl_handler(fnic, 8);
-        work_done += fnic_wq_cmpl_handler(fnic, 4);
-        work_done += fnic_rq_cmpl_handler(fnic, 4);
+        work_done += fnic_wq_copy_cmpl_handler(fnic, -1);
+        work_done += fnic_wq_cmpl_handler(fnic, -1);
+        work_done += fnic_rq_cmpl_handler(fnic, -1);
 
         vnic_intr_return_credits(&fnic->intr[0],
                                  work_done,
@@ -83,7 +83,7 @@ static irqreturn_t fnic_isr_msix_rq(int irq, void *data)
         struct fnic *fnic = data;
         unsigned long rq_work_done = 0;
 
-        rq_work_done = fnic_rq_cmpl_handler(fnic, 4);
+        rq_work_done = fnic_rq_cmpl_handler(fnic, -1);
         vnic_intr_return_credits(&fnic->intr[FNIC_MSIX_RQ],
                                  rq_work_done,
                                  1 /* unmask intr */,
@@ -97,7 +97,7 @@ static irqreturn_t fnic_isr_msix_wq(int irq, void *data)
         struct fnic *fnic = data;
         unsigned long wq_work_done = 0;
 
-        wq_work_done = fnic_wq_cmpl_handler(fnic, 4);
+        wq_work_done = fnic_wq_cmpl_handler(fnic, -1);
         vnic_intr_return_credits(&fnic->intr[FNIC_MSIX_WQ],
                                  wq_work_done,
                                  1 /* unmask intr */,
@@ -110,7 +110,7 @@ static irqreturn_t fnic_isr_msix_wq_copy(int irq, void *data)
         struct fnic *fnic = data;
         unsigned long wq_copy_work_done = 0;
 
-        wq_copy_work_done = fnic_wq_copy_cmpl_handler(fnic, 8);
+        wq_copy_work_done = fnic_wq_copy_cmpl_handler(fnic, -1);
         vnic_intr_return_credits(&fnic->intr[FNIC_MSIX_WQ_COPY],
                                  wq_copy_work_done,
                                  1 /* unmask intr */,
diff --git a/drivers/scsi/fnic/fnic_main.c b/drivers/scsi/fnic/fnic_main.c
index 71c7bbe26d05..97b212570bcc 100644
--- a/drivers/scsi/fnic/fnic_main.c
+++ b/drivers/scsi/fnic/fnic_main.c
@@ -18,6 +18,7 @@
 #include <linux/module.h>
 #include <linux/mempool.h>
 #include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/pci.h>
@@ -25,6 +26,8 @@
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
+#include <linux/if_ether.h>
+#include <scsi/fc/fc_fip.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_transport.h>
 #include <scsi/scsi_transport_fc.h>
@@ -68,6 +71,7 @@ MODULE_PARM_DESC(fnic_log_level, "bit mask of fnic logging levels");
 
 static struct libfc_function_template fnic_transport_template = {
         .frame_send = fnic_send,
+        .lport_set_port_id = fnic_set_port_id,
         .fcp_abort_io = fnic_empty_scsi_cleanup,
         .fcp_cleanup = fnic_empty_scsi_cleanup,
         .exch_mgr_reset = fnic_exch_mgr_reset
@@ -140,6 +144,7 @@ static struct fc_function_template fnic_fc_functions = {
         .get_fc_host_stats = fnic_get_stats,
         .dd_fcrport_size = sizeof(struct fc_rport_libfc_priv),
         .terminate_rport_io = fnic_terminate_rport_io,
+        .bsg_request = fc_lport_bsg_request,
 };
 
 static void fnic_get_host_speed(struct Scsi_Host *shost)
@@ -324,9 +329,6 @@ static int fnic_cleanup(struct fnic *fnic)
 {
         unsigned int i;
         int err;
-        unsigned long flags;
-        struct fc_frame *flogi = NULL;
-        struct fc_frame *flogi_resp = NULL;
 
         vnic_dev_disable(fnic->vdev);
         for (i = 0; i < fnic->intr_count; i++)
@@ -367,24 +369,6 @@ static int fnic_cleanup(struct fnic *fnic)
         for (i = 0; i < fnic->intr_count; i++)
                 vnic_intr_clean(&fnic->intr[i]);
 
-        /*
-         * Remove cached flogi and flogi resp frames if any
-         * These frames are not in any queue, and therefore queue
-         * cleanup does not clean them. So clean them explicitly
-         */
-        spin_lock_irqsave(&fnic->fnic_lock, flags);
-        flogi = fnic->flogi;
-        fnic->flogi = NULL;
-        flogi_resp = fnic->flogi_resp;
-        fnic->flogi_resp = NULL;
-        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-
-        if (flogi)
-                dev_kfree_skb(fp_skb(flogi));
-
-        if (flogi_resp)
-                dev_kfree_skb(fp_skb(flogi_resp));
-
         mempool_destroy(fnic->io_req_pool);
         for (i = 0; i < FNIC_SGL_NUM_CACHES; i++)
                 mempool_destroy(fnic->io_sgl_pool[i]);
@@ -409,6 +393,17 @@ static void *fnic_alloc_slab_dma(gfp_t gfp_mask, void *pool_data)
         return kmem_cache_alloc(mem, gfp_mask | GFP_ATOMIC | GFP_DMA);
 }
 
+/**
+ * fnic_get_mac() - get assigned data MAC address for FIP code.
+ * @lport:      local port.
+ */
+static u8 *fnic_get_mac(struct fc_lport *lport)
+{
+        struct fnic *fnic = lport_priv(lport);
+
+        return fnic->data_src_addr;
+}
+
 static int __devinit fnic_probe(struct pci_dev *pdev,
                                 const struct pci_device_id *ent)
 {
@@ -424,17 +419,16 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
          * Allocate SCSI Host and set up association between host,
          * local port, and fnic
          */
-        host = scsi_host_alloc(&fnic_host_template,
-                               sizeof(struct fc_lport) + sizeof(struct fnic));
-        if (!host) {
-                printk(KERN_ERR PFX "Unable to alloc SCSI host\n");
+        lp = libfc_host_alloc(&fnic_host_template, sizeof(struct fnic));
+        if (!lp) {
+                printk(KERN_ERR PFX "Unable to alloc libfc local port\n");
                 err = -ENOMEM;
                 goto err_out;
         }
-        lp = shost_priv(host);
-        lp->host = host;
+        host = lp->host;
         fnic = lport_priv(lp);
         fnic->lport = lp;
+        fnic->ctlr.lp = lp;
 
         snprintf(fnic->name, sizeof(fnic->name) - 1, "%s%d", DRV_NAME,
                  host->host_no);
@@ -543,12 +537,14 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
                 goto err_out_dev_close;
         }
 
-        err = vnic_dev_mac_addr(fnic->vdev, fnic->mac_addr);
+        err = vnic_dev_mac_addr(fnic->vdev, fnic->ctlr.ctl_src_addr);
         if (err) {
                 shost_printk(KERN_ERR, fnic->lport->host,
                              "vNIC get MAC addr failed \n");
                 goto err_out_dev_close;
         }
+        /* set data_src for point-to-point mode and to keep it non-zero */
+        memcpy(fnic->data_src_addr, fnic->ctlr.ctl_src_addr, ETH_ALEN);
 
         /* Get vNIC configuration */
         err = fnic_get_vnic_config(fnic);
@@ -560,6 +556,7 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
         }
         host->max_lun = fnic->config.luns_per_tgt;
         host->max_id = FNIC_MAX_FCP_TARGET;
+        host->max_cmd_len = FNIC_MAX_CMD_LEN;
 
         fnic_get_res_counts(fnic);
 
@@ -571,19 +568,12 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
                 goto err_out_dev_close;
         }
 
-        err = fnic_request_intr(fnic);
-        if (err) {
-                shost_printk(KERN_ERR, fnic->lport->host,
-                             "Unable to request irq.\n");
-                goto err_out_clear_intr;
-        }
-
         err = fnic_alloc_vnic_resources(fnic);
         if (err) {
                 shost_printk(KERN_ERR, fnic->lport->host,
                              "Failed to alloc vNIC resources, "
                              "aborting.\n");
-                goto err_out_free_intr;
+                goto err_out_clear_intr;
         }
 
 
@@ -623,9 +613,23 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
         fnic->vlan_hw_insert = 1;
         fnic->vlan_id = 0;
 
-        fnic->flogi_oxid = FC_XID_UNKNOWN;
-        fnic->flogi = NULL;
-        fnic->flogi_resp = NULL;
+        /* Initialize the FIP fcoe_ctrl struct */
+        fnic->ctlr.send = fnic_eth_send;
+        fnic->ctlr.update_mac = fnic_update_mac;
+        fnic->ctlr.get_src_addr = fnic_get_mac;
+        fcoe_ctlr_init(&fnic->ctlr);
+        if (fnic->config.flags & VFCF_FIP_CAPABLE) {
+                shost_printk(KERN_INFO, fnic->lport->host,
+                             "firmware supports FIP\n");
+                /* enable directed and multicast */
+                vnic_dev_packet_filter(fnic->vdev, 1, 1, 0, 0, 0);
+                vnic_dev_add_addr(fnic->vdev, FIP_ALL_ENODE_MACS);
+                vnic_dev_add_addr(fnic->vdev, fnic->ctlr.ctl_src_addr);
+        } else {
+                shost_printk(KERN_INFO, fnic->lport->host,
+                             "firmware uses non-FIP mode\n");
+                fnic->ctlr.mode = FIP_ST_NON_FIP;
+        }
         fnic->state = FNIC_IN_FC_MODE;
 
         /* Enable hardware stripping of vlan header on ingress */
@@ -697,6 +701,8 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
                 goto err_out_remove_scsi_host;
         }
 
+        fc_lport_init_stats(lp);
+
         fc_lport_config(lp);
 
         if (fc_set_mfs(lp, fnic->config.maxdatafieldsize +
@@ -716,6 +722,7 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
         INIT_WORK(&fnic->link_work, fnic_handle_link);
         INIT_WORK(&fnic->frame_work, fnic_handle_frame);
         skb_queue_head_init(&fnic->frame_queue);
+        skb_queue_head_init(&fnic->tx_queue);
 
         /* Enable all queues */
         for (i = 0; i < fnic->raw_wq_count; i++)
@@ -728,6 +735,14 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
         fc_fabric_login(lp);
 
         vnic_dev_enable(fnic->vdev);
+
+        err = fnic_request_intr(fnic);
+        if (err) {
+                shost_printk(KERN_ERR, fnic->lport->host,
+                             "Unable to request irq.\n");
+                goto err_out_free_exch_mgr;
+        }
+
         for (i = 0; i < fnic->intr_count; i++)
                 vnic_intr_unmask(&fnic->intr[i]);
 
@@ -738,8 +753,8 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
 err_out_free_exch_mgr:
         fc_exch_mgr_free(lp);
 err_out_remove_scsi_host:
-        fc_remove_host(fnic->lport->host);
-        scsi_remove_host(fnic->lport->host);
+        fc_remove_host(lp->host);
+        scsi_remove_host(lp->host);
 err_out_free_rq_buf:
         for (i = 0; i < fnic->rq_count; i++)
                 vnic_rq_clean(&fnic->rq[i], fnic_free_rq_buf);
@@ -752,8 +767,6 @@ err_out_free_ioreq_pool:
         mempool_destroy(fnic->io_req_pool);
 err_out_free_resources:
         fnic_free_vnic_resources(fnic);
-err_out_free_intr:
-        fnic_free_intr(fnic);
 err_out_clear_intr:
         fnic_clear_intr_mode(fnic);
 err_out_dev_close:
@@ -775,6 +788,7 @@ err_out:
 static void __devexit fnic_remove(struct pci_dev *pdev)
 {
         struct fnic *fnic = pci_get_drvdata(pdev);
+        struct fc_lport *lp = fnic->lport;
         unsigned long flags;
 
         /*
@@ -796,6 +810,7 @@ static void __devexit fnic_remove(struct pci_dev *pdev)
          */
         flush_workqueue(fnic_event_queue);
         skb_queue_purge(&fnic->frame_queue);
+        skb_queue_purge(&fnic->tx_queue);
 
         /*
          * Log off the fabric. This stops all remote ports, dns port,
@@ -808,7 +823,8 @@ static void __devexit fnic_remove(struct pci_dev *pdev)
         fnic->in_remove = 1;
         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
-        fc_lport_destroy(fnic->lport);
+        fcoe_ctlr_destroy(&fnic->ctlr);
+        fc_lport_destroy(lp);
 
         /*
          * This stops the fnic device, masks all interrupts. Completed
@@ -818,6 +834,7 @@ static void __devexit fnic_remove(struct pci_dev *pdev)
         fnic_cleanup(fnic);
 
         BUG_ON(!skb_queue_empty(&fnic->frame_queue));
+        BUG_ON(!skb_queue_empty(&fnic->tx_queue));
 
         spin_lock_irqsave(&fnic_list_lock, flags);
         list_del(&fnic->list);
@@ -827,8 +844,8 @@ static void __devexit fnic_remove(struct pci_dev *pdev)
         scsi_remove_host(fnic->lport->host);
         fc_exch_mgr_free(fnic->lport);
         vnic_dev_notify_unset(fnic->vdev);
-        fnic_free_vnic_resources(fnic);
         fnic_free_intr(fnic);
+        fnic_free_vnic_resources(fnic);
         fnic_clear_intr_mode(fnic);
         vnic_dev_close(fnic->vdev);
         vnic_dev_unregister(fnic->vdev);
@@ -836,7 +853,7 @@ static void __devexit fnic_remove(struct pci_dev *pdev)
         pci_release_regions(pdev);
         pci_disable_device(pdev);
         pci_set_drvdata(pdev, NULL);
-        scsi_host_put(fnic->lport->host);
+        scsi_host_put(lp->host);
 }
 
 static struct pci_driver fnic_driver = {
diff --git a/drivers/scsi/fnic/fnic_res.c b/drivers/scsi/fnic/fnic_res.c
index 7ba61ec715d2..50488f8e169d 100644
--- a/drivers/scsi/fnic/fnic_res.c
+++ b/drivers/scsi/fnic/fnic_res.c
@@ -144,10 +144,9 @@ int fnic_get_vnic_config(struct fnic *fnic)
         c->intr_timer_type = c->intr_timer_type;
 
         shost_printk(KERN_INFO, fnic->lport->host,
-                     "vNIC MAC addr %02x:%02x:%02x:%02x:%02x:%02x "
+                     "vNIC MAC addr %pM "
                      "wq/wq_copy/rq %d/%d/%d\n",
-                     fnic->mac_addr[0], fnic->mac_addr[1], fnic->mac_addr[2],
-                     fnic->mac_addr[3], fnic->mac_addr[4], fnic->mac_addr[5],
+                     fnic->ctlr.ctl_src_addr,
                      c->wq_enet_desc_count, c->wq_copy_desc_count,
                      c->rq_desc_count);
         shost_printk(KERN_INFO, fnic->lport->host,
diff --git a/drivers/scsi/fnic/fnic_res.h b/drivers/scsi/fnic/fnic_res.h
index b6f310262534..ef8aaf2156dd 100644
--- a/drivers/scsi/fnic/fnic_res.h
+++ b/drivers/scsi/fnic/fnic_res.h
@@ -51,6 +51,31 @@ static inline void fnic_queue_wq_desc(struct vnic_wq *wq,
         vnic_wq_post(wq, os_buf, dma_addr, len, sop, eop);
 }
 
+static inline void fnic_queue_wq_eth_desc(struct vnic_wq *wq,
+                                      void *os_buf, dma_addr_t dma_addr,
+                                      unsigned int len,
+                                      int vlan_tag_insert,
+                                      unsigned int vlan_tag,
+                                      int cq_entry)
+{
+        struct wq_enet_desc *desc = vnic_wq_next_desc(wq);
+
+        wq_enet_desc_enc(desc,
+                         (u64)dma_addr | VNIC_PADDR_TARGET,
+                         (u16)len,
+                         0, /* mss_or_csum_offset */
+                         0, /* fc_eof */
+                         0, /* offload_mode */
+                         1, /* eop */
+                         (u8)cq_entry,
+                         0, /* fcoe_encap */
+                         (u8)vlan_tag_insert,
+                         (u16)vlan_tag,
+                         0 /* loopback */);
+
+        vnic_wq_post(wq, os_buf, dma_addr, len, 1, 1);
+}
+
 static inline void fnic_queue_wq_copy_desc_icmnd_16(struct vnic_wq_copy *wq,
                                                     u32 req_id,
                                                     u32 lunmap_id, u8 spl_flags,
@@ -58,6 +83,7 @@ static inline void fnic_queue_wq_copy_desc_icmnd_16(struct vnic_wq_copy *wq,
                                                     u64 sgl_addr, u64 sns_addr,
                                                     u8 crn, u8 pri_ta,
                                                     u8 flags, u8 *scsi_cdb,
+                                                    u8 cdb_len,
                                                     u32 data_len, u8 *lun,
                                                     u32 d_id, u16 mss,
                                                     u32 ratov, u32 edtov)
@@ -82,7 +108,8 @@ static inline void fnic_queue_wq_copy_desc_icmnd_16(struct vnic_wq_copy *wq,
         desc->u.icmnd_16.pri_ta = pri_ta;       /* SCSI Pri & Task attribute */
         desc->u.icmnd_16._resvd1 = 0;           /* reserved: should be 0 */
         desc->u.icmnd_16.flags = flags;         /* command flags */
-        memcpy(desc->u.icmnd_16.scsi_cdb, scsi_cdb, CDB_16);    /* SCSI CDB */
+        memset(desc->u.icmnd_16.scsi_cdb, 0, CDB_16);
+        memcpy(desc->u.icmnd_16.scsi_cdb, scsi_cdb, cdb_len);    /* SCSI CDB */
         desc->u.icmnd_16.data_len = data_len;   /* length of data expected */
         memcpy(desc->u.icmnd_16.lun, lun, LUN_ADDRESS);  /* LUN address */
         desc->u.icmnd_16._resvd2 = 0;           /* reserved */
@@ -132,12 +159,37 @@ static inline void fnic_queue_wq_copy_desc_flogi_reg(struct vnic_wq_copy *wq,
         desc->hdr.tag.u.req_id = req_id;      /* id for this request */
 
         desc->u.flogi_reg.format = format;
+        desc->u.flogi_reg._resvd = 0;
         hton24(desc->u.flogi_reg.s_id, s_id);
         memcpy(desc->u.flogi_reg.gateway_mac, gw_mac, ETH_ALEN);
 
         vnic_wq_copy_post(wq);
 }
 
+static inline void fnic_queue_wq_copy_desc_fip_reg(struct vnic_wq_copy *wq,
+                                                   u32 req_id, u32 s_id,
+                                                   u8 *fcf_mac, u8 *ha_mac,
+                                                   u32 r_a_tov, u32 e_d_tov)
+{
+        struct fcpio_host_req *desc = vnic_wq_copy_next_desc(wq);
+
+        desc->hdr.type = FCPIO_FLOGI_FIP_REG; /* enum fcpio_type */
+        desc->hdr.status = 0;                 /* header status entry */
+        desc->hdr._resvd = 0;                 /* reserved */
+        desc->hdr.tag.u.req_id = req_id;      /* id for this request */
+
+        desc->u.flogi_fip_reg._resvd0 = 0;
+        hton24(desc->u.flogi_fip_reg.s_id, s_id);
+        memcpy(desc->u.flogi_fip_reg.fcf_mac, fcf_mac, ETH_ALEN);
+        desc->u.flogi_fip_reg._resvd1 = 0;
+        desc->u.flogi_fip_reg.r_a_tov = r_a_tov;
+        desc->u.flogi_fip_reg.e_d_tov = e_d_tov;
+        memcpy(desc->u.flogi_fip_reg.ha_mac, ha_mac, ETH_ALEN);
+        desc->u.flogi_fip_reg._resvd2 = 0;
+
+        vnic_wq_copy_post(wq);
+}
+
 static inline void fnic_queue_wq_copy_desc_fw_reset(struct vnic_wq_copy *wq,
                                                     u32 req_id)
 {
diff --git a/drivers/scsi/fnic/fnic_scsi.c b/drivers/scsi/fnic/fnic_scsi.c
index bfc996971b81..3cc47c6e1ada 100644
--- a/drivers/scsi/fnic/fnic_scsi.c
+++ b/drivers/scsi/fnic/fnic_scsi.c
@@ -26,6 +26,7 @@
 #include <linux/if_ether.h>
 #include <linux/if_vlan.h>
 #include <linux/delay.h>
+#include <linux/gfp.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
@@ -174,6 +175,9 @@ int fnic_fw_reset_handler(struct fnic *fnic)
         int ret = 0;
         unsigned long flags;
 
+        skb_queue_purge(&fnic->frame_queue);
+        skb_queue_purge(&fnic->tx_queue);
+
         spin_lock_irqsave(&fnic->wq_copy_lock[0], flags);
 
         if (vnic_wq_copy_desc_avail(wq) <= fnic->wq_copy_desc_low[0])
@@ -200,9 +204,11 @@ int fnic_fw_reset_handler(struct fnic *fnic)
  * fnic_flogi_reg_handler
  * Routine to send flogi register msg to fw
  */
-int fnic_flogi_reg_handler(struct fnic *fnic)
+int fnic_flogi_reg_handler(struct fnic *fnic, u32 fc_id)
 {
         struct vnic_wq_copy *wq = &fnic->wq_copy[0];
+        enum fcpio_flogi_reg_format_type format;
+        struct fc_lport *lp = fnic->lport;
         u8 gw_mac[ETH_ALEN];
         int ret = 0;
         unsigned long flags;
@@ -217,23 +223,32 @@ int fnic_flogi_reg_handler(struct fnic *fnic)
                 goto flogi_reg_ioreq_end;
         }
 
-        if (fnic->fcoui_mode)
+        if (fnic->ctlr.map_dest) {
                 memset(gw_mac, 0xff, ETH_ALEN);
-        else
-                memcpy(gw_mac, fnic->dest_addr, ETH_ALEN);
+                format = FCPIO_FLOGI_REG_DEF_DEST;
+        } else {
+                memcpy(gw_mac, fnic->ctlr.dest_addr, ETH_ALEN);
+                format = FCPIO_FLOGI_REG_GW_DEST;
+        }
 
-        fnic_queue_wq_copy_desc_flogi_reg(wq, SCSI_NO_TAG,
-                                          FCPIO_FLOGI_REG_GW_DEST,
-                                          fnic->s_id,
-                                          gw_mac);
+        if ((fnic->config.flags & VFCF_FIP_CAPABLE) && !fnic->ctlr.map_dest) {
+                fnic_queue_wq_copy_desc_fip_reg(wq, SCSI_NO_TAG,
+                                                fc_id, gw_mac,
+                                                fnic->data_src_addr,
+                                                lp->r_a_tov, lp->e_d_tov);
+                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
+                              "FLOGI FIP reg issued fcid %x src %pM dest %pM\n",
+                              fc_id, fnic->data_src_addr, gw_mac);
+        } else {
+                fnic_queue_wq_copy_desc_flogi_reg(wq, SCSI_NO_TAG,
+                                                  format, fc_id, gw_mac);
+                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
+                              "FLOGI reg issued fcid %x map %d dest %pM\n",
+                              fc_id, fnic->ctlr.map_dest, gw_mac);
+        }
 
 flogi_reg_ioreq_end:
         spin_unlock_irqrestore(&fnic->wq_copy_lock[0], flags);
-
-        if (!ret)
-                FNIC_SCSI_DBG(KERN_DEBUG, fnic->lport->host,
-                              "flog reg issued\n");
-
         return ret;
 }
 
@@ -319,7 +334,8 @@ static inline int fnic_queue_wq_copy_desc(struct fnic *fnic,
                                          0, /* scsi cmd ref, always 0 */
                                          pri_tag, /* scsi pri and tag */
                                          flags, /* command flags */
-                                         sc->cmnd, scsi_bufflen(sc),
+                                         sc->cmnd, sc->cmd_len,
+                                         scsi_bufflen(sc),
                                          fc_lun.scsi_lun, io_req->port_id,
                                          rport->maxframe_size, rp->r_a_tov,
                                          rp->e_d_tov);
@@ -452,7 +468,6 @@ static int fnic_fcpio_fw_reset_cmpl_handler(struct fnic *fnic,
         u8 hdr_status;
         struct fcpio_tag tag;
         int ret = 0;
-        struct fc_frame *flogi;
         unsigned long flags;
 
         fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
@@ -462,9 +477,6 @@ static int fnic_fcpio_fw_reset_cmpl_handler(struct fnic *fnic,
 
         spin_lock_irqsave(&fnic->fnic_lock, flags);
 
-        flogi = fnic->flogi;
-        fnic->flogi = NULL;
-
         /* fnic should be in FC_TRANS_ETH_MODE */
         if (fnic->state == FNIC_IN_FC_TRANS_ETH_MODE) {
                 /* Check status of reset completion */
@@ -505,17 +517,14 @@ static int fnic_fcpio_fw_reset_cmpl_handler(struct fnic *fnic,
          * free the flogi frame. Else, send it out
          */
         if (fnic->remove_wait || ret) {
-                fnic->flogi_oxid = FC_XID_UNKNOWN;
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                if (flogi)
-                        dev_kfree_skb_irq(fp_skb(flogi));
+                skb_queue_purge(&fnic->tx_queue);
                 goto reset_cmpl_handler_end;
         }
 
         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
-        if (flogi)
-                ret = fnic_send_frame(fnic, flogi);
+        fnic_flush_tx(fnic);
 
  reset_cmpl_handler_end:
         return ret;
@@ -532,18 +541,13 @@ static int fnic_fcpio_flogi_reg_cmpl_handler(struct fnic *fnic,
         u8 hdr_status;
         struct fcpio_tag tag;
         int ret = 0;
-        struct fc_frame *flogi_resp = NULL;
         unsigned long flags;
-        struct sk_buff *skb;
 
         fcpio_header_dec(&desc->hdr, &type, &hdr_status, &tag);
 
         /* Update fnic state based on status of flogi reg completion */
         spin_lock_irqsave(&fnic->fnic_lock, flags);
 
-        flogi_resp = fnic->flogi_resp;
-        fnic->flogi_resp = NULL;
-
         if (fnic->state == FNIC_IN_ETH_TRANS_FC_MODE) {
 
                 /* Check flogi registration completion status */
@@ -567,25 +571,17 @@ static int fnic_fcpio_flogi_reg_cmpl_handler(struct fnic *fnic,
                 ret = -1;
         }
 
-        /* Successful flogi reg cmpl, pass frame to LibFC */
-        if (!ret && flogi_resp) {
+        if (!ret) {
                 if (fnic->stop_rx_link_events) {
                         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
                         goto reg_cmpl_handler_end;
                 }
-                skb = (struct sk_buff *)flogi_resp;
-                /* Use fr_flags to indicate whether flogi resp or not */
-                fr_flags(flogi_resp) = 1;
-                fr_dev(flogi_resp) = fnic->lport;
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
-                skb_queue_tail(&fnic->frame_queue, skb);
+                fnic_flush_tx(fnic);
                 queue_work(fnic_event_queue, &fnic->frame_work);
-
         } else {
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
-                if (flogi_resp)
-                        dev_kfree_skb_irq(fp_skb(flogi_resp));
         }
 
 reg_cmpl_handler_end:
@@ -907,6 +903,7 @@ static int fnic_fcpio_cmpl_handler(struct vnic_dev *vdev,
                 break;
 
         case FCPIO_FLOGI_REG_CMPL: /* fw completed flogi_reg */
+        case FCPIO_FLOGI_FIP_REG_CMPL: /* fw completed flogi_fip_reg */
                 ret = fnic_fcpio_flogi_reg_cmpl_handler(fnic, desc);
                 break;
 
@@ -1224,22 +1221,6 @@ void fnic_terminate_rport_io(struct fc_rport *rport)
 
 }
 
-static void fnic_block_error_handler(struct scsi_cmnd *sc)
-{
-        struct Scsi_Host *shost = sc->device->host;
-        struct fc_rport *rport = starget_to_rport(scsi_target(sc->device));
-        unsigned long flags;
-
-        spin_lock_irqsave(shost->host_lock, flags);
-        while (rport->port_state == FC_PORTSTATE_BLOCKED) {
-                spin_unlock_irqrestore(shost->host_lock, flags);
-                msleep(1000);
-                spin_lock_irqsave(shost->host_lock, flags);
-        }
-        spin_unlock_irqrestore(shost->host_lock, flags);
-
-}
-
 /*
  * This function is exported to SCSI for sending abort cmnds.
  * A SCSI IO is represented by a io_req in the driver.
@@ -1259,7 +1240,7 @@ int fnic_abort_cmd(struct scsi_cmnd *sc)
         DECLARE_COMPLETION_ONSTACK(tm_done);
 
         /* Wait for rport to unblock */
-        fnic_block_error_handler(sc);
+        fc_block_scsi_eh(sc);
 
         /* Get local-port, check ready and link up */
         lp = shost_priv(sc->device->host);
@@ -1541,7 +1522,7 @@ int fnic_device_reset(struct scsi_cmnd *sc)
         DECLARE_COMPLETION_ONSTACK(tm_done);
 
         /* Wait for rport to unblock */
-        fnic_block_error_handler(sc);
+        fc_block_scsi_eh(sc);
 
         /* Get local-port, check ready and link up */
         lp = shost_priv(sc->device->host);
@@ -1762,7 +1743,7 @@ void fnic_scsi_abort_io(struct fc_lport *lp)
         fnic->remove_wait = &remove_wait;
         old_state = fnic->state;
         fnic->state = FNIC_IN_FC_TRANS_ETH_MODE;
-        vnic_dev_del_addr(fnic->vdev, fnic->data_src_addr);
+        fnic_update_mac_locked(fnic, fnic->ctlr.ctl_src_addr);
         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
         err = fnic_fw_reset_handler(fnic);
@@ -1802,7 +1783,7 @@ void fnic_scsi_cleanup(struct fc_lport *lp)
         spin_lock_irqsave(&fnic->fnic_lock, flags);
         old_state = fnic->state;
         fnic->state = FNIC_IN_FC_TRANS_ETH_MODE;
-        vnic_dev_del_addr(fnic->vdev, fnic->data_src_addr);
+        fnic_update_mac_locked(fnic, fnic->ctlr.ctl_src_addr);
         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
 
         if (fnic_fw_reset_handler(fnic)) {
diff --git a/drivers/scsi/fnic/vnic_dev.c b/drivers/scsi/fnic/vnic_dev.c
index 566770645086..db710148d156 100644
--- a/drivers/scsi/fnic/vnic_dev.c
+++ b/drivers/scsi/fnic/vnic_dev.c
@@ -22,6 +22,7 @@
 #include <linux/pci.h>
 #include <linux/delay.h>
 #include <linux/if_ether.h>
+#include <linux/slab.h>
 #include "vnic_resource.h"
 #include "vnic_devcmd.h"
 #include "vnic_dev.h"
diff --git a/drivers/scsi/fnic/vnic_devcmd.h b/drivers/scsi/fnic/vnic_devcmd.h
index d62b9061bf12..7c9ccbd4134b 100644
--- a/drivers/scsi/fnic/vnic_devcmd.h
+++ b/drivers/scsi/fnic/vnic_devcmd.h
@@ -94,7 +94,7 @@ enum vnic_devcmd_cmd {
         CMD_STATS_DUMP          = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 4),
 
         /* set Rx packet filter: (u32)a0=filters (see CMD_PFILTER_*) */
-        CMD_PACKET_FILTER       = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 7),
+        CMD_PACKET_FILTER       = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 7),
 
         /* hang detection notification */
         CMD_HANG_NOTIFY         = _CMDC(_CMD_DIR_NONE, _CMD_VTYPE_ALL, 8),
diff --git a/drivers/scsi/fnic/vnic_rq.c b/drivers/scsi/fnic/vnic_rq.c
index bedd0d285630..fd2068f5ae16 100644
--- a/drivers/scsi/fnic/vnic_rq.c
+++ b/drivers/scsi/fnic/vnic_rq.c
@@ -20,6 +20,7 @@
 #include <linux/types.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include "vnic_dev.h"
 #include "vnic_rq.h"
 
diff --git a/drivers/scsi/fnic/vnic_scsi.h b/drivers/scsi/fnic/vnic_scsi.h
index 46baa5254001..fbb55364e272 100644
--- a/drivers/scsi/fnic/vnic_scsi.h
+++ b/drivers/scsi/fnic/vnic_scsi.h
@@ -95,5 +95,6 @@ struct vnic_fc_config {
 
 #define VFCF_FCP_SEQ_LVL_ERR    0x1     /* Enable FCP-2 Error Recovery */
 #define VFCF_PERBI              0x2     /* persistent binding info available */
+#define VFCF_FIP_CAPABLE        0x4     /* firmware can handle FIP */
 
 #endif /* _VNIC_SCSI_H_ */
diff --git a/drivers/scsi/fnic/vnic_wq.c b/drivers/scsi/fnic/vnic_wq.c
index 1f9ea790d130..a414135460db 100644
--- a/drivers/scsi/fnic/vnic_wq.c
+++ b/drivers/scsi/fnic/vnic_wq.c
@@ -20,6 +20,7 @@
 #include <linux/types.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include "vnic_dev.h"
 #include "vnic_wq.h"
 
diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c
index 9e8fce0f0c1b..35a4b3073ec3 100644
--- a/drivers/scsi/gdth.c
+++ b/drivers/scsi/gdth.c
@@ -121,6 +121,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/list.h>
 #include <linux/smp_lock.h>
+#include <linux/slab.h>
 
 #ifdef GDTH_RTC
 #include <linux/mc146818rtc.h>
@@ -140,40 +141,40 @@
 #include "gdth.h"
 
 static void gdth_delay(int milliseconds);
-static void gdth_eval_mapping(ulong32 size, ulong32 *cyls, int *heads, int *secs);
+static void gdth_eval_mapping(u32 size, u32 *cyls, int *heads, int *secs);
 static irqreturn_t gdth_interrupt(int irq, void *dev_id);
 static irqreturn_t __gdth_interrupt(gdth_ha_str *ha,
                                     int gdth_from_wait, int* pIndex);
-static int gdth_sync_event(gdth_ha_str *ha, int service, unchar index,
+static int gdth_sync_event(gdth_ha_str *ha, int service, u8 index,
                                                                Scsi_Cmnd *scp);
 static int gdth_async_event(gdth_ha_str *ha);
 static void gdth_log_event(gdth_evt_data *dvr, char *buffer);
 
-static void gdth_putq(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar priority);
+static void gdth_putq(gdth_ha_str *ha, Scsi_Cmnd *scp, u8 priority);
 static void gdth_next(gdth_ha_str *ha);
-static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar b);
+static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, u8 b);
 static int gdth_special_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp);
-static gdth_evt_str *gdth_store_event(gdth_ha_str *ha, ushort source,
-                                      ushort idx, gdth_evt_data *evt);
+static gdth_evt_str *gdth_store_event(gdth_ha_str *ha, u16 source,
+                                      u16 idx, gdth_evt_data *evt);
 static int gdth_read_event(gdth_ha_str *ha, int handle, gdth_evt_str *estr);
-static void gdth_readapp_event(gdth_ha_str *ha, unchar application, 
+static void gdth_readapp_event(gdth_ha_str *ha, u8 application, 
                                gdth_evt_str *estr);
 static void gdth_clear_events(void);
 
 static void gdth_copy_internal_data(gdth_ha_str *ha, Scsi_Cmnd *scp,
-                                    char *buffer, ushort count);
+                                    char *buffer, u16 count);
 static int gdth_internal_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp);
-static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive);
+static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, u16 hdrive);
 
 static void gdth_enable_int(gdth_ha_str *ha);
 static int gdth_test_busy(gdth_ha_str *ha);
 static int gdth_get_cmd_index(gdth_ha_str *ha);
 static void gdth_release_event(gdth_ha_str *ha);
-static int gdth_wait(gdth_ha_str *ha, int index,ulong32 time);
-static int gdth_internal_cmd(gdth_ha_str *ha, unchar service, ushort opcode,
-                                             ulong32 p1, ulong64 p2,ulong64 p3);
+static int gdth_wait(gdth_ha_str *ha, int index,u32 time);
+static int gdth_internal_cmd(gdth_ha_str *ha, u8 service, u16 opcode,
+                                             u32 p1, u64 p2,u64 p3);
 static int gdth_search_drives(gdth_ha_str *ha);
-static int gdth_analyse_hdrive(gdth_ha_str *ha, ushort hdrive);
+static int gdth_analyse_hdrive(gdth_ha_str *ha, u16 hdrive);
 
 static const char *gdth_ctr_name(gdth_ha_str *ha);
 
@@ -189,7 +190,7 @@ static int __gdth_queuecommand(gdth_ha_str *ha, struct scsi_cmnd *scp,
 static void gdth_scsi_done(struct scsi_cmnd *scp);
 
 #ifdef DEBUG_GDTH
-static unchar   DebugState = DEBUG_GDTH;
+static u8   DebugState = DEBUG_GDTH;
 
 #ifdef __SERIAL__
 #define MAX_SERBUF 160
@@ -270,30 +271,30 @@ static int ser_printk(const char *fmt, ...)
 #endif
 
 #ifdef GDTH_STATISTICS
-static ulong32 max_rq=0, max_index=0, max_sg=0;
+static u32 max_rq=0, max_index=0, max_sg=0;
 #ifdef INT_COAL
-static ulong32 max_int_coal=0;
+static u32 max_int_coal=0;
 #endif
-static ulong32 act_ints=0, act_ios=0, act_stats=0, act_rq=0;
+static u32 act_ints=0, act_ios=0, act_stats=0, act_rq=0;
 static struct timer_list gdth_timer;
 #endif
 
-#define PTR2USHORT(a)   (ushort)(ulong)(a)
+#define PTR2USHORT(a)   (u16)(unsigned long)(a)
 #define GDTOFFSOF(a,b)  (size_t)&(((a*)0)->b)
 #define INDEX_OK(i,t)   ((i)<ARRAY_SIZE(t))
 
 #define BUS_L2P(a,b)    ((b)>(a)->virt_bus ? (b-1):(b))
 
 #ifdef CONFIG_ISA
-static unchar   gdth_drq_tab[4] = {5,6,7,7};            /* DRQ table */
+static u8   gdth_drq_tab[4] = {5,6,7,7};            /* DRQ table */
 #endif
 #if defined(CONFIG_EISA) || defined(CONFIG_ISA)
-static unchar   gdth_irq_tab[6] = {0,10,11,12,14,0};    /* IRQ table */
+static u8   gdth_irq_tab[6] = {0,10,11,12,14,0};    /* IRQ table */
 #endif
-static unchar   gdth_polling;                           /* polling if TRUE */
+static u8   gdth_polling;                           /* polling if TRUE */
 static int      gdth_ctr_count  = 0;                    /* controller count */
 static LIST_HEAD(gdth_instances);                       /* controller list */
-static unchar   gdth_write_through = FALSE;             /* write through */
+static u8   gdth_write_through = FALSE;             /* write through */
 static gdth_evt_str ebuffer[MAX_EVENTS];                /* event buffer */
 static int elastidx;
 static int eoldidx;
@@ -303,7 +304,7 @@ static int major;
 #define DOU     2                               /* OUT data direction */
 #define DNO     DIN                             /* no data transfer */
 #define DUN     DIN                             /* unknown data direction */
-static unchar gdth_direction_tab[0x100] = {
+static u8 gdth_direction_tab[0x100] = {
     DNO,DNO,DIN,DIN,DOU,DIN,DIN,DOU,DIN,DUN,DOU,DOU,DUN,DUN,DUN,DIN,
     DNO,DIN,DIN,DOU,DIN,DOU,DNO,DNO,DOU,DNO,DIN,DNO,DIN,DOU,DNO,DUN,
     DIN,DUN,DIN,DUN,DOU,DIN,DUN,DUN,DIN,DIN,DOU,DNO,DUN,DIN,DOU,DOU,
@@ -390,7 +391,7 @@ static gdth_ha_str *gdth_find_ha(int hanum)
 static struct gdth_cmndinfo *gdth_get_cmndinfo(gdth_ha_str *ha)
 {
         struct gdth_cmndinfo *priv = NULL;
-        ulong flags;
+        unsigned long flags;
         int i;
 
         spin_lock_irqsave(&ha->smp_lock, flags);
@@ -493,7 +494,7 @@ int gdth_execute(struct Scsi_Host *shost, gdth_cmd_str *gdtcmd, char *cmnd,
     return rval;
 }
 
-static void gdth_eval_mapping(ulong32 size, ulong32 *cyls, int *heads, int *secs)
+static void gdth_eval_mapping(u32 size, u32 *cyls, int *heads, int *secs)
 {
     *cyls = size /HEADS/SECS;
     if (*cyls <= MAXCYLS) {
@@ -514,9 +515,9 @@ static void gdth_eval_mapping(ulong32 size, ulong32 *cyls, int *heads, int *secs
 
 /* controller search and initialization functions */
 #ifdef CONFIG_EISA
-static int __init gdth_search_eisa(ushort eisa_adr)
+static int __init gdth_search_eisa(u16 eisa_adr)
 {
-    ulong32 id;
+    u32 id;
     
     TRACE(("gdth_search_eisa() adr. %x\n",eisa_adr));
     id = inl(eisa_adr+ID0REG);
@@ -533,13 +534,13 @@ static int __init gdth_search_eisa(ushort eisa_adr)
 #endif /* CONFIG_EISA */
 
 #ifdef CONFIG_ISA
-static int __init gdth_search_isa(ulong32 bios_adr)
+static int __init gdth_search_isa(u32 bios_adr)
 {
     void __iomem *addr;
-    ulong32 id;
+    u32 id;
 
     TRACE(("gdth_search_isa() bios adr. %x\n",bios_adr));
-    if ((addr = ioremap(bios_adr+BIOS_ID_OFFS, sizeof(ulong32))) != NULL) {
+    if ((addr = ioremap(bios_adr+BIOS_ID_OFFS, sizeof(u32))) != NULL) {
         id = readl(addr);
         iounmap(addr);
         if (id == GDT2_ID)                          /* GDT2000 */
@@ -551,7 +552,7 @@ static int __init gdth_search_isa(ulong32 bios_adr)
 
 #ifdef CONFIG_PCI
 
-static bool gdth_search_vortex(ushort device)
+static bool gdth_search_vortex(u16 device)
 {
         if (device <= PCI_DEVICE_ID_VORTEX_GDT6555)
                 return true;
@@ -603,9 +604,9 @@ static void __devexit gdth_pci_remove_one(struct pci_dev *pdev)
 static int __devinit gdth_pci_init_one(struct pci_dev *pdev,
                                        const struct pci_device_id *ent)
 {
-        ushort vendor = pdev->vendor;
-        ushort device = pdev->device;
-        ulong base0, base1, base2;
+        u16 vendor = pdev->vendor;
+        u16 device = pdev->device;
+        unsigned long base0, base1, base2;
         int rc;
         gdth_pci_str gdth_pcistr;
         gdth_ha_str *ha = NULL;
@@ -658,10 +659,10 @@ static int __devinit gdth_pci_init_one(struct pci_dev *pdev,
 #endif /* CONFIG_PCI */
 
 #ifdef CONFIG_EISA
-static int __init gdth_init_eisa(ushort eisa_adr,gdth_ha_str *ha)
+static int __init gdth_init_eisa(u16 eisa_adr,gdth_ha_str *ha)
 {
-    ulong32 retries,id;
-    unchar prot_ver,eisacf,i,irq_found;
+    u32 retries,id;
+    u8 prot_ver,eisacf,i,irq_found;
 
     TRACE(("gdth_init_eisa() adr. %x\n",eisa_adr));
     
@@ -688,7 +689,7 @@ static int __init gdth_init_eisa(ushort eisa_adr,gdth_ha_str *ha)
         return 0;
     }
     ha->bmic = eisa_adr;
-    ha->brd_phys = (ulong32)eisa_adr >> 12;
+    ha->brd_phys = (u32)eisa_adr >> 12;
 
     outl(0,eisa_adr+MAILBOXREG);
     outl(0,eisa_adr+MAILBOXREG+4);
@@ -752,12 +753,12 @@ static int __init gdth_init_eisa(ushort eisa_adr,gdth_ha_str *ha)
 #endif /* CONFIG_EISA */
 
 #ifdef CONFIG_ISA
-static int __init gdth_init_isa(ulong32 bios_adr,gdth_ha_str *ha)
+static int __init gdth_init_isa(u32 bios_adr,gdth_ha_str *ha)
 {
     register gdt2_dpram_str __iomem *dp2_ptr;
     int i;
-    unchar irq_drq,prot_ver;
-    ulong32 retries;
+    u8 irq_drq,prot_ver;
+    u32 retries;
 
     TRACE(("gdth_init_isa() bios adr. %x\n",bios_adr));
 
@@ -812,7 +813,7 @@ static int __init gdth_init_isa(ulong32 bios_adr,gdth_ha_str *ha)
         }
         gdth_delay(1);
     }
-    prot_ver = (unchar)readl(&dp2_ptr->u.ic.S_Info[0]);
+    prot_ver = (u8)readl(&dp2_ptr->u.ic.S_Info[0]);
     writeb(0, &dp2_ptr->u.ic.Status);
     writeb(0xff, &dp2_ptr->io.irqdel);
     if (prot_ver != PROTOCOL_VERSION) {
@@ -859,9 +860,9 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
     register gdt6_dpram_str __iomem *dp6_ptr;
     register gdt6c_dpram_str __iomem *dp6c_ptr;
     register gdt6m_dpram_str __iomem *dp6m_ptr;
-    ulong32 retries;
-    unchar prot_ver;
-    ushort command;
+    u32 retries;
+    u8 prot_ver;
+    u16 command;
     int i, found = FALSE;
 
     TRACE(("gdth_init_pci()\n"));
@@ -871,7 +872,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
     else
         ha->oem_id = OEM_ID_ICP;
     ha->brd_phys = (pdev->bus->number << 8) | (pdev->devfn & 0xf8);
-    ha->stype = (ulong32)pdev->device;
+    ha->stype = (u32)pdev->device;
     ha->irq = pdev->irq;
     ha->pdev = pdev;
     
@@ -891,7 +892,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
             found = FALSE;
             for (i = 0xC8000; i < 0xE8000; i += 0x4000) {
                 iounmap(ha->brd);
-                ha->brd = ioremap(i, sizeof(ushort)); 
+                ha->brd = ioremap(i, sizeof(u16)); 
                 if (ha->brd == NULL) {
                     printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
                     return 0;
@@ -947,7 +948,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
             }
             gdth_delay(1);
         }
-        prot_ver = (unchar)readl(&dp6_ptr->u.ic.S_Info[0]);
+        prot_ver = (u8)readl(&dp6_ptr->u.ic.S_Info[0]);
         writeb(0, &dp6_ptr->u.ic.S_Status);
         writeb(0xff, &dp6_ptr->io.irqdel);
         if (prot_ver != PROTOCOL_VERSION) {
@@ -1000,7 +1001,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
             found = FALSE;
             for (i = 0xC8000; i < 0xE8000; i += 0x4000) {
                 iounmap(ha->brd);
-                ha->brd = ioremap(i, sizeof(ushort)); 
+                ha->brd = ioremap(i, sizeof(u16)); 
                 if (ha->brd == NULL) {
                     printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
                     return 0;
@@ -1059,7 +1060,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
             }
             gdth_delay(1);
         }
-        prot_ver = (unchar)readl(&dp6c_ptr->u.ic.S_Info[0]);
+        prot_ver = (u8)readl(&dp6c_ptr->u.ic.S_Info[0]);
         writeb(0, &dp6c_ptr->u.ic.Status);
         if (prot_ver != PROTOCOL_VERSION) {
             printk("GDT-PCI: Illegal protocol version\n");
@@ -1128,7 +1129,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
             found = FALSE;
             for (i = 0xC8000; i < 0xE8000; i += 0x4000) {
                 iounmap(ha->brd);
-                ha->brd = ioremap(i, sizeof(ushort)); 
+                ha->brd = ioremap(i, sizeof(u16)); 
                 if (ha->brd == NULL) {
                     printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
                     return 0;
@@ -1180,7 +1181,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
             }
             gdth_delay(1);
         }
-        prot_ver = (unchar)readl(&dp6m_ptr->u.ic.S_Info[0]);
+        prot_ver = (u8)readl(&dp6m_ptr->u.ic.S_Info[0]);
         writeb(0, &dp6m_ptr->u.ic.S_Status);
         if (prot_ver != PROTOCOL_VERSION) {
             printk("GDT-PCI: Illegal protocol version\n");
@@ -1223,7 +1224,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
             }
             gdth_delay(1);
         }
-        prot_ver = (unchar)(readl(&dp6m_ptr->u.ic.S_Info[0]) >> 16);
+        prot_ver = (u8)(readl(&dp6m_ptr->u.ic.S_Info[0]) >> 16);
         writeb(0, &dp6m_ptr->u.ic.S_Status);
         if (prot_ver < 0x2b)      /* FW < x.43: no 64-bit DMA support */
             ha->dma64_support = 0;
@@ -1239,7 +1240,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
 
 static void __devinit gdth_enable_int(gdth_ha_str *ha)
 {
-    ulong flags;
+    unsigned long flags;
     gdt2_dpram_str __iomem *dp2_ptr;
     gdt6_dpram_str __iomem *dp6_ptr;
     gdt6m_dpram_str __iomem *dp6m_ptr;
@@ -1274,14 +1275,14 @@ static void __devinit gdth_enable_int(gdth_ha_str *ha)
 }
 
 /* return IStatus if interrupt was from this card else 0 */
-static unchar gdth_get_status(gdth_ha_str *ha)
+static u8 gdth_get_status(gdth_ha_str *ha)
 {
-    unchar IStatus = 0;
+    u8 IStatus = 0;
 
     TRACE(("gdth_get_status() irq %d ctr_count %d\n", ha->irq, gdth_ctr_count));
 
         if (ha->type == GDT_EISA)
-            IStatus = inb((ushort)ha->bmic + EDOORREG);
+            IStatus = inb((u16)ha->bmic + EDOORREG);
         else if (ha->type == GDT_ISA)
             IStatus =
                 readb(&((gdt2_dpram_str __iomem *)ha->brd)->u.ic.Cmd_Index);
@@ -1329,7 +1330,7 @@ static int gdth_get_cmd_index(gdth_ha_str *ha)
         if (ha->cmd_tab[i].cmnd == UNUSED_CMND) {
             ha->cmd_tab[i].cmnd = ha->pccb->RequestBuffer;
             ha->cmd_tab[i].service = ha->pccb->Service;
-            ha->pccb->CommandIndex = (ulong32)i+2;
+            ha->pccb->CommandIndex = (u32)i+2;
             return (i+2);
         }
     }
@@ -1362,7 +1363,7 @@ static void gdth_copy_command(gdth_ha_str *ha)
     register gdt6c_dpram_str __iomem *dp6c_ptr;
     gdt6_dpram_str __iomem *dp6_ptr;
     gdt2_dpram_str __iomem *dp2_ptr;
-    ushort cp_count,dp_offset,cmd_no;
+    u16 cp_count,dp_offset,cmd_no;
     
     TRACE(("gdth_copy_command() hanum %d\n", ha->hanum));
 
@@ -1386,28 +1387,28 @@ static void gdth_copy_command(gdth_ha_str *ha)
         dp2_ptr = ha->brd;
         writew(dp_offset + DPMEM_COMMAND_OFFSET,
                     &dp2_ptr->u.ic.comm_queue[cmd_no].offset);
-        writew((ushort)cmd_ptr->Service,
+        writew((u16)cmd_ptr->Service,
                     &dp2_ptr->u.ic.comm_queue[cmd_no].serv_id);
         memcpy_toio(&dp2_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
     } else if (ha->type == GDT_PCI) {
         dp6_ptr = ha->brd;
         writew(dp_offset + DPMEM_COMMAND_OFFSET,
                     &dp6_ptr->u.ic.comm_queue[cmd_no].offset);
-        writew((ushort)cmd_ptr->Service,
+        writew((u16)cmd_ptr->Service,
                     &dp6_ptr->u.ic.comm_queue[cmd_no].serv_id);
         memcpy_toio(&dp6_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
     } else if (ha->type == GDT_PCINEW) {
         dp6c_ptr = ha->brd;
         writew(dp_offset + DPMEM_COMMAND_OFFSET,
                     &dp6c_ptr->u.ic.comm_queue[cmd_no].offset);
-        writew((ushort)cmd_ptr->Service,
+        writew((u16)cmd_ptr->Service,
                     &dp6c_ptr->u.ic.comm_queue[cmd_no].serv_id);
         memcpy_toio(&dp6c_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
     } else if (ha->type == GDT_PCIMPR) {
         dp6m_ptr = ha->brd;
         writew(dp_offset + DPMEM_COMMAND_OFFSET,
                     &dp6m_ptr->u.ic.comm_queue[cmd_no].offset);
-        writew((ushort)cmd_ptr->Service,
+        writew((u16)cmd_ptr->Service,
                     &dp6m_ptr->u.ic.comm_queue[cmd_no].serv_id);
         memcpy_toio(&dp6m_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
     }
@@ -1420,14 +1421,14 @@ static void gdth_release_event(gdth_ha_str *ha)
 
 #ifdef GDTH_STATISTICS
     {
-        ulong32 i,j;
+        u32 i,j;
         for (i=0,j=0; j<GDTH_MAXCMDS; ++j) {
             if (ha->cmd_tab[j].cmnd != UNUSED_CMND)
                 ++i;
         }
         if (max_index < i) {
             max_index = i;
-            TRACE3(("GDT: max_index = %d\n",(ushort)i));
+            TRACE3(("GDT: max_index = %d\n",(u16)i));
         }
     }
 #endif
@@ -1450,7 +1451,7 @@ static void gdth_release_event(gdth_ha_str *ha)
     }
 }
 
-static int gdth_wait(gdth_ha_str *ha, int index, ulong32 time)
+static int gdth_wait(gdth_ha_str *ha, int index, u32 time)
 {
     int answer_found = FALSE;
     int wait_index = 0;
@@ -1476,8 +1477,8 @@ static int gdth_wait(gdth_ha_str *ha, int index, ulong32 time)
 }
 
 
-static int gdth_internal_cmd(gdth_ha_str *ha, unchar service, ushort opcode,
-                                            ulong32 p1, ulong64 p2, ulong64 p3)
+static int gdth_internal_cmd(gdth_ha_str *ha, u8 service, u16 opcode,
+                                            u32 p1, u64 p2, u64 p3)
 {
     register gdth_cmd_str *cmd_ptr;
     int retries,index;
@@ -1501,35 +1502,35 @@ static int gdth_internal_cmd(gdth_ha_str *ha, unchar service, ushort opcode,
         if (service == CACHESERVICE) {
             if (opcode == GDT_IOCTL) {
                 cmd_ptr->u.ioctl.subfunc = p1;
-                cmd_ptr->u.ioctl.channel = (ulong32)p2;
-                cmd_ptr->u.ioctl.param_size = (ushort)p3;
+                cmd_ptr->u.ioctl.channel = (u32)p2;
+                cmd_ptr->u.ioctl.param_size = (u16)p3;
                 cmd_ptr->u.ioctl.p_param = ha->scratch_phys;
             } else {
                 if (ha->cache_feat & GDT_64BIT) {
-                    cmd_ptr->u.cache64.DeviceNo = (ushort)p1;
+                    cmd_ptr->u.cache64.DeviceNo = (u16)p1;
                     cmd_ptr->u.cache64.BlockNo  = p2;
                 } else {
-                    cmd_ptr->u.cache.DeviceNo = (ushort)p1;
-                    cmd_ptr->u.cache.BlockNo  = (ulong32)p2;
+                    cmd_ptr->u.cache.DeviceNo = (u16)p1;
+                    cmd_ptr->u.cache.BlockNo  = (u32)p2;
                 }
             }
         } else if (service == SCSIRAWSERVICE) {
             if (ha->raw_feat & GDT_64BIT) {
                 cmd_ptr->u.raw64.direction  = p1;
-                cmd_ptr->u.raw64.bus        = (unchar)p2;
-                cmd_ptr->u.raw64.target     = (unchar)p3;
-                cmd_ptr->u.raw64.lun        = (unchar)(p3 >> 8);
+                cmd_ptr->u.raw64.bus        = (u8)p2;
+                cmd_ptr->u.raw64.target     = (u8)p3;
+                cmd_ptr->u.raw64.lun        = (u8)(p3 >> 8);
             } else {
                 cmd_ptr->u.raw.direction  = p1;
-                cmd_ptr->u.raw.bus        = (unchar)p2;
-                cmd_ptr->u.raw.target     = (unchar)p3;
-                cmd_ptr->u.raw.lun        = (unchar)(p3 >> 8);
+                cmd_ptr->u.raw.bus        = (u8)p2;
+                cmd_ptr->u.raw.target     = (u8)p3;
+                cmd_ptr->u.raw.lun        = (u8)(p3 >> 8);
             }
         } else if (service == SCREENSERVICE) {
             if (opcode == GDT_REALTIME) {
-                *(ulong32 *)&cmd_ptr->u.screen.su.data[0] = p1;
-                *(ulong32 *)&cmd_ptr->u.screen.su.data[4] = (ulong32)p2;
-                *(ulong32 *)&cmd_ptr->u.screen.su.data[8] = (ulong32)p3;
+                *(u32 *)&cmd_ptr->u.screen.su.data[0] = p1;
+                *(u32 *)&cmd_ptr->u.screen.su.data[4] = (u32)p2;
+                *(u32 *)&cmd_ptr->u.screen.su.data[8] = (u32)p3;
             }
         }
         ha->cmd_len          = sizeof(gdth_cmd_str);
@@ -1555,9 +1556,9 @@ static int gdth_internal_cmd(gdth_ha_str *ha, unchar service, ushort opcode,
 
 static int __devinit gdth_search_drives(gdth_ha_str *ha)
 {
-    ushort cdev_cnt, i;
+    u16 cdev_cnt, i;
     int ok;
-    ulong32 bus_no, drv_cnt, drv_no, j;
+    u32 bus_no, drv_cnt, drv_no, j;
     gdth_getch_str *chn;
     gdth_drlist_str *drl;
     gdth_iochan_str *ioc;
@@ -1570,8 +1571,8 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
 #endif
 
 #ifdef GDTH_RTC
-    unchar rtc[12];
-    ulong flags;
+    u8 rtc[12];
+    unsigned long flags;
 #endif     
    
     TRACE(("gdth_search_drives() hanum %d\n", ha->hanum));
@@ -1584,7 +1585,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
         if (ok)
             ha->screen_feat = GDT_64BIT;
     }
-    if (force_dma32 || (!ok && ha->status == (ushort)S_NOFUNC))
+    if (force_dma32 || (!ok && ha->status == (u16)S_NOFUNC))
         ok = gdth_internal_cmd(ha, SCREENSERVICE, GDT_INIT, 0, 0, 0);
     if (!ok) {
         printk("GDT-HA %d: Initialization error screen service (code %d)\n",
@@ -1609,11 +1610,11 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
             rtc[j] = CMOS_READ(j);
     } while (rtc[0] != CMOS_READ(0));
     spin_unlock_irqrestore(&rtc_lock, flags);
-    TRACE2(("gdth_search_drives(): RTC: %x/%x/%x\n",*(ulong32 *)&rtc[0],
-            *(ulong32 *)&rtc[4], *(ulong32 *)&rtc[8]));
+    TRACE2(("gdth_search_drives(): RTC: %x/%x/%x\n",*(u32 *)&rtc[0],
+            *(u32 *)&rtc[4], *(u32 *)&rtc[8]));
     /* 3. send to controller firmware */
-    gdth_internal_cmd(ha, SCREENSERVICE, GDT_REALTIME, *(ulong32 *)&rtc[0],
-                      *(ulong32 *)&rtc[4], *(ulong32 *)&rtc[8]);
+    gdth_internal_cmd(ha, SCREENSERVICE, GDT_REALTIME, *(u32 *)&rtc[0],
+                      *(u32 *)&rtc[4], *(u32 *)&rtc[8]);
 #endif  
  
     /* unfreeze all IOs */
@@ -1627,7 +1628,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
         if (ok)
             ha->cache_feat = GDT_64BIT;
     }
-    if (force_dma32 || (!ok && ha->status == (ushort)S_NOFUNC))
+    if (force_dma32 || (!ok && ha->status == (u16)S_NOFUNC))
         ok = gdth_internal_cmd(ha, CACHESERVICE, GDT_INIT, LINUX_OS, 0, 0);
     if (!ok) {
         printk("GDT-HA %d: Initialization error cache service (code %d)\n",
@@ -1635,7 +1636,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
         return 0;
     }
     TRACE2(("gdth_search_drives(): CACHESERVICE initialized\n"));
-    cdev_cnt = (ushort)ha->info;
+    cdev_cnt = (u16)ha->info;
     ha->fw_vers = ha->service;
 
 #ifdef INT_COAL
@@ -1644,7 +1645,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
         pmod = (gdth_perf_modes *)ha->pscratch;
         pmod->version          = 1;
         pmod->st_mode          = 1;    /* enable one status buffer */
-        *((ulong64 *)&pmod->st_buff_addr1) = ha->coal_stat_phys;
+        *((u64 *)&pmod->st_buff_addr1) = ha->coal_stat_phys;
         pmod->st_buff_indx1    = COALINDEX;
         pmod->st_buff_addr2    = 0;
         pmod->st_buff_u_addr2  = 0;
@@ -1705,7 +1706,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
             else
                 ha->bus_id[bus_no] = 0xff;
         }       
-        ha->bus_cnt = (unchar)bus_no;
+        ha->bus_cnt = (u8)bus_no;
     }
     TRACE2(("gdth_search_drives() %d channels\n",ha->bus_cnt));
 
@@ -1789,12 +1790,12 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
 
         /* logical drives */
         if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL, CACHE_DRV_CNT,
-                              INVALID_CHANNEL,sizeof(ulong32))) {
-            drv_cnt = *(ulong32 *)ha->pscratch;
+                              INVALID_CHANNEL,sizeof(u32))) {
+            drv_cnt = *(u32 *)ha->pscratch;
             if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL, CACHE_DRV_LIST,
-                                  INVALID_CHANNEL,drv_cnt * sizeof(ulong32))) {
+                                  INVALID_CHANNEL,drv_cnt * sizeof(u32))) {
                 for (j = 0; j < drv_cnt; ++j) {
-                    drv_no = ((ulong32 *)ha->pscratch)[j];
+                    drv_no = ((u32 *)ha->pscratch)[j];
                     if (drv_no < MAX_LDRIVES) {
                         ha->hdr[drv_no].is_logdrv = TRUE;
                         TRACE2(("Drive %d is log. drive\n",drv_no));
@@ -1838,7 +1839,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
         if (ok)
             ha->raw_feat = GDT_64BIT;
     }
-    if (force_dma32 || (!ok && ha->status == (ushort)S_NOFUNC))
+    if (force_dma32 || (!ok && ha->status == (u16)S_NOFUNC))
         ok = gdth_internal_cmd(ha, SCSIRAWSERVICE, GDT_INIT, 0, 0, 0);
     if (!ok) {
         printk("GDT-HA %d: Initialization error raw service (code %d)\n",
@@ -1854,7 +1855,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
         if (gdth_internal_cmd(ha, SCSIRAWSERVICE, GDT_GET_FEAT, 0, 0, 0)) {
             TRACE2(("gdth_search_dr(): get feat RAWSERVICE %d\n",
                     ha->info));
-            ha->raw_feat |= (ushort)ha->info;
+            ha->raw_feat |= (u16)ha->info;
         }
     } 
 
@@ -1865,7 +1866,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
         if (gdth_internal_cmd(ha, CACHESERVICE, GDT_GET_FEAT, 0, 0, 0)) {
             TRACE2(("gdth_search_dr(): get feat CACHESERV. %d\n",
                     ha->info));
-            ha->cache_feat |= (ushort)ha->info;
+            ha->cache_feat |= (u16)ha->info;
         }
     }
 
@@ -1923,9 +1924,9 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
     return 1;
 }
 
-static int gdth_analyse_hdrive(gdth_ha_str *ha, ushort hdrive)
+static int gdth_analyse_hdrive(gdth_ha_str *ha, u16 hdrive)
 {
-    ulong32 drv_cyls;
+    u32 drv_cyls;
     int drv_hds, drv_secs;
 
     TRACE(("gdth_analyse_hdrive() hanum %d drive %d\n", ha->hanum, hdrive));
@@ -1944,17 +1945,17 @@ static int gdth_analyse_hdrive(gdth_ha_str *ha, ushort hdrive)
     } else {
         drv_hds = ha->info2 & 0xff;
         drv_secs = (ha->info2 >> 8) & 0xff;
-        drv_cyls = (ulong32)ha->hdr[hdrive].size / drv_hds / drv_secs;
+        drv_cyls = (u32)ha->hdr[hdrive].size / drv_hds / drv_secs;
     }
-    ha->hdr[hdrive].heads = (unchar)drv_hds;
-    ha->hdr[hdrive].secs  = (unchar)drv_secs;
+    ha->hdr[hdrive].heads = (u8)drv_hds;
+    ha->hdr[hdrive].secs  = (u8)drv_secs;
     /* round size */
     ha->hdr[hdrive].size  = drv_cyls * drv_hds * drv_secs;
     
     if (ha->cache_feat & GDT_64BIT) {
         if (gdth_internal_cmd(ha, CACHESERVICE, GDT_X_INFO, hdrive, 0, 0)
             && ha->info2 != 0) {
-            ha->hdr[hdrive].size = ((ulong64)ha->info2 << 32) | ha->info;
+            ha->hdr[hdrive].size = ((u64)ha->info2 << 32) | ha->info;
         }
     }
     TRACE2(("gdth_search_dr() cdr. %d size %d hds %d scs %d\n",
@@ -1964,7 +1965,7 @@ static int gdth_analyse_hdrive(gdth_ha_str *ha, ushort hdrive)
     if (gdth_internal_cmd(ha, CACHESERVICE, GDT_DEVTYPE, hdrive, 0, 0)) {
         TRACE2(("gdth_search_dr() cache drive %d devtype %d\n",
                 hdrive,ha->info));
-        ha->hdr[hdrive].devtype = (ushort)ha->info;
+        ha->hdr[hdrive].devtype = (u16)ha->info;
     }
 
     /* cluster info */
@@ -1972,14 +1973,14 @@ static int gdth_analyse_hdrive(gdth_ha_str *ha, ushort hdrive)
         TRACE2(("gdth_search_dr() cache drive %d cluster info %d\n",
                 hdrive,ha->info));
         if (!shared_access)
-            ha->hdr[hdrive].cluster_type = (unchar)ha->info;
+            ha->hdr[hdrive].cluster_type = (u8)ha->info;
     }
 
     /* R/W attributes */
     if (gdth_internal_cmd(ha, CACHESERVICE, GDT_RW_ATTRIBS, hdrive, 0, 0)) {
         TRACE2(("gdth_search_dr() cache drive %d r/w attrib. %d\n",
                 hdrive,ha->info));
-        ha->hdr[hdrive].rw_attribs = (unchar)ha->info;
+        ha->hdr[hdrive].rw_attribs = (u8)ha->info;
     }
 
     return 1;
@@ -1988,12 +1989,12 @@ static int gdth_analyse_hdrive(gdth_ha_str *ha, ushort hdrive)
 
 /* command queueing/sending functions */
 
-static void gdth_putq(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar priority)
+static void gdth_putq(gdth_ha_str *ha, Scsi_Cmnd *scp, u8 priority)
 {
     struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
     register Scsi_Cmnd *pscp;
     register Scsi_Cmnd *nscp;
-    ulong flags;
+    unsigned long flags;
 
     TRACE(("gdth_putq() priority %d\n",priority));
     spin_lock_irqsave(&ha->smp_lock, flags);
@@ -2023,7 +2024,7 @@ static void gdth_putq(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar priority)
         ++flags;
     if (max_rq < flags) {
         max_rq = flags;
-        TRACE3(("GDT: max_rq = %d\n",(ushort)max_rq));
+        TRACE3(("GDT: max_rq = %d\n",(u16)max_rq));
     }
 #endif
 }
@@ -2032,9 +2033,9 @@ static void gdth_next(gdth_ha_str *ha)
 {
     register Scsi_Cmnd *pscp;
     register Scsi_Cmnd *nscp;
-    unchar b, t, l, firsttime;
-    unchar this_cmd, next_cmd;
-    ulong flags = 0;
+    u8 b, t, l, firsttime;
+    u8 this_cmd, next_cmd;
+    unsigned long flags = 0;
     int cmd_index;
 
     TRACE(("gdth_next() hanum %d\n", ha->hanum));
@@ -2282,20 +2283,20 @@ static void gdth_next(gdth_ha_str *ha)
  * buffers, kmap_atomic() as needed.
  */
 static void gdth_copy_internal_data(gdth_ha_str *ha, Scsi_Cmnd *scp,
-                                    char *buffer, ushort count)
+                                    char *buffer, u16 count)
 {
-    ushort cpcount,i, max_sg = scsi_sg_count(scp);
-    ushort cpsum,cpnow;
+    u16 cpcount,i, max_sg = scsi_sg_count(scp);
+    u16 cpsum,cpnow;
     struct scatterlist *sl;
     char *address;
 
-    cpcount = min_t(ushort, count, scsi_bufflen(scp));
+    cpcount = min_t(u16, count, scsi_bufflen(scp));
 
     if (cpcount) {
         cpsum=0;
         scsi_for_each_sg(scp, sl, max_sg, i) {
             unsigned long flags;
-            cpnow = (ushort)sl->length;
+            cpnow = (u16)sl->length;
             TRACE(("copy_internal() now %d sum %d count %d %d\n",
                           cpnow, cpsum, cpcount, scsi_bufflen(scp)));
             if (cpsum+cpnow > cpcount) 
@@ -2325,7 +2326,7 @@ static void gdth_copy_internal_data(gdth_ha_str *ha, Scsi_Cmnd *scp,
 
 static int gdth_internal_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp)
 {
-    unchar t;
+    u8 t;
     gdth_inq_data inq;
     gdth_rdcap_data rdc;
     gdth_sense_data sd;
@@ -2389,7 +2390,7 @@ static int gdth_internal_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp)
 
       case READ_CAPACITY:
         TRACE2(("Read capacity hdrive %d\n",t));
-        if (ha->hdr[t].size > (ulong64)0xffffffff)
+        if (ha->hdr[t].size > (u64)0xffffffff)
             rdc.last_block_no = 0xffffffff;
         else
             rdc.last_block_no = cpu_to_be32(ha->hdr[t].size-1);
@@ -2425,12 +2426,12 @@ static int gdth_internal_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp)
     return 0;
 }
 
-static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
+static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, u16 hdrive)
 {
     register gdth_cmd_str *cmdp;
     struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
-    ulong32 cnt, blockcnt;
-    ulong64 no, blockno;
+    u32 cnt, blockcnt;
+    u64 no, blockno;
     int i, cmd_index, read_write, sgcnt, mode64;
 
     cmdp = ha->pccb;
@@ -2498,17 +2499,17 @@ static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
 
     if (read_write) {
         if (scp->cmd_len == 16) {
-            memcpy(&no, &scp->cmnd[2], sizeof(ulong64));
+            memcpy(&no, &scp->cmnd[2], sizeof(u64));
             blockno = be64_to_cpu(no);
-            memcpy(&cnt, &scp->cmnd[10], sizeof(ulong32));
+            memcpy(&cnt, &scp->cmnd[10], sizeof(u32));
             blockcnt = be32_to_cpu(cnt);
         } else if (scp->cmd_len == 10) {
-            memcpy(&no, &scp->cmnd[2], sizeof(ulong32));
+            memcpy(&no, &scp->cmnd[2], sizeof(u32));
             blockno = be32_to_cpu(no);
-            memcpy(&cnt, &scp->cmnd[7], sizeof(ushort));
+            memcpy(&cnt, &scp->cmnd[7], sizeof(u16));
             blockcnt = be16_to_cpu(cnt);
         } else {
-            memcpy(&no, &scp->cmnd[0], sizeof(ulong32));
+            memcpy(&no, &scp->cmnd[0], sizeof(u32));
             blockno = be32_to_cpu(no) & 0x001fffffUL;
             blockcnt= scp->cmnd[4]==0 ? 0x100 : scp->cmnd[4];
         }
@@ -2516,7 +2517,7 @@ static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
             cmdp->u.cache64.BlockNo = blockno;
             cmdp->u.cache64.BlockCnt = blockcnt;
         } else {
-            cmdp->u.cache.BlockNo = (ulong32)blockno;
+            cmdp->u.cache.BlockNo = (u32)blockno;
             cmdp->u.cache.BlockCnt = blockcnt;
         }
 
@@ -2528,12 +2529,12 @@ static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
             if (mode64) {
                 struct scatterlist *sl;
 
-                cmdp->u.cache64.DestAddr= (ulong64)-1;
+                cmdp->u.cache64.DestAddr= (u64)-1;
                 cmdp->u.cache64.sg_canz = sgcnt;
                 scsi_for_each_sg(scp, sl, sgcnt, i) {
                     cmdp->u.cache64.sg_lst[i].sg_ptr = sg_dma_address(sl);
 #ifdef GDTH_DMA_STATISTICS
-                    if (cmdp->u.cache64.sg_lst[i].sg_ptr > (ulong64)0xffffffff)
+                    if (cmdp->u.cache64.sg_lst[i].sg_ptr > (u64)0xffffffff)
                         ha->dma64_cnt++;
                     else
                         ha->dma32_cnt++;
@@ -2555,8 +2556,8 @@ static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
             }
 
 #ifdef GDTH_STATISTICS
-            if (max_sg < (ulong32)sgcnt) {
-                max_sg = (ulong32)sgcnt;
+            if (max_sg < (u32)sgcnt) {
+                max_sg = (u32)sgcnt;
                 TRACE3(("GDT: max_sg = %d\n",max_sg));
             }
 #endif
@@ -2572,7 +2573,7 @@ static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
         TRACE(("cache cmd: cmd %d blockno. %d, blockcnt %d\n",
                cmdp->OpCode,cmdp->u.cache64.BlockNo,cmdp->u.cache64.BlockCnt));
         ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.cache64.sg_lst) +
-            (ushort)cmdp->u.cache64.sg_canz * sizeof(gdth_sg64_str);
+            (u16)cmdp->u.cache64.sg_canz * sizeof(gdth_sg64_str);
     } else {
         TRACE(("cache cmd: addr. %x sganz %x sgptr0 %x sglen0 %x\n",
                cmdp->u.cache.DestAddr,cmdp->u.cache.sg_canz,
@@ -2581,7 +2582,7 @@ static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
         TRACE(("cache cmd: cmd %d blockno. %d, blockcnt %d\n",
                cmdp->OpCode,cmdp->u.cache.BlockNo,cmdp->u.cache.BlockCnt));
         ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.cache.sg_lst) +
-            (ushort)cmdp->u.cache.sg_canz * sizeof(gdth_sg_str);
+            (u16)cmdp->u.cache.sg_canz * sizeof(gdth_sg_str);
     }
     if (ha->cmd_len & 3)
         ha->cmd_len += (4 - (ha->cmd_len & 3));
@@ -2600,15 +2601,15 @@ static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
     return cmd_index;
 }
 
-static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar b)
+static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, u8 b)
 {
     register gdth_cmd_str *cmdp;
-    ushort i;
+    u16 i;
     dma_addr_t sense_paddr;
     int cmd_index, sgcnt, mode64;
-    unchar t,l;
+    u8 t,l;
     struct page *page;
-    ulong offset;
+    unsigned long offset;
     struct gdth_cmndinfo *cmndinfo;
 
     t = scp->device->id;
@@ -2654,7 +2655,7 @@ static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar b)
 
     } else {
         page = virt_to_page(scp->sense_buffer);
-        offset = (ulong)scp->sense_buffer & ~PAGE_MASK;
+        offset = (unsigned long)scp->sense_buffer & ~PAGE_MASK;
         sense_paddr = pci_map_page(ha->pdev,page,offset,
                                    16,PCI_DMA_FROMDEVICE);
 
@@ -2703,12 +2704,12 @@ static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar b)
             if (mode64) {
                 struct scatterlist *sl;
 
-                cmdp->u.raw64.sdata = (ulong64)-1;
+                cmdp->u.raw64.sdata = (u64)-1;
                 cmdp->u.raw64.sg_ranz = sgcnt;
                 scsi_for_each_sg(scp, sl, sgcnt, i) {
                     cmdp->u.raw64.sg_lst[i].sg_ptr = sg_dma_address(sl);
 #ifdef GDTH_DMA_STATISTICS
-                    if (cmdp->u.raw64.sg_lst[i].sg_ptr > (ulong64)0xffffffff)
+                    if (cmdp->u.raw64.sg_lst[i].sg_ptr > (u64)0xffffffff)
                         ha->dma64_cnt++;
                     else
                         ha->dma32_cnt++;
@@ -2744,7 +2745,7 @@ static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar b)
                    cmdp->u.raw64.sg_lst[0].sg_len));
             /* evaluate command size */
             ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.raw64.sg_lst) +
-                (ushort)cmdp->u.raw64.sg_ranz * sizeof(gdth_sg64_str);
+                (u16)cmdp->u.raw64.sg_ranz * sizeof(gdth_sg64_str);
         } else {
             TRACE(("raw cmd: addr. %x sganz %x sgptr0 %x sglen0 %x\n",
                    cmdp->u.raw.sdata,cmdp->u.raw.sg_ranz,
@@ -2752,7 +2753,7 @@ static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar b)
                    cmdp->u.raw.sg_lst[0].sg_len));
             /* evaluate command size */
             ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.raw.sg_lst) +
-                (ushort)cmdp->u.raw.sg_ranz * sizeof(gdth_sg_str);
+                (u16)cmdp->u.raw.sg_ranz * sizeof(gdth_sg_str);
         }
     }
     /* check space */
@@ -2802,7 +2803,7 @@ static int gdth_special_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp)
     if (cmdp->OpCode == GDT_IOCTL) {
         TRACE2(("IOCTL\n"));
         ha->cmd_len = 
-            GDTOFFSOF(gdth_cmd_str,u.ioctl.p_param) + sizeof(ulong64);
+            GDTOFFSOF(gdth_cmd_str,u.ioctl.p_param) + sizeof(u64);
     } else if (cmdp->Service == CACHESERVICE) {
         TRACE2(("cache command %d\n",cmdp->OpCode));
         if (ha->cache_feat & GDT_64BIT)
@@ -2840,8 +2841,8 @@ static int gdth_special_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp)
 
 
 /* Controller event handling functions */
-static gdth_evt_str *gdth_store_event(gdth_ha_str *ha, ushort source, 
-                                      ushort idx, gdth_evt_data *evt)
+static gdth_evt_str *gdth_store_event(gdth_ha_str *ha, u16 source, 
+                                      u16 idx, gdth_evt_data *evt)
 {
     gdth_evt_str *e;
     struct timeval tv;
@@ -2890,7 +2891,7 @@ static int gdth_read_event(gdth_ha_str *ha, int handle, gdth_evt_str *estr)
 {
     gdth_evt_str *e;
     int eindex;
-    ulong flags;
+    unsigned long flags;
 
     TRACE2(("gdth_read_event() handle %d\n", handle));
     spin_lock_irqsave(&ha->smp_lock, flags);
@@ -2919,12 +2920,12 @@ static int gdth_read_event(gdth_ha_str *ha, int handle, gdth_evt_str *estr)
 }
 
 static void gdth_readapp_event(gdth_ha_str *ha,
-                               unchar application, gdth_evt_str *estr)
+                               u8 application, gdth_evt_str *estr)
 {
     gdth_evt_str *e;
     int eindex;
-    ulong flags;
-    unchar found = FALSE;
+    unsigned long flags;
+    u8 found = FALSE;
 
     TRACE2(("gdth_readapp_event() app. %d\n", application));
     spin_lock_irqsave(&ha->smp_lock, flags);
@@ -2969,9 +2970,9 @@ static irqreturn_t __gdth_interrupt(gdth_ha_str *ha,
     gdt2_dpram_str __iomem *dp2_ptr;
     Scsi_Cmnd *scp;
     int rval, i;
-    unchar IStatus;
-    ushort Service;
-    ulong flags = 0;
+    u8 IStatus;
+    u16 Service;
+    unsigned long flags = 0;
 #ifdef INT_COAL
     int coalesced = FALSE;
     int next = FALSE;
@@ -3018,7 +3019,7 @@ static irqreturn_t __gdth_interrupt(gdth_ha_str *ha,
         if (coalesced) {
             /* For coalesced requests all status
                information is found in the status buffer */
-            IStatus = (unchar)(pcs->status & 0xff);
+            IStatus = (u8)(pcs->status & 0xff);
         }
 #endif
     
@@ -3197,7 +3198,7 @@ static irqreturn_t __gdth_interrupt(gdth_ha_str *ha,
             ++act_int_coal;
             if (act_int_coal > max_int_coal) {
                 max_int_coal = act_int_coal;
-                printk("GDT: max_int_coal = %d\n",(ushort)max_int_coal);
+                printk("GDT: max_int_coal = %d\n",(u16)max_int_coal);
             }
 #endif      
             /* see if there is another status */
@@ -3225,12 +3226,12 @@ static irqreturn_t gdth_interrupt(int irq, void *dev_id)
         return __gdth_interrupt(ha, false, NULL);
 }
 
-static int gdth_sync_event(gdth_ha_str *ha, int service, unchar index,
+static int gdth_sync_event(gdth_ha_str *ha, int service, u8 index,
                                                               Scsi_Cmnd *scp)
 {
     gdth_msg_str *msg;
     gdth_cmd_str *cmdp;
-    unchar b, t;
+    u8 b, t;
     struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
 
     cmdp = ha->pccb;
@@ -3263,7 +3264,7 @@ static int gdth_sync_event(gdth_ha_str *ha, int service, unchar index,
             cmdp->u.screen.su.msg.msg_addr  = ha->msg_phys;
             ha->cmd_offs_dpmem = 0;
             ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.su.msg.msg_addr) 
-                + sizeof(ulong64);
+                + sizeof(u64);
             ha->cmd_cnt = 0;
             gdth_copy_command(ha);
             gdth_release_event(ha);
@@ -3297,7 +3298,7 @@ static int gdth_sync_event(gdth_ha_str *ha, int service, unchar index,
             cmdp->u.screen.su.msg.msg_addr  = ha->msg_phys;
             ha->cmd_offs_dpmem = 0;
             ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.su.msg.msg_addr) 
-                + sizeof(ulong64);
+                + sizeof(u64);
             ha->cmd_cnt = 0;
             gdth_copy_command(ha);
             gdth_release_event(ha);
@@ -3335,7 +3336,7 @@ static int gdth_sync_event(gdth_ha_str *ha, int service, unchar index,
                         cmndinfo->OpCode));
                 /* special commands GDT_CLUST_INFO/GDT_MOUNT ? */
                 if (cmndinfo->OpCode == GDT_CLUST_INFO) {
-                    ha->hdr[t].cluster_type = (unchar)ha->info;
+                    ha->hdr[t].cluster_type = (u8)ha->info;
                     if (!(ha->hdr[t].cluster_type & 
                         CLUSTER_MOUNTED)) {
                         /* NOT MOUNTED -> MOUNT */
@@ -3397,7 +3398,7 @@ static int gdth_sync_event(gdth_ha_str *ha, int service, unchar index,
                     ha->hdr[t].cluster_type &= ~CLUSTER_RESERVED;
                 }
                 memset((char*)scp->sense_buffer,0,16);
-                if (ha->status == (ushort)S_CACHE_RESERV) {
+                if (ha->status == (u16)S_CACHE_RESERV) {
                     scp->result = (DID_OK << 16) | (RESERVATION_CONFLICT << 1);
                 } else {
                     scp->sense_buffer[0] = 0x70;
@@ -3614,16 +3615,16 @@ static int gdth_async_event(gdth_ha_str *ha)
             cmdp->u.screen.su.msg.msg_addr  = ha->msg_phys;
             ha->cmd_offs_dpmem = 0;
             ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.su.msg.msg_addr) 
-                + sizeof(ulong64);
+                + sizeof(u64);
             ha->cmd_cnt = 0;
             gdth_copy_command(ha);
             if (ha->type == GDT_EISA)
-                printk("[EISA slot %d] ",(ushort)ha->brd_phys);
+                printk("[EISA slot %d] ",(u16)ha->brd_phys);
             else if (ha->type == GDT_ISA)
-                printk("[DPMEM 0x%4X] ",(ushort)ha->brd_phys);
+                printk("[DPMEM 0x%4X] ",(u16)ha->brd_phys);
             else 
-                printk("[PCI %d/%d] ",(ushort)(ha->brd_phys>>8),
-                       (ushort)((ha->brd_phys>>3)&0x1f));
+                printk("[PCI %d/%d] ",(u16)(ha->brd_phys>>8),
+                       (u16)((ha->brd_phys>>3)&0x1f));
             gdth_release_event(ha);
         }
 
@@ -3640,7 +3641,7 @@ static int gdth_async_event(gdth_ha_str *ha)
             ha->dvr.eu.async.service = ha->service;
             ha->dvr.eu.async.status  = ha->status;
             ha->dvr.eu.async.info    = ha->info;
-            *(ulong32 *)ha->dvr.eu.async.scsi_coord  = ha->info2;
+            *(u32 *)ha->dvr.eu.async.scsi_coord  = ha->info2;
         }
         gdth_store_event( ha, ES_ASYNC, ha->service, &ha->dvr );
         gdth_log_event( &ha->dvr, NULL );
@@ -3648,8 +3649,8 @@ static int gdth_async_event(gdth_ha_str *ha)
         /* new host drive from expand? */
         if (ha->service == CACHESERVICE && ha->status == 56) {
             TRACE2(("gdth_async_event(): new host drive %d created\n",
-                    (ushort)ha->info));
-            /* gdth_analyse_hdrive(hanum, (ushort)ha->info); */
+                    (u16)ha->info));
+            /* gdth_analyse_hdrive(hanum, (u16)ha->info); */
         }   
     }
     return 1;
@@ -3680,13 +3681,13 @@ static void gdth_log_event(gdth_evt_data *dvr, char *buffer)
         for (j=0,i=1; i < f[0]; i+=2) {
             switch (f[i+1]) {
               case 4:
-                stack.b[j++] = *(ulong32*)&dvr->eu.stream[(int)f[i]];
+                stack.b[j++] = *(u32*)&dvr->eu.stream[(int)f[i]];
                 break;
               case 2:
-                stack.b[j++] = *(ushort*)&dvr->eu.stream[(int)f[i]];
+                stack.b[j++] = *(u16*)&dvr->eu.stream[(int)f[i]];
                 break;
               case 1:
-                stack.b[j++] = *(unchar*)&dvr->eu.stream[(int)f[i]];
+                stack.b[j++] = *(u8*)&dvr->eu.stream[(int)f[i]];
                 break;
               default:
                 break;
@@ -3712,14 +3713,14 @@ static void gdth_log_event(gdth_evt_data *dvr, char *buffer)
 }
 
 #ifdef GDTH_STATISTICS
-static unchar   gdth_timer_running;
+static u8       gdth_timer_running;
 
-static void gdth_timeout(ulong data)
+static void gdth_timeout(unsigned long data)
 {
-    ulong32 i;
+    u32 i;
     Scsi_Cmnd *nscp;
     gdth_ha_str *ha;
-    ulong flags;
+    unsigned long flags;
 
     if(unlikely(list_empty(&gdth_instances))) {
             gdth_timer_running = 0;
@@ -3891,8 +3892,8 @@ static enum blk_eh_timer_return gdth_timed_out(struct scsi_cmnd *scp)
 {
         gdth_ha_str *ha = shost_priv(scp->device->host);
         struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
-        unchar b, t;
-        ulong flags;
+        u8 b, t;
+        unsigned long flags;
         enum blk_eh_timer_return retval = BLK_EH_NOT_HANDLED;
 
         TRACE(("%s() cmd 0x%x\n", scp->cmnd[0], __func__));
@@ -3924,9 +3925,9 @@ static int gdth_eh_bus_reset(Scsi_Cmnd *scp)
 {
     gdth_ha_str *ha = shost_priv(scp->device->host);
     int i;
-    ulong flags;
+    unsigned long flags;
     Scsi_Cmnd *cmnd;
-    unchar b;
+    u8 b;
 
     TRACE2(("gdth_eh_bus_reset()\n"));
 
@@ -3974,7 +3975,7 @@ static int gdth_eh_bus_reset(Scsi_Cmnd *scp)
 
 static int gdth_bios_param(struct scsi_device *sdev,struct block_device *bdev,sector_t cap,int *ip)
 {
-    unchar b, t;
+    u8 b, t;
     gdth_ha_str *ha = shost_priv(sdev->host);
     struct scsi_device *sd;
     unsigned capacity;
@@ -4062,7 +4063,7 @@ static int ioc_event(void __user *arg)
 {
     gdth_ioctl_event evt;
     gdth_ha_str *ha;
-    ulong flags;
+    unsigned long flags;
 
     if (copy_from_user(&evt, arg, sizeof(gdth_ioctl_event)))
         return -EFAULT;
@@ -4098,8 +4099,8 @@ static int ioc_event(void __user *arg)
 static int ioc_lockdrv(void __user *arg)
 {
     gdth_ioctl_lockdrv ldrv;
-    unchar i, j;
-    ulong flags;
+    u8 i, j;
+    unsigned long flags;
     gdth_ha_str *ha;
 
     if (copy_from_user(&ldrv, arg, sizeof(gdth_ioctl_lockdrv)))
@@ -4165,7 +4166,7 @@ static int ioc_general(void __user *arg, char *cmnd)
 {
     gdth_ioctl_general gen;
     char *buf = NULL;
-    ulong64 paddr; 
+    u64 paddr; 
     gdth_ha_str *ha;
     int rval;
 
@@ -4194,7 +4195,7 @@ static int ioc_general(void __user *arg, char *cmnd)
                 gen.command.u.cache64.DeviceNo = gen.command.u.cache.DeviceNo;
                 /* addresses */
                 if (ha->cache_feat & SCATTER_GATHER) {
-                    gen.command.u.cache64.DestAddr = (ulong64)-1;
+                    gen.command.u.cache64.DestAddr = (u64)-1;
                     gen.command.u.cache64.sg_canz = 1;
                     gen.command.u.cache64.sg_lst[0].sg_ptr = paddr;
                     gen.command.u.cache64.sg_lst[0].sg_len = gen.data_len;
@@ -4207,7 +4208,7 @@ static int ioc_general(void __user *arg, char *cmnd)
                 if (ha->cache_feat & SCATTER_GATHER) {
                     gen.command.u.cache.DestAddr = 0xffffffff;
                     gen.command.u.cache.sg_canz = 1;
-                    gen.command.u.cache.sg_lst[0].sg_ptr = (ulong32)paddr;
+                    gen.command.u.cache.sg_lst[0].sg_ptr = (u32)paddr;
                     gen.command.u.cache.sg_lst[0].sg_len = gen.data_len;
                     gen.command.u.cache.sg_lst[1].sg_len = 0;
                 } else {
@@ -4230,7 +4231,7 @@ static int ioc_general(void __user *arg, char *cmnd)
                 gen.command.u.raw64.direction = gen.command.u.raw.direction;
                 /* addresses */
                 if (ha->raw_feat & SCATTER_GATHER) {
-                    gen.command.u.raw64.sdata = (ulong64)-1;
+                    gen.command.u.raw64.sdata = (u64)-1;
                     gen.command.u.raw64.sg_ranz = 1;
                     gen.command.u.raw64.sg_lst[0].sg_ptr = paddr;
                     gen.command.u.raw64.sg_lst[0].sg_len = gen.data_len;
@@ -4244,14 +4245,14 @@ static int ioc_general(void __user *arg, char *cmnd)
                 if (ha->raw_feat & SCATTER_GATHER) {
                     gen.command.u.raw.sdata = 0xffffffff;
                     gen.command.u.raw.sg_ranz = 1;
-                    gen.command.u.raw.sg_lst[0].sg_ptr = (ulong32)paddr;
+                    gen.command.u.raw.sg_lst[0].sg_ptr = (u32)paddr;
                     gen.command.u.raw.sg_lst[0].sg_len = gen.data_len;
                     gen.command.u.raw.sg_lst[1].sg_len = 0;
                 } else {
                     gen.command.u.raw.sdata = paddr;
                     gen.command.u.raw.sg_ranz = 0;
                 }
-                gen.command.u.raw.sense_data = (ulong32)paddr + gen.data_len;
+                gen.command.u.raw.sense_data = (u32)paddr + gen.data_len;
             }
         } else {
             gdth_ioctl_free(ha, gen.data_len+gen.sense_len, buf, paddr);
@@ -4283,7 +4284,7 @@ static int ioc_hdrlist(void __user *arg, char *cmnd)
     gdth_ioctl_rescan *rsc;
     gdth_cmd_str *cmd;
     gdth_ha_str *ha;
-    unchar i;
+    u8 i;
     int rc = -ENOMEM;
     u32 cluster_type = 0;
 
@@ -4335,11 +4336,11 @@ static int ioc_rescan(void __user *arg, char *cmnd)
 {
     gdth_ioctl_rescan *rsc;
     gdth_cmd_str *cmd;
-    ushort i, status, hdr_cnt;
-    ulong32 info;
+    u16 i, status, hdr_cnt;
+    u32 info;
     int cyls, hds, secs;
     int rc = -ENOMEM;
-    ulong flags;
+    unsigned long flags;
     gdth_ha_str *ha; 
 
     rsc = kmalloc(sizeof(*rsc), GFP_KERNEL);
@@ -4367,7 +4368,7 @@ static int ioc_rescan(void __user *arg, char *cmnd)
 
         status = __gdth_execute(ha->sdev, cmd, cmnd, 30, &info);
         i = 0;
-        hdr_cnt = (status == S_OK ? (ushort)info : 0);
+        hdr_cnt = (status == S_OK ? (u16)info : 0);
     } else {
         i = rsc->hdr_no;
         hdr_cnt = i + 1;
@@ -4418,7 +4419,7 @@ static int ioc_rescan(void __user *arg, char *cmnd)
         status = __gdth_execute(ha->sdev, cmd, cmnd, 30, &info);
 
         spin_lock_irqsave(&ha->smp_lock, flags);
-        ha->hdr[i].devtype = (status == S_OK ? (ushort)info : 0);
+        ha->hdr[i].devtype = (status == S_OK ? (u16)info : 0);
         spin_unlock_irqrestore(&ha->smp_lock, flags);
 
         cmd->Service = CACHESERVICE;
@@ -4432,7 +4433,7 @@ static int ioc_rescan(void __user *arg, char *cmnd)
 
         spin_lock_irqsave(&ha->smp_lock, flags);
         ha->hdr[i].cluster_type = 
-            ((status == S_OK && !shared_access) ? (ushort)info : 0);
+            ((status == S_OK && !shared_access) ? (u16)info : 0);
         spin_unlock_irqrestore(&ha->smp_lock, flags);
         rsc->hdr_list[i].cluster_type = ha->hdr[i].cluster_type;
 
@@ -4446,7 +4447,7 @@ static int ioc_rescan(void __user *arg, char *cmnd)
         status = __gdth_execute(ha->sdev, cmd, cmnd, 30, &info);
 
         spin_lock_irqsave(&ha->smp_lock, flags);
-        ha->hdr[i].rw_attribs = (status == S_OK ? (ushort)info : 0);
+        ha->hdr[i].rw_attribs = (status == S_OK ? (u16)info : 0);
         spin_unlock_irqrestore(&ha->smp_lock, flags);
     }
  
@@ -4466,7 +4467,7 @@ static int gdth_ioctl(struct inode *inode, struct file *filep,
 {
     gdth_ha_str *ha; 
     Scsi_Cmnd *scp;
-    ulong flags;
+    unsigned long flags;
     char cmnd[MAX_COMMAND_SIZE];   
     void __user *argp = (void __user *)arg;
 
@@ -4495,9 +4496,9 @@ static int gdth_ioctl(struct inode *inode, struct file *filep,
       { 
         gdth_ioctl_osvers osv; 
 
-        osv.version = (unchar)(LINUX_VERSION_CODE >> 16);
-        osv.subversion = (unchar)(LINUX_VERSION_CODE >> 8);
-        osv.revision = (ushort)(LINUX_VERSION_CODE & 0xff);
+        osv.version = (u8)(LINUX_VERSION_CODE >> 16);
+        osv.subversion = (u8)(LINUX_VERSION_CODE >> 8);
+        osv.revision = (u16)(LINUX_VERSION_CODE & 0xff);
         if (copy_to_user(argp, &osv, sizeof(gdth_ioctl_osvers)))
                 return -EFAULT;
         break;
@@ -4512,10 +4513,10 @@ static int gdth_ioctl(struct inode *inode, struct file *filep,
             return -EFAULT;
 
         if (ha->type == GDT_ISA || ha->type == GDT_EISA) {
-            ctrt.type = (unchar)((ha->stype>>20) - 0x10);
+            ctrt.type = (u8)((ha->stype>>20) - 0x10);
         } else {
             if (ha->type != GDT_PCIMPR) {
-                ctrt.type = (unchar)((ha->stype<<4) + 6);
+                ctrt.type = (u8)((ha->stype<<4) + 6);
             } else {
                 ctrt.type = 
                     (ha->oem_id == OEM_ID_INTEL ? 0xfd : 0xfe);
@@ -4546,7 +4547,7 @@ static int gdth_ioctl(struct inode *inode, struct file *filep,
       case GDTIOCTL_LOCKCHN:
       {
         gdth_ioctl_lockchn lchn;
-        unchar i, j;
+        u8 i, j;
 
         if (copy_from_user(&lchn, argp, sizeof(gdth_ioctl_lockchn)) ||
             (NULL == (ha = gdth_find_ha(lchn.ionode))))
@@ -4670,7 +4671,7 @@ static struct scsi_host_template gdth_template = {
 };
 
 #ifdef CONFIG_ISA
-static int __init gdth_isa_probe_one(ulong32 isa_bios)
+static int __init gdth_isa_probe_one(u32 isa_bios)
 {
         struct Scsi_Host *shp;
         gdth_ha_str *ha;
@@ -4802,7 +4803,7 @@ static int __init gdth_isa_probe_one(ulong32 isa_bios)
 #endif /* CONFIG_ISA */
 
 #ifdef CONFIG_EISA
-static int __init gdth_eisa_probe_one(ushort eisa_slot)
+static int __init gdth_eisa_probe_one(u16 eisa_slot)
 {
         struct Scsi_Host *shp;
         gdth_ha_str *ha;
@@ -5120,7 +5121,7 @@ static void gdth_remove_one(gdth_ha_str *ha)
         scsi_host_put(shp);
 }
 
-static int gdth_halt(struct notifier_block *nb, ulong event, void *buf)
+static int gdth_halt(struct notifier_block *nb, unsigned long event, void *buf)
 {
         gdth_ha_str *ha;
 
@@ -5158,14 +5159,14 @@ static int __init gdth_init(void)
         if (probe_eisa_isa) {
                 /* scanning for controllers, at first: ISA controller */
 #ifdef CONFIG_ISA
-                ulong32 isa_bios;
+                u32 isa_bios;
                 for (isa_bios = 0xc8000UL; isa_bios <= 0xd8000UL;
                                 isa_bios += 0x8000UL)
                         gdth_isa_probe_one(isa_bios);
 #endif
 #ifdef CONFIG_EISA
                 {
-                        ushort eisa_slot;
+                        u16 eisa_slot;
                         for (eisa_slot = 0x1000; eisa_slot <= 0x8000;
                                                  eisa_slot += 0x1000)
                                 gdth_eisa_probe_one(eisa_slot);
diff --git a/drivers/scsi/gdth.h b/drivers/scsi/gdth.h
index 1646444e9bd5..120a0625a7b5 100644
--- a/drivers/scsi/gdth.h
+++ b/drivers/scsi/gdth.h
@@ -321,524 +321,524 @@
 
 /* screenservice message */
 typedef struct {                               
-    ulong32     msg_handle;                     /* message handle */
-    ulong32     msg_len;                        /* size of message */
-    ulong32     msg_alen;                       /* answer length */
-    unchar      msg_answer;                     /* answer flag */
-    unchar      msg_ext;                        /* more messages */
-    unchar      msg_reserved[2];
+    u32     msg_handle;                     /* message handle */
+    u32     msg_len;                        /* size of message */
+    u32     msg_alen;                       /* answer length */
+    u8      msg_answer;                     /* answer flag */
+    u8      msg_ext;                        /* more messages */
+    u8      msg_reserved[2];
     char        msg_text[MSGLEN+2];             /* the message text */
-} PACKED gdth_msg_str;
+} __attribute__((packed)) gdth_msg_str;
 
 
 /* IOCTL data structures */
 
 /* Status coalescing buffer for returning multiple requests per interrupt */
 typedef struct {
-    ulong32     status;
-    ulong32     ext_status;
-    ulong32     info0;
-    ulong32     info1;
-} PACKED gdth_coal_status;
+    u32     status;
+    u32     ext_status;
+    u32     info0;
+    u32     info1;
+} __attribute__((packed)) gdth_coal_status;
 
 /* performance mode data structure */
 typedef struct {
-    ulong32     version;            /* The version of this IOCTL structure. */
-    ulong32     st_mode;            /* 0=dis., 1=st_buf_addr1 valid, 2=both  */
-    ulong32     st_buff_addr1;      /* physical address of status buffer 1 */
-    ulong32     st_buff_u_addr1;    /* reserved for 64 bit addressing */
-    ulong32     st_buff_indx1;      /* reserved command idx. for this buffer */
-    ulong32     st_buff_addr2;      /* physical address of status buffer 1 */
-    ulong32     st_buff_u_addr2;    /* reserved for 64 bit addressing */
-    ulong32     st_buff_indx2;      /* reserved command idx. for this buffer */
-    ulong32     st_buff_size;       /* size of each buffer in bytes */
-    ulong32     cmd_mode;           /* 0 = mode disabled, 1 = cmd_buff_addr1 */ 
-    ulong32     cmd_buff_addr1;     /* physical address of cmd buffer 1 */   
-    ulong32     cmd_buff_u_addr1;   /* reserved for 64 bit addressing */
-    ulong32     cmd_buff_indx1;     /* cmd buf addr1 unique identifier */
-    ulong32     cmd_buff_addr2;     /* physical address of cmd buffer 1 */   
-    ulong32     cmd_buff_u_addr2;   /* reserved for 64 bit addressing */
-    ulong32     cmd_buff_indx2;     /* cmd buf addr1 unique identifier */
-    ulong32     cmd_buff_size;      /* size of each cmd bufer in bytes */
-    ulong32     reserved1;
-    ulong32     reserved2;
-} PACKED gdth_perf_modes;
+    u32     version;            /* The version of this IOCTL structure. */
+    u32     st_mode;            /* 0=dis., 1=st_buf_addr1 valid, 2=both  */
+    u32     st_buff_addr1;      /* physical address of status buffer 1 */
+    u32     st_buff_u_addr1;    /* reserved for 64 bit addressing */
+    u32     st_buff_indx1;      /* reserved command idx. for this buffer */
+    u32     st_buff_addr2;      /* physical address of status buffer 1 */
+    u32     st_buff_u_addr2;    /* reserved for 64 bit addressing */
+    u32     st_buff_indx2;      /* reserved command idx. for this buffer */
+    u32     st_buff_size;       /* size of each buffer in bytes */
+    u32     cmd_mode;           /* 0 = mode disabled, 1 = cmd_buff_addr1 */ 
+    u32     cmd_buff_addr1;     /* physical address of cmd buffer 1 */   
+    u32     cmd_buff_u_addr1;   /* reserved for 64 bit addressing */
+    u32     cmd_buff_indx1;     /* cmd buf addr1 unique identifier */
+    u32     cmd_buff_addr2;     /* physical address of cmd buffer 1 */   
+    u32     cmd_buff_u_addr2;   /* reserved for 64 bit addressing */
+    u32     cmd_buff_indx2;     /* cmd buf addr1 unique identifier */
+    u32     cmd_buff_size;      /* size of each cmd bufer in bytes */
+    u32     reserved1;
+    u32     reserved2;
+} __attribute__((packed)) gdth_perf_modes;
 
 /* SCSI drive info */
 typedef struct {
-    unchar      vendor[8];                      /* vendor string */
-    unchar      product[16];                    /* product string */
-    unchar      revision[4];                    /* revision */
-    ulong32     sy_rate;                        /* current rate for sync. tr. */
-    ulong32     sy_max_rate;                    /* max. rate for sync. tr. */
-    ulong32     no_ldrive;                      /* belongs to this log. drv.*/
-    ulong32     blkcnt;                         /* number of blocks */
-    ushort      blksize;                        /* size of block in bytes */
-    unchar      available;                      /* flag: access is available */
-    unchar      init;                           /* medium is initialized */
-    unchar      devtype;                        /* SCSI devicetype */
-    unchar      rm_medium;                      /* medium is removable */
-    unchar      wp_medium;                      /* medium is write protected */
-    unchar      ansi;                           /* SCSI I/II or III? */
-    unchar      protocol;                       /* same as ansi */
-    unchar      sync;                           /* flag: sync. transfer enab. */
-    unchar      disc;                           /* flag: disconnect enabled */
-    unchar      queueing;                       /* flag: command queing enab. */
-    unchar      cached;                         /* flag: caching enabled */
-    unchar      target_id;                      /* target ID of device */
-    unchar      lun;                            /* LUN id of device */
-    unchar      orphan;                         /* flag: drive fragment */
-    ulong32     last_error;                     /* sense key or drive state */
-    ulong32     last_result;                    /* result of last command */
-    ulong32     check_errors;                   /* err. in last surface check */
-    unchar      percent;                        /* progress for surface check */
-    unchar      last_check;                     /* IOCTRL operation */
-    unchar      res[2];
-    ulong32     flags;                          /* from 1.19/2.19: raw reserv.*/
-    unchar      multi_bus;                      /* multi bus dev? (fibre ch.) */
-    unchar      mb_status;                      /* status: available? */
-    unchar      res2[2];
-    unchar      mb_alt_status;                  /* status on second bus */
-    unchar      mb_alt_bid;                     /* number of second bus */
-    unchar      mb_alt_tid;                     /* target id on second bus */
-    unchar      res3;
-    unchar      fc_flag;                        /* from 1.22/2.22: info valid?*/
-    unchar      res4;
-    ushort      fc_frame_size;                  /* frame size (bytes) */
+    u8      vendor[8];                      /* vendor string */
+    u8      product[16];                    /* product string */
+    u8      revision[4];                    /* revision */
+    u32     sy_rate;                        /* current rate for sync. tr. */
+    u32     sy_max_rate;                    /* max. rate for sync. tr. */
+    u32     no_ldrive;                      /* belongs to this log. drv.*/
+    u32     blkcnt;                         /* number of blocks */
+    u16      blksize;                        /* size of block in bytes */
+    u8      available;                      /* flag: access is available */
+    u8      init;                           /* medium is initialized */
+    u8      devtype;                        /* SCSI devicetype */
+    u8      rm_medium;                      /* medium is removable */
+    u8      wp_medium;                      /* medium is write protected */
+    u8      ansi;                           /* SCSI I/II or III? */
+    u8      protocol;                       /* same as ansi */
+    u8      sync;                           /* flag: sync. transfer enab. */
+    u8      disc;                           /* flag: disconnect enabled */
+    u8      queueing;                       /* flag: command queing enab. */
+    u8      cached;                         /* flag: caching enabled */
+    u8      target_id;                      /* target ID of device */
+    u8      lun;                            /* LUN id of device */
+    u8      orphan;                         /* flag: drive fragment */
+    u32     last_error;                     /* sense key or drive state */
+    u32     last_result;                    /* result of last command */
+    u32     check_errors;                   /* err. in last surface check */
+    u8      percent;                        /* progress for surface check */
+    u8      last_check;                     /* IOCTRL operation */
+    u8      res[2];
+    u32     flags;                          /* from 1.19/2.19: raw reserv.*/
+    u8      multi_bus;                      /* multi bus dev? (fibre ch.) */
+    u8      mb_status;                      /* status: available? */
+    u8      res2[2];
+    u8      mb_alt_status;                  /* status on second bus */
+    u8      mb_alt_bid;                     /* number of second bus */
+    u8      mb_alt_tid;                     /* target id on second bus */
+    u8      res3;
+    u8      fc_flag;                        /* from 1.22/2.22: info valid?*/
+    u8      res4;
+    u16      fc_frame_size;                  /* frame size (bytes) */
     char        wwn[8];                         /* world wide name */
-} PACKED gdth_diskinfo_str;
+} __attribute__((packed)) gdth_diskinfo_str;
 
 /* get SCSI channel count  */
 typedef struct {
-    ulong32     channel_no;                     /* number of channel */
-    ulong32     drive_cnt;                      /* drive count */
-    unchar      siop_id;                        /* SCSI processor ID */
-    unchar      siop_state;                     /* SCSI processor state */ 
-} PACKED gdth_getch_str;
+    u32     channel_no;                     /* number of channel */
+    u32     drive_cnt;                      /* drive count */
+    u8      siop_id;                        /* SCSI processor ID */
+    u8      siop_state;                     /* SCSI processor state */ 
+} __attribute__((packed)) gdth_getch_str;
 
 /* get SCSI drive numbers */
 typedef struct {
-    ulong32     sc_no;                          /* SCSI channel */
-    ulong32     sc_cnt;                         /* sc_list[] elements */
-    ulong32     sc_list[MAXID];                 /* minor device numbers */
-} PACKED gdth_drlist_str;
+    u32     sc_no;                          /* SCSI channel */
+    u32     sc_cnt;                         /* sc_list[] elements */
+    u32     sc_list[MAXID];                 /* minor device numbers */
+} __attribute__((packed)) gdth_drlist_str;
 
 /* get grown/primary defect count */
 typedef struct {
-    unchar      sddc_type;                      /* 0x08: grown, 0x10: prim. */
-    unchar      sddc_format;                    /* list entry format */
-    unchar      sddc_len;                       /* list entry length */
-    unchar      sddc_res;
-    ulong32     sddc_cnt;                       /* entry count */
-} PACKED gdth_defcnt_str;
+    u8      sddc_type;                      /* 0x08: grown, 0x10: prim. */
+    u8      sddc_format;                    /* list entry format */
+    u8      sddc_len;                       /* list entry length */
+    u8      sddc_res;
+    u32     sddc_cnt;                       /* entry count */
+} __attribute__((packed)) gdth_defcnt_str;
 
 /* disk statistics */
 typedef struct {
-    ulong32     bid;                            /* SCSI channel */
-    ulong32     first;                          /* first SCSI disk */
-    ulong32     entries;                        /* number of elements */
-    ulong32     count;                          /* (R) number of init. el. */
-    ulong32     mon_time;                       /* time stamp */
+    u32     bid;                            /* SCSI channel */
+    u32     first;                          /* first SCSI disk */
+    u32     entries;                        /* number of elements */
+    u32     count;                          /* (R) number of init. el. */
+    u32     mon_time;                       /* time stamp */
     struct {
-        unchar  tid;                            /* target ID */
-        unchar  lun;                            /* LUN */
-        unchar  res[2];
-        ulong32 blk_size;                       /* block size in bytes */
-        ulong32 rd_count;                       /* bytes read */
-        ulong32 wr_count;                       /* bytes written */
-        ulong32 rd_blk_count;                   /* blocks read */
-        ulong32 wr_blk_count;                   /* blocks written */
-        ulong32 retries;                        /* retries */
-        ulong32 reassigns;                      /* reassigns */
-    } PACKED list[1];
-} PACKED gdth_dskstat_str;
+        u8  tid;                            /* target ID */
+        u8  lun;                            /* LUN */
+        u8  res[2];
+        u32 blk_size;                       /* block size in bytes */
+        u32 rd_count;                       /* bytes read */
+        u32 wr_count;                       /* bytes written */
+        u32 rd_blk_count;                   /* blocks read */
+        u32 wr_blk_count;                   /* blocks written */
+        u32 retries;                        /* retries */
+        u32 reassigns;                      /* reassigns */
+    } __attribute__((packed)) list[1];
+} __attribute__((packed)) gdth_dskstat_str;
 
 /* IO channel header */
 typedef struct {
-    ulong32     version;                        /* version (-1UL: newest) */
-    unchar      list_entries;                   /* list entry count */
-    unchar      first_chan;                     /* first channel number */
-    unchar      last_chan;                      /* last channel number */
-    unchar      chan_count;                     /* (R) channel count */
-    ulong32     list_offset;                    /* offset of list[0] */
-} PACKED gdth_iochan_header;
+    u32     version;                        /* version (-1UL: newest) */
+    u8      list_entries;                   /* list entry count */
+    u8      first_chan;                     /* first channel number */
+    u8      last_chan;                      /* last channel number */
+    u8      chan_count;                     /* (R) channel count */
+    u32     list_offset;                    /* offset of list[0] */
+} __attribute__((packed)) gdth_iochan_header;
 
 /* get IO channel description */
 typedef struct {
     gdth_iochan_header  hdr;
     struct {
-        ulong32         address;                /* channel address */
-        unchar          type;                   /* type (SCSI, FCAL) */
-        unchar          local_no;               /* local number */
-        ushort          features;               /* channel features */
-    } PACKED list[MAXBUS];
-} PACKED gdth_iochan_str;
+        u32         address;                /* channel address */
+        u8          type;                   /* type (SCSI, FCAL) */
+        u8          local_no;               /* local number */
+        u16          features;               /* channel features */
+    } __attribute__((packed)) list[MAXBUS];
+} __attribute__((packed)) gdth_iochan_str;
 
 /* get raw IO channel description */
 typedef struct {
     gdth_iochan_header  hdr;
     struct {
-        unchar      proc_id;                    /* processor id */
-        unchar      proc_defect;                /* defect ? */
-        unchar      reserved[2];
-    } PACKED list[MAXBUS];
-} PACKED gdth_raw_iochan_str;
+        u8      proc_id;                    /* processor id */
+        u8      proc_defect;                /* defect ? */
+        u8      reserved[2];
+    } __attribute__((packed)) list[MAXBUS];
+} __attribute__((packed)) gdth_raw_iochan_str;
 
 /* array drive component */
 typedef struct {
-    ulong32     al_controller;                  /* controller ID */
-    unchar      al_cache_drive;                 /* cache drive number */
-    unchar      al_status;                      /* cache drive state */
-    unchar      al_res[2];     
-} PACKED gdth_arraycomp_str;
+    u32     al_controller;                  /* controller ID */
+    u8      al_cache_drive;                 /* cache drive number */
+    u8      al_status;                      /* cache drive state */
+    u8      al_res[2];     
+} __attribute__((packed)) gdth_arraycomp_str;
 
 /* array drive information */
 typedef struct {
-    unchar      ai_type;                        /* array type (RAID0,4,5) */
-    unchar      ai_cache_drive_cnt;             /* active cachedrives */
-    unchar      ai_state;                       /* array drive state */
-    unchar      ai_master_cd;                   /* master cachedrive */
-    ulong32     ai_master_controller;           /* ID of master controller */
-    ulong32     ai_size;                        /* user capacity [sectors] */
-    ulong32     ai_striping_size;               /* striping size [sectors] */
-    ulong32     ai_secsize;                     /* sector size [bytes] */
-    ulong32     ai_err_info;                    /* failed cache drive */
-    unchar      ai_name[8];                     /* name of the array drive */
-    unchar      ai_controller_cnt;              /* number of controllers */
-    unchar      ai_removable;                   /* flag: removable */
-    unchar      ai_write_protected;             /* flag: write protected */
-    unchar      ai_devtype;                     /* type: always direct access */
+    u8      ai_type;                        /* array type (RAID0,4,5) */
+    u8      ai_cache_drive_cnt;             /* active cachedrives */
+    u8      ai_state;                       /* array drive state */
+    u8      ai_master_cd;                   /* master cachedrive */
+    u32     ai_master_controller;           /* ID of master controller */
+    u32     ai_size;                        /* user capacity [sectors] */
+    u32     ai_striping_size;               /* striping size [sectors] */
+    u32     ai_secsize;                     /* sector size [bytes] */
+    u32     ai_err_info;                    /* failed cache drive */
+    u8      ai_name[8];                     /* name of the array drive */
+    u8      ai_controller_cnt;              /* number of controllers */
+    u8      ai_removable;                   /* flag: removable */
+    u8      ai_write_protected;             /* flag: write protected */
+    u8      ai_devtype;                     /* type: always direct access */
     gdth_arraycomp_str  ai_drives[35];          /* drive components: */
-    unchar      ai_drive_entries;               /* number of drive components */
-    unchar      ai_protected;                   /* protection flag */
-    unchar      ai_verify_state;                /* state of a parity verify */
-    unchar      ai_ext_state;                   /* extended array drive state */
-    unchar      ai_expand_state;                /* array expand state (>=2.18)*/
-    unchar      ai_reserved[3];
-} PACKED gdth_arrayinf_str;
+    u8      ai_drive_entries;               /* number of drive components */
+    u8      ai_protected;                   /* protection flag */
+    u8      ai_verify_state;                /* state of a parity verify */
+    u8      ai_ext_state;                   /* extended array drive state */
+    u8      ai_expand_state;                /* array expand state (>=2.18)*/
+    u8      ai_reserved[3];
+} __attribute__((packed)) gdth_arrayinf_str;
 
 /* get array drive list */
 typedef struct {
-    ulong32     controller_no;                  /* controller no. */
-    unchar      cd_handle;                      /* master cachedrive */
-    unchar      is_arrayd;                      /* Flag: is array drive? */
-    unchar      is_master;                      /* Flag: is array master? */
-    unchar      is_parity;                      /* Flag: is parity drive? */
-    unchar      is_hotfix;                      /* Flag: is hotfix drive? */
-    unchar      res[3];
-} PACKED gdth_alist_str;
+    u32     controller_no;                  /* controller no. */
+    u8      cd_handle;                      /* master cachedrive */
+    u8      is_arrayd;                      /* Flag: is array drive? */
+    u8      is_master;                      /* Flag: is array master? */
+    u8      is_parity;                      /* Flag: is parity drive? */
+    u8      is_hotfix;                      /* Flag: is hotfix drive? */
+    u8      res[3];
+} __attribute__((packed)) gdth_alist_str;
 
 typedef struct {
-    ulong32     entries_avail;                  /* allocated entries */
-    ulong32     entries_init;                   /* returned entries */
-    ulong32     first_entry;                    /* first entry number */
-    ulong32     list_offset;                    /* offset of following list */
+    u32     entries_avail;                  /* allocated entries */
+    u32     entries_init;                   /* returned entries */
+    u32     first_entry;                    /* first entry number */
+    u32     list_offset;                    /* offset of following list */
     gdth_alist_str list[1];                     /* list */
-} PACKED gdth_arcdl_str;
+} __attribute__((packed)) gdth_arcdl_str;
 
 /* cache info/config IOCTL */
 typedef struct {
-    ulong32     version;                        /* firmware version */
-    ushort      state;                          /* cache state (on/off) */
-    ushort      strategy;                       /* cache strategy */
-    ushort      write_back;                     /* write back state (on/off) */
-    ushort      block_size;                     /* cache block size */
-} PACKED gdth_cpar_str;
+    u32     version;                        /* firmware version */
+    u16      state;                          /* cache state (on/off) */
+    u16      strategy;                       /* cache strategy */
+    u16      write_back;                     /* write back state (on/off) */
+    u16      block_size;                     /* cache block size */
+} __attribute__((packed)) gdth_cpar_str;
 
 typedef struct {
-    ulong32     csize;                          /* cache size */
-    ulong32     read_cnt;                       /* read/write counter */
-    ulong32     write_cnt;
-    ulong32     tr_hits;                        /* hits */
-    ulong32     sec_hits;
-    ulong32     sec_miss;                       /* misses */
-} PACKED gdth_cstat_str;
+    u32     csize;                          /* cache size */
+    u32     read_cnt;                       /* read/write counter */
+    u32     write_cnt;
+    u32     tr_hits;                        /* hits */
+    u32     sec_hits;
+    u32     sec_miss;                       /* misses */
+} __attribute__((packed)) gdth_cstat_str;
 
 typedef struct {
     gdth_cpar_str   cpar;
     gdth_cstat_str  cstat;
-} PACKED gdth_cinfo_str;
+} __attribute__((packed)) gdth_cinfo_str;
 
 /* cache drive info */
 typedef struct {
-    unchar      cd_name[8];                     /* cache drive name */
-    ulong32     cd_devtype;                     /* SCSI devicetype */
-    ulong32     cd_ldcnt;                       /* number of log. drives */
-    ulong32     cd_last_error;                  /* last error */
-    unchar      cd_initialized;                 /* drive is initialized */
-    unchar      cd_removable;                   /* media is removable */
-    unchar      cd_write_protected;             /* write protected */
-    unchar      cd_flags;                       /* Pool Hot Fix? */
-    ulong32     ld_blkcnt;                      /* number of blocks */
-    ulong32     ld_blksize;                     /* blocksize */
-    ulong32     ld_dcnt;                        /* number of disks */
-    ulong32     ld_slave;                       /* log. drive index */
-    ulong32     ld_dtype;                       /* type of logical drive */
-    ulong32     ld_last_error;                  /* last error */
-    unchar      ld_name[8];                     /* log. drive name */
-    unchar      ld_error;                       /* error */
-} PACKED gdth_cdrinfo_str;
+    u8      cd_name[8];                     /* cache drive name */
+    u32     cd_devtype;                     /* SCSI devicetype */
+    u32     cd_ldcnt;                       /* number of log. drives */
+    u32     cd_last_error;                  /* last error */
+    u8      cd_initialized;                 /* drive is initialized */
+    u8      cd_removable;                   /* media is removable */
+    u8      cd_write_protected;             /* write protected */
+    u8      cd_flags;                       /* Pool Hot Fix? */
+    u32     ld_blkcnt;                      /* number of blocks */
+    u32     ld_blksize;                     /* blocksize */
+    u32     ld_dcnt;                        /* number of disks */
+    u32     ld_slave;                       /* log. drive index */
+    u32     ld_dtype;                       /* type of logical drive */
+    u32     ld_last_error;                  /* last error */
+    u8      ld_name[8];                     /* log. drive name */
+    u8      ld_error;                       /* error */
+} __attribute__((packed)) gdth_cdrinfo_str;
 
 /* OEM string */
 typedef struct {
-    ulong32     ctl_version;
-    ulong32     file_major_version;
-    ulong32     file_minor_version;
-    ulong32     buffer_size;
-    ulong32     cpy_count;
-    ulong32     ext_error;
-    ulong32     oem_id;
-    ulong32     board_id;
-} PACKED gdth_oem_str_params;
-
-typedef struct {
-    unchar      product_0_1_name[16];
-    unchar      product_4_5_name[16];
-    unchar      product_cluster_name[16];
-    unchar      product_reserved[16];
-    unchar      scsi_cluster_target_vendor_id[16];
-    unchar      cluster_raid_fw_name[16];
-    unchar      oem_brand_name[16];
-    unchar      oem_raid_type[16];
-    unchar      bios_type[13];
-    unchar      bios_title[50];
-    unchar      oem_company_name[37];
-    ulong32     pci_id_1;
-    ulong32     pci_id_2;
-    unchar      validation_status[80];
-    unchar      reserved_1[4];
-    unchar      scsi_host_drive_inquiry_vendor_id[16];
-    unchar      library_file_template[16];
-    unchar      reserved_2[16];
-    unchar      tool_name_1[32];
-    unchar      tool_name_2[32];
-    unchar      tool_name_3[32];
-    unchar      oem_contact_1[84];
-    unchar      oem_contact_2[84];
-    unchar      oem_contact_3[84];
-} PACKED gdth_oem_str;
+    u32     ctl_version;
+    u32     file_major_version;
+    u32     file_minor_version;
+    u32     buffer_size;
+    u32     cpy_count;
+    u32     ext_error;
+    u32     oem_id;
+    u32     board_id;
+} __attribute__((packed)) gdth_oem_str_params;
+
+typedef struct {
+    u8      product_0_1_name[16];
+    u8      product_4_5_name[16];
+    u8      product_cluster_name[16];
+    u8      product_reserved[16];
+    u8      scsi_cluster_target_vendor_id[16];
+    u8      cluster_raid_fw_name[16];
+    u8      oem_brand_name[16];
+    u8      oem_raid_type[16];
+    u8      bios_type[13];
+    u8      bios_title[50];
+    u8      oem_company_name[37];
+    u32     pci_id_1;
+    u32     pci_id_2;
+    u8      validation_status[80];
+    u8      reserved_1[4];
+    u8      scsi_host_drive_inquiry_vendor_id[16];
+    u8      library_file_template[16];
+    u8      reserved_2[16];
+    u8      tool_name_1[32];
+    u8      tool_name_2[32];
+    u8      tool_name_3[32];
+    u8      oem_contact_1[84];
+    u8      oem_contact_2[84];
+    u8      oem_contact_3[84];
+} __attribute__((packed)) gdth_oem_str;
 
 typedef struct {
     gdth_oem_str_params params;
     gdth_oem_str        text;
-} PACKED gdth_oem_str_ioctl;
+} __attribute__((packed)) gdth_oem_str_ioctl;
 
 /* board features */
 typedef struct {
-    unchar      chaining;                       /* Chaining supported */
-    unchar      striping;                       /* Striping (RAID-0) supp. */
-    unchar      mirroring;                      /* Mirroring (RAID-1) supp. */
-    unchar      raid;                           /* RAID-4/5/10 supported */
-} PACKED gdth_bfeat_str;
+    u8      chaining;                       /* Chaining supported */
+    u8      striping;                       /* Striping (RAID-0) supp. */
+    u8      mirroring;                      /* Mirroring (RAID-1) supp. */
+    u8      raid;                           /* RAID-4/5/10 supported */
+} __attribute__((packed)) gdth_bfeat_str;
 
 /* board info IOCTL */
 typedef struct {
-    ulong32     ser_no;                         /* serial no. */
-    unchar      oem_id[2];                      /* OEM ID */
-    ushort      ep_flags;                       /* eprom flags */
-    ulong32     proc_id;                        /* processor ID */
-    ulong32     memsize;                        /* memory size (bytes) */
-    unchar      mem_banks;                      /* memory banks */
-    unchar      chan_type;                      /* channel type */
-    unchar      chan_count;                     /* channel count */
-    unchar      rdongle_pres;                   /* dongle present? */
-    ulong32     epr_fw_ver;                     /* (eprom) firmware version */
-    ulong32     upd_fw_ver;                     /* (update) firmware version */
-    ulong32     upd_revision;                   /* update revision */
+    u32     ser_no;                         /* serial no. */
+    u8      oem_id[2];                      /* OEM ID */
+    u16      ep_flags;                       /* eprom flags */
+    u32     proc_id;                        /* processor ID */
+    u32     memsize;                        /* memory size (bytes) */
+    u8      mem_banks;                      /* memory banks */
+    u8      chan_type;                      /* channel type */
+    u8      chan_count;                     /* channel count */
+    u8      rdongle_pres;                   /* dongle present? */
+    u32     epr_fw_ver;                     /* (eprom) firmware version */
+    u32     upd_fw_ver;                     /* (update) firmware version */
+    u32     upd_revision;                   /* update revision */
     char        type_string[16];                /* controller name */
     char        raid_string[16];                /* RAID firmware name */
-    unchar      update_pres;                    /* update present? */
-    unchar      xor_pres;                       /* XOR engine present? */
-    unchar      prom_type;                      /* ROM type (eprom/flash) */
-    unchar      prom_count;                     /* number of ROM devices */
-    ulong32     dup_pres;                       /* duplexing module present? */
-    ulong32     chan_pres;                      /* number of expansion chn. */
-    ulong32     mem_pres;                       /* memory expansion inst. ? */
-    unchar      ft_bus_system;                  /* fault bus supported? */
-    unchar      subtype_valid;                  /* board_subtype valid? */
-    unchar      board_subtype;                  /* subtype/hardware level */
-    unchar      ramparity_pres;                 /* RAM parity check hardware? */
-} PACKED gdth_binfo_str; 
+    u8      update_pres;                    /* update present? */
+    u8      xor_pres;                       /* XOR engine present? */
+    u8      prom_type;                      /* ROM type (eprom/flash) */
+    u8      prom_count;                     /* number of ROM devices */
+    u32     dup_pres;                       /* duplexing module present? */
+    u32     chan_pres;                      /* number of expansion chn. */
+    u32     mem_pres;                       /* memory expansion inst. ? */
+    u8      ft_bus_system;                  /* fault bus supported? */
+    u8      subtype_valid;                  /* board_subtype valid? */
+    u8      board_subtype;                  /* subtype/hardware level */
+    u8      ramparity_pres;                 /* RAM parity check hardware? */
+} __attribute__((packed)) gdth_binfo_str; 
 
 /* get host drive info */
 typedef struct {
     char        name[8];                        /* host drive name */
-    ulong32     size;                           /* size (sectors) */
-    unchar      host_drive;                     /* host drive number */
-    unchar      log_drive;                      /* log. drive (master) */
-    unchar      reserved;
-    unchar      rw_attribs;                     /* r/w attribs */
-    ulong32     start_sec;                      /* start sector */
-} PACKED gdth_hentry_str;
-
-typedef struct {
-    ulong32     entries;                        /* entry count */
-    ulong32     offset;                         /* offset of entries */
-    unchar      secs_p_head;                    /* sectors/head */
-    unchar      heads_p_cyl;                    /* heads/cylinder */
-    unchar      reserved;
-    unchar      clust_drvtype;                  /* cluster drive type */
-    ulong32     location;                       /* controller number */
+    u32     size;                           /* size (sectors) */
+    u8      host_drive;                     /* host drive number */
+    u8      log_drive;                      /* log. drive (master) */
+    u8      reserved;
+    u8      rw_attribs;                     /* r/w attribs */
+    u32     start_sec;                      /* start sector */
+} __attribute__((packed)) gdth_hentry_str;
+
+typedef struct {
+    u32     entries;                        /* entry count */
+    u32     offset;                         /* offset of entries */
+    u8      secs_p_head;                    /* sectors/head */
+    u8      heads_p_cyl;                    /* heads/cylinder */
+    u8      reserved;
+    u8      clust_drvtype;                  /* cluster drive type */
+    u32     location;                       /* controller number */
     gdth_hentry_str entry[MAX_HDRIVES];         /* entries */
-} PACKED gdth_hget_str;    
+} __attribute__((packed)) gdth_hget_str;    
 
 
 /* DPRAM structures */
 
 /* interface area ISA/PCI */
 typedef struct {
-    unchar              S_Cmd_Indx;             /* special command */
-    unchar volatile     S_Status;               /* status special command */
-    ushort              reserved1;
-    ulong32             S_Info[4];              /* add. info special command */
-    unchar volatile     Sema0;                  /* command semaphore */
-    unchar              reserved2[3];
-    unchar              Cmd_Index;              /* command number */
-    unchar              reserved3[3];
-    ushort volatile     Status;                 /* command status */
-    ushort              Service;                /* service(for async.events) */
-    ulong32             Info[2];                /* additional info */
+    u8              S_Cmd_Indx;             /* special command */
+    u8 volatile     S_Status;               /* status special command */
+    u16              reserved1;
+    u32             S_Info[4];              /* add. info special command */
+    u8 volatile     Sema0;                  /* command semaphore */
+    u8              reserved2[3];
+    u8              Cmd_Index;              /* command number */
+    u8              reserved3[3];
+    u16 volatile     Status;                 /* command status */
+    u16              Service;                /* service(for async.events) */
+    u32             Info[2];                /* additional info */
     struct {
-        ushort          offset;                 /* command offs. in the DPRAM*/
-        ushort          serv_id;                /* service */
-    } PACKED comm_queue[MAXOFFSETS];            /* command queue */
-    ulong32             bios_reserved[2];
-    unchar              gdt_dpr_cmd[1];         /* commands */
-} PACKED gdt_dpr_if;
+        u16          offset;                 /* command offs. in the DPRAM*/
+        u16          serv_id;                /* service */
+    } __attribute__((packed)) comm_queue[MAXOFFSETS];            /* command queue */
+    u32             bios_reserved[2];
+    u8              gdt_dpr_cmd[1];         /* commands */
+} __attribute__((packed)) gdt_dpr_if;
 
 /* SRAM structure PCI controllers */
 typedef struct {
-    ulong32     magic;                          /* controller ID from BIOS */
-    ushort      need_deinit;                    /* switch betw. BIOS/driver */
-    unchar      switch_support;                 /* see need_deinit */
-    unchar      padding[9];
-    unchar      os_used[16];                    /* OS code per service */
-    unchar      unused[28];
-    unchar      fw_magic;                       /* contr. ID from firmware */
-} PACKED gdt_pci_sram;
+    u32     magic;                          /* controller ID from BIOS */
+    u16      need_deinit;                    /* switch betw. BIOS/driver */
+    u8      switch_support;                 /* see need_deinit */
+    u8      padding[9];
+    u8      os_used[16];                    /* OS code per service */
+    u8      unused[28];
+    u8      fw_magic;                       /* contr. ID from firmware */
+} __attribute__((packed)) gdt_pci_sram;
 
 /* SRAM structure EISA controllers (but NOT GDT3000/3020) */
 typedef struct {
-    unchar      os_used[16];                    /* OS code per service */
-    ushort      need_deinit;                    /* switch betw. BIOS/driver */
-    unchar      switch_support;                 /* see need_deinit */
-    unchar      padding;
-} PACKED gdt_eisa_sram;
+    u8      os_used[16];                    /* OS code per service */
+    u16      need_deinit;                    /* switch betw. BIOS/driver */
+    u8      switch_support;                 /* see need_deinit */
+    u8      padding;
+} __attribute__((packed)) gdt_eisa_sram;
 
 
 /* DPRAM ISA controllers */
 typedef struct {
     union {
         struct {
-            unchar      bios_used[0x3c00-32];   /* 15KB - 32Bytes BIOS */
-            ulong32     magic;                  /* controller (EISA) ID */
-            ushort      need_deinit;            /* switch betw. BIOS/driver */
-            unchar      switch_support;         /* see need_deinit */
-            unchar      padding[9];
-            unchar      os_used[16];            /* OS code per service */
-        } PACKED dp_sram;
-        unchar          bios_area[0x4000];      /* 16KB reserved for BIOS */
+            u8      bios_used[0x3c00-32];   /* 15KB - 32Bytes BIOS */
+            u32     magic;                  /* controller (EISA) ID */
+            u16      need_deinit;            /* switch betw. BIOS/driver */
+            u8      switch_support;         /* see need_deinit */
+            u8      padding[9];
+            u8      os_used[16];            /* OS code per service */
+        } __attribute__((packed)) dp_sram;
+        u8          bios_area[0x4000];      /* 16KB reserved for BIOS */
     } bu;
     union {
         gdt_dpr_if      ic;                     /* interface area */
-        unchar          if_area[0x3000];        /* 12KB for interface */
+        u8          if_area[0x3000];        /* 12KB for interface */
     } u;
     struct {
-        unchar          memlock;                /* write protection DPRAM */
-        unchar          event;                  /* release event */
-        unchar          irqen;                  /* board interrupts enable */
-        unchar          irqdel;                 /* acknowledge board int. */
-        unchar volatile Sema1;                  /* status semaphore */
-        unchar          rq;                     /* IRQ/DRQ configuration */
-    } PACKED io;
-} PACKED gdt2_dpram_str;
+        u8          memlock;                /* write protection DPRAM */
+        u8          event;                  /* release event */
+        u8          irqen;                  /* board interrupts enable */
+        u8          irqdel;                 /* acknowledge board int. */
+        u8 volatile Sema1;                  /* status semaphore */
+        u8          rq;                     /* IRQ/DRQ configuration */
+    } __attribute__((packed)) io;
+} __attribute__((packed)) gdt2_dpram_str;
 
 /* DPRAM PCI controllers */
 typedef struct {
     union {
         gdt_dpr_if      ic;                     /* interface area */
-        unchar          if_area[0xff0-sizeof(gdt_pci_sram)];
+        u8          if_area[0xff0-sizeof(gdt_pci_sram)];
     } u;
     gdt_pci_sram        gdt6sr;                 /* SRAM structure */
     struct {
-        unchar          unused0[1];
-        unchar volatile Sema1;                  /* command semaphore */
-        unchar          unused1[3];
-        unchar          irqen;                  /* board interrupts enable */
-        unchar          unused2[2];
-        unchar          event;                  /* release event */
-        unchar          unused3[3];
-        unchar          irqdel;                 /* acknowledge board int. */
-        unchar          unused4[3];
-    } PACKED io;
-} PACKED gdt6_dpram_str;
+        u8          unused0[1];
+        u8 volatile Sema1;                  /* command semaphore */
+        u8          unused1[3];
+        u8          irqen;                  /* board interrupts enable */
+        u8          unused2[2];
+        u8          event;                  /* release event */
+        u8          unused3[3];
+        u8          irqdel;                 /* acknowledge board int. */
+        u8          unused4[3];
+    } __attribute__((packed)) io;
+} __attribute__((packed)) gdt6_dpram_str;
 
 /* PLX register structure (new PCI controllers) */
 typedef struct {
-    unchar              cfg_reg;        /* DPRAM cfg.(2:below 1MB,0:anywhere)*/
-    unchar              unused1[0x3f];
-    unchar volatile     sema0_reg;              /* command semaphore */
-    unchar volatile     sema1_reg;              /* status semaphore */
-    unchar              unused2[2];
-    ushort volatile     status;                 /* command status */
-    ushort              service;                /* service */
-    ulong32             info[2];                /* additional info */
-    unchar              unused3[0x10];
-    unchar              ldoor_reg;              /* PCI to local doorbell */
-    unchar              unused4[3];
-    unchar volatile     edoor_reg;              /* local to PCI doorbell */
-    unchar              unused5[3];
-    unchar              control0;               /* control0 register(unused) */
-    unchar              control1;               /* board interrupts enable */
-    unchar              unused6[0x16];
-} PACKED gdt6c_plx_regs;
+    u8              cfg_reg;        /* DPRAM cfg.(2:below 1MB,0:anywhere)*/
+    u8              unused1[0x3f];
+    u8 volatile     sema0_reg;              /* command semaphore */
+    u8 volatile     sema1_reg;              /* status semaphore */
+    u8              unused2[2];
+    u16 volatile     status;                 /* command status */
+    u16              service;                /* service */
+    u32             info[2];                /* additional info */
+    u8              unused3[0x10];
+    u8              ldoor_reg;              /* PCI to local doorbell */
+    u8              unused4[3];
+    u8 volatile     edoor_reg;              /* local to PCI doorbell */
+    u8              unused5[3];
+    u8              control0;               /* control0 register(unused) */
+    u8              control1;               /* board interrupts enable */
+    u8              unused6[0x16];
+} __attribute__((packed)) gdt6c_plx_regs;
 
 /* DPRAM new PCI controllers */
 typedef struct {
     union {
         gdt_dpr_if      ic;                     /* interface area */
-        unchar          if_area[0x4000-sizeof(gdt_pci_sram)];
+        u8          if_area[0x4000-sizeof(gdt_pci_sram)];
     } u;
     gdt_pci_sram        gdt6sr;                 /* SRAM structure */
-} PACKED gdt6c_dpram_str;
+} __attribute__((packed)) gdt6c_dpram_str;
 
 /* i960 register structure (PCI MPR controllers) */
 typedef struct {
-    unchar              unused1[16];
-    unchar volatile     sema0_reg;              /* command semaphore */
-    unchar              unused2;
-    unchar volatile     sema1_reg;              /* status semaphore */
-    unchar              unused3;
-    ushort volatile     status;                 /* command status */
-    ushort              service;                /* service */
-    ulong32             info[2];                /* additional info */
-    unchar              ldoor_reg;              /* PCI to local doorbell */
-    unchar              unused4[11];
-    unchar volatile     edoor_reg;              /* local to PCI doorbell */
-    unchar              unused5[7];
-    unchar              edoor_en_reg;           /* board interrupts enable */
-    unchar              unused6[27];
-    ulong32             unused7[939];         
-    ulong32             severity;       
+    u8              unused1[16];
+    u8 volatile     sema0_reg;              /* command semaphore */
+    u8              unused2;
+    u8 volatile     sema1_reg;              /* status semaphore */
+    u8              unused3;
+    u16 volatile     status;                 /* command status */
+    u16              service;                /* service */
+    u32             info[2];                /* additional info */
+    u8              ldoor_reg;              /* PCI to local doorbell */
+    u8              unused4[11];
+    u8 volatile     edoor_reg;              /* local to PCI doorbell */
+    u8              unused5[7];
+    u8              edoor_en_reg;           /* board interrupts enable */
+    u8              unused6[27];
+    u32             unused7[939];         
+    u32             severity;       
     char                evt_str[256];           /* event string */
-} PACKED gdt6m_i960_regs;
+} __attribute__((packed)) gdt6m_i960_regs;
 
 /* DPRAM PCI MPR controllers */
 typedef struct {
     gdt6m_i960_regs     i960r;                  /* 4KB i960 registers */
     union {
         gdt_dpr_if      ic;                     /* interface area */
-        unchar          if_area[0x3000-sizeof(gdt_pci_sram)];
+        u8          if_area[0x3000-sizeof(gdt_pci_sram)];
     } u;
     gdt_pci_sram        gdt6sr;                 /* SRAM structure */
-} PACKED gdt6m_dpram_str;
+} __attribute__((packed)) gdt6m_dpram_str;
 
 
 /* PCI resources */
 typedef struct {
     struct pci_dev      *pdev;
-    ulong               dpmem;                  /* DPRAM address */
-    ulong               io;                     /* IO address */
+    unsigned long               dpmem;                  /* DPRAM address */
+    unsigned long               io;                     /* IO address */
 } gdth_pci_str;
 
 
@@ -846,93 +846,93 @@ typedef struct {
 typedef struct {
     struct Scsi_Host    *shost;
     struct list_head    list;
-    ushort              hanum;
-    ushort              oem_id;                 /* OEM */
-    ushort              type;                   /* controller class */
-    ulong32             stype;                  /* subtype (PCI: device ID) */
-    ushort              fw_vers;                /* firmware version */
-    ushort              cache_feat;             /* feat. cache serv. (s/g,..)*/
-    ushort              raw_feat;               /* feat. raw service (s/g,..)*/
-    ushort              screen_feat;            /* feat. raw service (s/g,..)*/
-    ushort              bmic;                   /* BMIC address (EISA) */
+    u16         hanum;
+    u16              oem_id;                 /* OEM */
+    u16              type;                   /* controller class */
+    u32             stype;                  /* subtype (PCI: device ID) */
+    u16              fw_vers;                /* firmware version */
+    u16              cache_feat;             /* feat. cache serv. (s/g,..)*/
+    u16              raw_feat;               /* feat. raw service (s/g,..)*/
+    u16              screen_feat;            /* feat. raw service (s/g,..)*/
+    u16              bmic;                   /* BMIC address (EISA) */
     void __iomem        *brd;                   /* DPRAM address */
-    ulong32             brd_phys;               /* slot number/BIOS address */
+    u32             brd_phys;               /* slot number/BIOS address */
     gdt6c_plx_regs      *plx;                   /* PLX regs (new PCI contr.) */
     gdth_cmd_str        cmdext;
     gdth_cmd_str        *pccb;                  /* address command structure */
-    ulong32             ccb_phys;               /* phys. address */
+    u32             ccb_phys;               /* phys. address */
 #ifdef INT_COAL
     gdth_coal_status    *coal_stat;             /* buffer for coalescing int.*/
-    ulong64             coal_stat_phys;         /* phys. address */
+    u64             coal_stat_phys;         /* phys. address */
 #endif
     char                *pscratch;              /* scratch (DMA) buffer */
-    ulong64             scratch_phys;           /* phys. address */
-    unchar              scratch_busy;           /* in use? */
-    unchar              dma64_support;          /* 64-bit DMA supported? */
+    u64             scratch_phys;           /* phys. address */
+    u8              scratch_busy;           /* in use? */
+    u8              dma64_support;          /* 64-bit DMA supported? */
     gdth_msg_str        *pmsg;                  /* message buffer */
-    ulong64             msg_phys;               /* phys. address */
-    unchar              scan_mode;              /* current scan mode */
-    unchar              irq;                    /* IRQ */
-    unchar              drq;                    /* DRQ (ISA controllers) */
-    ushort              status;                 /* command status */
-    ushort              service;                /* service/firmware ver./.. */
-    ulong32             info;
-    ulong32             info2;                  /* additional info */
+    u64             msg_phys;               /* phys. address */
+    u8              scan_mode;              /* current scan mode */
+    u8              irq;                    /* IRQ */
+    u8              drq;                    /* DRQ (ISA controllers) */
+    u16              status;                 /* command status */
+    u16              service;                /* service/firmware ver./.. */
+    u32             info;
+    u32             info2;                  /* additional info */
     Scsi_Cmnd           *req_first;             /* top of request queue */
     struct {
-        unchar          present;                /* Flag: host drive present? */
-        unchar          is_logdrv;              /* Flag: log. drive (master)? */
-        unchar          is_arraydrv;            /* Flag: array drive? */
-        unchar          is_master;              /* Flag: array drive master? */
-        unchar          is_parity;              /* Flag: parity drive? */
-        unchar          is_hotfix;              /* Flag: hotfix drive? */
-        unchar          master_no;              /* number of master drive */
-        unchar          lock;                   /* drive locked? (hot plug) */
-        unchar          heads;                  /* mapping */
-        unchar          secs;
-        ushort          devtype;                /* further information */
-        ulong64         size;                   /* capacity */
-        unchar          ldr_no;                 /* log. drive no. */
-        unchar          rw_attribs;             /* r/w attributes */
-        unchar          cluster_type;           /* cluster properties */
-        unchar          media_changed;          /* Flag:MOUNT/UNMOUNT occured */
-        ulong32         start_sec;              /* start sector */
+        u8          present;                /* Flag: host drive present? */
+        u8          is_logdrv;              /* Flag: log. drive (master)? */
+        u8          is_arraydrv;            /* Flag: array drive? */
+        u8          is_master;              /* Flag: array drive master? */
+        u8          is_parity;              /* Flag: parity drive? */
+        u8          is_hotfix;              /* Flag: hotfix drive? */
+        u8          master_no;              /* number of master drive */
+        u8          lock;                   /* drive locked? (hot plug) */
+        u8          heads;                  /* mapping */
+        u8          secs;
+        u16          devtype;                /* further information */
+        u64         size;                   /* capacity */
+        u8          ldr_no;                 /* log. drive no. */
+        u8          rw_attribs;             /* r/w attributes */
+        u8          cluster_type;           /* cluster properties */
+        u8          media_changed;          /* Flag:MOUNT/UNMOUNT occured */
+        u32         start_sec;              /* start sector */
     } hdr[MAX_LDRIVES];                         /* host drives */
     struct {
-        unchar          lock;                   /* channel locked? (hot plug) */
-        unchar          pdev_cnt;               /* physical device count */
-        unchar          local_no;               /* local channel number */
-        unchar          io_cnt[MAXID];          /* current IO count */
-        ulong32         address;                /* channel address */
-        ulong32         id_list[MAXID];         /* IDs of the phys. devices */
+        u8          lock;                   /* channel locked? (hot plug) */
+        u8          pdev_cnt;               /* physical device count */
+        u8          local_no;               /* local channel number */
+        u8          io_cnt[MAXID];          /* current IO count */
+        u32         address;                /* channel address */
+        u32         id_list[MAXID];         /* IDs of the phys. devices */
     } raw[MAXBUS];                              /* SCSI channels */
     struct {
         Scsi_Cmnd       *cmnd;                  /* pending request */
-        ushort          service;                /* service */
+        u16          service;                /* service */
     } cmd_tab[GDTH_MAXCMDS];                    /* table of pend. requests */
     struct gdth_cmndinfo {                      /* per-command private info */
         int index;
         int internal_command;                   /* don't call scsi_done */
         gdth_cmd_str *internal_cmd_str;         /* crier for internal messages*/
         dma_addr_t sense_paddr;                 /* sense dma-addr */
-        unchar priority;
+        u8 priority;
         int timeout_count;                      /* # of timeout calls */
         volatile int wait_for_completion;
-        ushort status;
-        ulong32 info;
+        u16 status;
+        u32 info;
         enum dma_data_direction dma_dir;
         int phase;                              /* ???? */
         int OpCode;
     } cmndinfo[GDTH_MAXCMDS];                   /* index==0 is free */
-    unchar              bus_cnt;                /* SCSI bus count */
-    unchar              tid_cnt;                /* Target ID count */
-    unchar              bus_id[MAXBUS];         /* IOP IDs */
-    unchar              virt_bus;               /* number of virtual bus */
-    unchar              more_proc;              /* more /proc info supported */
-    ushort              cmd_cnt;                /* command count in DPRAM */
-    ushort              cmd_len;                /* length of actual command */
-    ushort              cmd_offs_dpmem;         /* actual offset in DPRAM */
-    ushort              ic_all_size;            /* sizeof DPRAM interf. area */
+    u8              bus_cnt;                /* SCSI bus count */
+    u8              tid_cnt;                /* Target ID count */
+    u8              bus_id[MAXBUS];         /* IOP IDs */
+    u8              virt_bus;               /* number of virtual bus */
+    u8              more_proc;              /* more /proc info supported */
+    u16              cmd_cnt;                /* command count in DPRAM */
+    u16              cmd_len;                /* length of actual command */
+    u16              cmd_offs_dpmem;         /* actual offset in DPRAM */
+    u16              ic_all_size;            /* sizeof DPRAM interf. area */
     gdth_cpar_str       cpar;                   /* controller cache par. */
     gdth_bfeat_str      bfeat;                  /* controller features */
     gdth_binfo_str      binfo;                  /* controller info */
@@ -941,7 +941,7 @@ typedef struct {
     struct pci_dev      *pdev;
     char                oem_name[8];
 #ifdef GDTH_DMA_STATISTICS
-    ulong               dma32_cnt, dma64_cnt;   /* statistics: DMA buffer */
+    unsigned long               dma32_cnt, dma64_cnt;   /* statistics: DMA buffer */
 #endif
     struct scsi_device         *sdev;
 } gdth_ha_str;
@@ -953,65 +953,65 @@ static inline struct gdth_cmndinfo *gdth_cmnd_priv(struct scsi_cmnd* cmd)
 
 /* INQUIRY data format */
 typedef struct {
-    unchar      type_qual;
-    unchar      modif_rmb;
-    unchar      version;
-    unchar      resp_aenc;
-    unchar      add_length;
-    unchar      reserved1;
-    unchar      reserved2;
-    unchar      misc;
-    unchar      vendor[8];
-    unchar      product[16];
-    unchar      revision[4];
-} PACKED gdth_inq_data;
+    u8      type_qual;
+    u8      modif_rmb;
+    u8      version;
+    u8      resp_aenc;
+    u8      add_length;
+    u8      reserved1;
+    u8      reserved2;
+    u8      misc;
+    u8      vendor[8];
+    u8      product[16];
+    u8      revision[4];
+} __attribute__((packed)) gdth_inq_data;
 
 /* READ_CAPACITY data format */
 typedef struct {
-    ulong32     last_block_no;
-    ulong32     block_length;
-} PACKED gdth_rdcap_data;
+    u32     last_block_no;
+    u32     block_length;
+} __attribute__((packed)) gdth_rdcap_data;
 
 /* READ_CAPACITY (16) data format */
 typedef struct {
-    ulong64     last_block_no;
-    ulong32     block_length;
-} PACKED gdth_rdcap16_data;
+    u64     last_block_no;
+    u32     block_length;
+} __attribute__((packed)) gdth_rdcap16_data;
 
 /* REQUEST_SENSE data format */
 typedef struct {
-    unchar      errorcode;
-    unchar      segno;
-    unchar      key;
-    ulong32     info;
-    unchar      add_length;
-    ulong32     cmd_info;
-    unchar      adsc;
-    unchar      adsq;
-    unchar      fruc;
-    unchar      key_spec[3];
-} PACKED gdth_sense_data;
+    u8      errorcode;
+    u8      segno;
+    u8      key;
+    u32     info;
+    u8      add_length;
+    u32     cmd_info;
+    u8      adsc;
+    u8      adsq;
+    u8      fruc;
+    u8      key_spec[3];
+} __attribute__((packed)) gdth_sense_data;
 
 /* MODE_SENSE data format */
 typedef struct {
     struct {
-        unchar  data_length;
-        unchar  med_type;
-        unchar  dev_par;
-        unchar  bd_length;
-    } PACKED hd;
+        u8  data_length;
+        u8  med_type;
+        u8  dev_par;
+        u8  bd_length;
+    } __attribute__((packed)) hd;
     struct {
-        unchar  dens_code;
-        unchar  block_count[3];
-        unchar  reserved;
-        unchar  block_length[3];
-    } PACKED bd;
-} PACKED gdth_modep_data;
+        u8  dens_code;
+        u8  block_count[3];
+        u8  reserved;
+        u8  block_length[3];
+    } __attribute__((packed)) bd;
+} __attribute__((packed)) gdth_modep_data;
 
 /* stack frame */
 typedef struct {
-    ulong       b[10];                          /* 32/64 bit compiler ! */
-} PACKED gdth_stackframe;
+    unsigned long       b[10];                          /* 32/64 bit compiler ! */
+} __attribute__((packed)) gdth_stackframe;
 
 
 /* function prototyping */
diff --git a/drivers/scsi/gdth_ioctl.h b/drivers/scsi/gdth_ioctl.h
index 783fae737f17..b004c6165887 100644
--- a/drivers/scsi/gdth_ioctl.h
+++ b/drivers/scsi/gdth_ioctl.h
@@ -32,109 +32,101 @@
 #define MAX_HDRIVES     MAX_LDRIVES             /* max. host drive count */
 #endif
 
-/* typedefs */
-#ifdef __KERNEL__
-typedef u32     ulong32;
-typedef u64     ulong64;
-#endif
-
-#define PACKED  __attribute__((packed))
-
 /* scatter/gather element */
 typedef struct {
-    ulong32     sg_ptr;                         /* address */
-    ulong32     sg_len;                         /* length */
-} PACKED gdth_sg_str;
+    u32     sg_ptr;                         /* address */
+    u32     sg_len;                         /* length */
+} __attribute__((packed)) gdth_sg_str;
 
 /* scatter/gather element - 64bit addresses */
 typedef struct {
-    ulong64     sg_ptr;                         /* address */
-    ulong32     sg_len;                         /* length */
-} PACKED gdth_sg64_str;
+    u64     sg_ptr;                         /* address */
+    u32     sg_len;                         /* length */
+} __attribute__((packed)) gdth_sg64_str;
 
 /* command structure */
 typedef struct {
-    ulong32     BoardNode;                      /* board node (always 0) */
-    ulong32     CommandIndex;                   /* command number */
-    ushort      OpCode;                         /* the command (READ,..) */
+    u32     BoardNode;                      /* board node (always 0) */
+    u32     CommandIndex;                   /* command number */
+    u16      OpCode;                         /* the command (READ,..) */
     union {
         struct {
-            ushort      DeviceNo;               /* number of cache drive */
-            ulong32     BlockNo;                /* block number */
-            ulong32     BlockCnt;               /* block count */
-            ulong32     DestAddr;               /* dest. addr. (if s/g: -1) */
-            ulong32     sg_canz;                /* s/g element count */
+            u16      DeviceNo;               /* number of cache drive */
+            u32     BlockNo;                /* block number */
+            u32     BlockCnt;               /* block count */
+            u32     DestAddr;               /* dest. addr. (if s/g: -1) */
+            u32     sg_canz;                /* s/g element count */
             gdth_sg_str sg_lst[GDTH_MAXSG];     /* s/g list */
-        } PACKED cache;                         /* cache service cmd. str. */
+        } __attribute__((packed)) cache;                         /* cache service cmd. str. */
         struct {
-            ushort      DeviceNo;               /* number of cache drive */
-            ulong64     BlockNo;                /* block number */
-            ulong32     BlockCnt;               /* block count */
-            ulong64     DestAddr;               /* dest. addr. (if s/g: -1) */
-            ulong32     sg_canz;                /* s/g element count */
+            u16      DeviceNo;               /* number of cache drive */
+            u64     BlockNo;                /* block number */
+            u32     BlockCnt;               /* block count */
+            u64     DestAddr;               /* dest. addr. (if s/g: -1) */
+            u32     sg_canz;                /* s/g element count */
             gdth_sg64_str sg_lst[GDTH_MAXSG];   /* s/g list */
-        } PACKED cache64;                       /* cache service cmd. str. */
+        } __attribute__((packed)) cache64;                       /* cache service cmd. str. */
         struct {
-            ushort      param_size;             /* size of p_param buffer */
-            ulong32     subfunc;                /* IOCTL function */
-            ulong32     channel;                /* device */
-            ulong64     p_param;                /* buffer */
-        } PACKED ioctl;                         /* IOCTL command structure */
+            u16      param_size;             /* size of p_param buffer */
+            u32     subfunc;                /* IOCTL function */
+            u32     channel;                /* device */
+            u64     p_param;                /* buffer */
+        } __attribute__((packed)) ioctl;                         /* IOCTL command structure */
         struct {
-            ushort      reserved;
+            u16      reserved;
             union {
                 struct {
-                    ulong32  msg_handle;        /* message handle */
-                    ulong64  msg_addr;          /* message buffer address */
-                } PACKED msg;
-                unchar       data[12];          /* buffer for rtc data, ... */
+                    u32  msg_handle;        /* message handle */
+                    u64  msg_addr;          /* message buffer address */
+                } __attribute__((packed)) msg;
+                u8       data[12];          /* buffer for rtc data, ... */
             } su;
-        } PACKED screen;                        /* screen service cmd. str. */
+        } __attribute__((packed)) screen;                        /* screen service cmd. str. */
         struct {
-            ushort      reserved;
-            ulong32     direction;              /* data direction */
-            ulong32     mdisc_time;             /* disc. time (0: no timeout)*/
-            ulong32     mcon_time;              /* connect time(0: no to.) */
-            ulong32     sdata;                  /* dest. addr. (if s/g: -1) */
-            ulong32     sdlen;                  /* data length (bytes) */
-            ulong32     clen;                   /* SCSI cmd. length(6,10,12) */
-            unchar      cmd[12];                /* SCSI command */
-            unchar      target;                 /* target ID */
-            unchar      lun;                    /* LUN */
-            unchar      bus;                    /* SCSI bus number */
-            unchar      priority;               /* only 0 used */
-            ulong32     sense_len;              /* sense data length */
-            ulong32     sense_data;             /* sense data addr. */
-            ulong32     link_p;                 /* linked cmds (not supp.) */
-            ulong32     sg_ranz;                /* s/g element count */
+            u16      reserved;
+            u32     direction;              /* data direction */
+            u32     mdisc_time;             /* disc. time (0: no timeout)*/
+            u32     mcon_time;              /* connect time(0: no to.) */
+            u32     sdata;                  /* dest. addr. (if s/g: -1) */
+            u32     sdlen;                  /* data length (bytes) */
+            u32     clen;                   /* SCSI cmd. length(6,10,12) */
+            u8      cmd[12];                /* SCSI command */
+            u8      target;                 /* target ID */
+            u8      lun;                    /* LUN */
+            u8      bus;                    /* SCSI bus number */
+            u8      priority;               /* only 0 used */
+            u32     sense_len;              /* sense data length */
+            u32     sense_data;             /* sense data addr. */
+            u32     link_p;                 /* linked cmds (not supp.) */
+            u32     sg_ranz;                /* s/g element count */
             gdth_sg_str sg_lst[GDTH_MAXSG];     /* s/g list */
-        } PACKED raw;                           /* raw service cmd. struct. */
+        } __attribute__((packed)) raw;                           /* raw service cmd. struct. */
         struct {
-            ushort      reserved;
-            ulong32     direction;              /* data direction */
-            ulong32     mdisc_time;             /* disc. time (0: no timeout)*/
-            ulong32     mcon_time;              /* connect time(0: no to.) */
-            ulong64     sdata;                  /* dest. addr. (if s/g: -1) */
-            ulong32     sdlen;                  /* data length (bytes) */
-            ulong32     clen;                   /* SCSI cmd. length(6,..,16) */
-            unchar      cmd[16];                /* SCSI command */
-            unchar      target;                 /* target ID */
-            unchar      lun;                    /* LUN */
-            unchar      bus;                    /* SCSI bus number */
-            unchar      priority;               /* only 0 used */
-            ulong32     sense_len;              /* sense data length */
-            ulong64     sense_data;             /* sense data addr. */
-            ulong32     sg_ranz;                /* s/g element count */
+            u16      reserved;
+            u32     direction;              /* data direction */
+            u32     mdisc_time;             /* disc. time (0: no timeout)*/
+            u32     mcon_time;              /* connect time(0: no to.) */
+            u64     sdata;                  /* dest. addr. (if s/g: -1) */
+            u32     sdlen;                  /* data length (bytes) */
+            u32     clen;                   /* SCSI cmd. length(6,..,16) */
+            u8      cmd[16];                /* SCSI command */
+            u8      target;                 /* target ID */
+            u8      lun;                    /* LUN */
+            u8      bus;                    /* SCSI bus number */
+            u8      priority;               /* only 0 used */
+            u32     sense_len;              /* sense data length */
+            u64     sense_data;             /* sense data addr. */
+            u32     sg_ranz;                /* s/g element count */
             gdth_sg64_str sg_lst[GDTH_MAXSG];   /* s/g list */
-        } PACKED raw64;                         /* raw service cmd. struct. */
+        } __attribute__((packed)) raw64;                         /* raw service cmd. struct. */
     } u;
     /* additional variables */
-    unchar      Service;                        /* controller service */
-    unchar      reserved;
-    ushort      Status;                         /* command result */
-    ulong32     Info;                           /* additional information */
+    u8      Service;                        /* controller service */
+    u8      reserved;
+    u16      Status;                         /* command result */
+    u32     Info;                           /* additional information */
     void        *RequestBuffer;                 /* request buffer */
-} PACKED gdth_cmd_str;
+} __attribute__((packed)) gdth_cmd_str;
 
 /* controller event structure */
 #define ES_ASYNC    1
@@ -142,129 +134,129 @@ typedef struct {
 #define ES_TEST     3
 #define ES_SYNC     4
 typedef struct {
-    ushort                  size;               /* size of structure */
+    u16                  size;               /* size of structure */
     union {
         char                stream[16];
         struct {
-            ushort          ionode;
-            ushort          service;
-            ulong32         index;
-        } PACKED driver;
+            u16          ionode;
+            u16          service;
+            u32         index;
+        } __attribute__((packed)) driver;
         struct {
-            ushort          ionode;
-            ushort          service;
-            ushort          status;
-            ulong32         info;
-            unchar          scsi_coord[3];
-        } PACKED async;
+            u16          ionode;
+            u16          service;
+            u16          status;
+            u32         info;
+            u8          scsi_coord[3];
+        } __attribute__((packed)) async;
         struct {
-            ushort          ionode;
-            ushort          service;
-            ushort          status;
-            ulong32         info;
-            ushort          hostdrive;
-            unchar          scsi_coord[3];
-            unchar          sense_key;
-        } PACKED sync;
+            u16          ionode;
+            u16          service;
+            u16          status;
+            u32         info;
+            u16          hostdrive;
+            u8          scsi_coord[3];
+            u8          sense_key;
+        } __attribute__((packed)) sync;
         struct {
-            ulong32         l1, l2, l3, l4;
-        } PACKED test;
+            u32         l1, l2, l3, l4;
+        } __attribute__((packed)) test;
     } eu;
-    ulong32                 severity;
-    unchar                  event_string[256];          
-} PACKED gdth_evt_data;
+    u32                 severity;
+    u8                  event_string[256];          
+} __attribute__((packed)) gdth_evt_data;
 
 typedef struct {
-    ulong32         first_stamp;
-    ulong32         last_stamp;
-    ushort          same_count;
-    ushort          event_source;
-    ushort          event_idx;
-    unchar          application;
-    unchar          reserved;
+    u32         first_stamp;
+    u32         last_stamp;
+    u16          same_count;
+    u16          event_source;
+    u16          event_idx;
+    u8          application;
+    u8          reserved;
     gdth_evt_data   event_data;
-} PACKED gdth_evt_str;
+} __attribute__((packed)) gdth_evt_str;
 
 
 #ifdef GDTH_IOCTL_PROC
 /* IOCTL structure (write) */
 typedef struct {
-    ulong32                 magic;              /* IOCTL magic */
-    ushort                  ioctl;              /* IOCTL */
-    ushort                  ionode;             /* controller number */
-    ushort                  service;            /* controller service */
-    ushort                  timeout;            /* timeout */
+    u32                 magic;              /* IOCTL magic */
+    u16                  ioctl;              /* IOCTL */
+    u16                  ionode;             /* controller number */
+    u16                  service;            /* controller service */
+    u16                  timeout;            /* timeout */
     union {
         struct {
-            unchar          command[512];       /* controller command */
-            unchar          data[1];            /* add. data */
+            u8          command[512];       /* controller command */
+            u8          data[1];            /* add. data */
         } general;
         struct {
-            unchar          lock;               /* lock/unlock */
-            unchar          drive_cnt;          /* drive count */
-            ushort          drives[MAX_HDRIVES];/* drives */
+            u8          lock;               /* lock/unlock */
+            u8          drive_cnt;          /* drive count */
+            u16          drives[MAX_HDRIVES];/* drives */
         } lockdrv;
         struct {
-            unchar          lock;               /* lock/unlock */
-            unchar          channel;            /* channel */
+            u8          lock;               /* lock/unlock */
+            u8          channel;            /* channel */
         } lockchn;
         struct {
             int             erase;              /* erase event ? */
             int             handle;
-            unchar          evt[EVENT_SIZE];    /* event structure */
+            u8          evt[EVENT_SIZE];    /* event structure */
         } event;
         struct {
-            unchar          bus;                /* SCSI bus */
-            unchar          target;             /* target ID */
-            unchar          lun;                /* LUN */
-            unchar          cmd_len;            /* command length */
-            unchar          cmd[12];            /* SCSI command */
+            u8          bus;                /* SCSI bus */
+            u8          target;             /* target ID */
+            u8          lun;                /* LUN */
+            u8          cmd_len;            /* command length */
+            u8          cmd[12];            /* SCSI command */
         } scsi;
         struct {
-            ushort          hdr_no;             /* host drive number */
-            unchar          flag;               /* old meth./add/remove */
+            u16          hdr_no;             /* host drive number */
+            u8          flag;               /* old meth./add/remove */
         } rescan;
     } iu;
 } gdth_iowr_str;
 
 /* IOCTL structure (read) */
 typedef struct {
-    ulong32                 size;               /* buffer size */
-    ulong32                 status;             /* IOCTL error code */
+    u32                 size;               /* buffer size */
+    u32                 status;             /* IOCTL error code */
     union {
         struct {
-            unchar          data[1];            /* data */
+            u8          data[1];            /* data */
         } general;
         struct {
-            ushort          version;            /* driver version */
+            u16          version;            /* driver version */
         } drvers;
         struct {
-            unchar          type;               /* controller type */
-            ushort          info;               /* slot etc. */
-            ushort          oem_id;             /* OEM ID */
-            ushort          bios_ver;           /* not used */
-            ushort          access;             /* not used */
-            ushort          ext_type;           /* extended type */
-            ushort          device_id;          /* device ID */
-            ushort          sub_device_id;      /* sub device ID */
+            u8          type;               /* controller type */
+            u16          info;               /* slot etc. */
+            u16          oem_id;             /* OEM ID */
+            u16          bios_ver;           /* not used */
+            u16          access;             /* not used */
+            u16          ext_type;           /* extended type */
+            u16          device_id;          /* device ID */
+            u16          sub_device_id;      /* sub device ID */
         } ctrtype;
         struct {
-            unchar          version;            /* OS version */
-            unchar          subversion;         /* OS subversion */
-            ushort          revision;           /* revision */
+            u8          version;            /* OS version */
+            u8          subversion;         /* OS subversion */
+            u16          revision;           /* revision */
         } osvers;
         struct {
-            ushort          count;              /* controller count */
+            u16          count;              /* controller count */
         } ctrcnt;
         struct {
             int             handle;
-            unchar          evt[EVENT_SIZE];    /* event structure */
+            u8          evt[EVENT_SIZE];    /* event structure */
         } event;
         struct {
-            unchar          bus;                /* SCSI bus, 0xff: invalid */
-            unchar          target;             /* target ID */
-            unchar          lun;                /* LUN */
-            unchar          cluster_type;       /* cluster properties */
+            u8          bus;                /* SCSI bus, 0xff: invalid */
+            u8          target;             /* target ID */
+            u8          lun;                /* LUN */
+            u8          cluster_type;       /* cluster properties */
         } hdr_list[MAX_HDRIVES];                /* index is host drive number */
     } iu;
 } gdth_iord_str;
@@ -272,53 +264,53 @@ typedef struct {
 
 /* GDTIOCTL_GENERAL */
 typedef struct {
-    ushort ionode;                              /* controller number */
-    ushort timeout;                             /* timeout */
-    ulong32 info;                               /* error info */ 
-    ushort status;                              /* status */
-    ulong data_len;                             /* data buffer size */
-    ulong sense_len;                            /* sense buffer size */
+    u16 ionode;                              /* controller number */
+    u16 timeout;                             /* timeout */
+    u32 info;                               /* error info */ 
+    u16 status;                              /* status */
+    unsigned long data_len;                             /* data buffer size */
+    unsigned long sense_len;                            /* sense buffer size */
     gdth_cmd_str command;                       /* command */                   
 } gdth_ioctl_general;
 
 /* GDTIOCTL_LOCKDRV */
 typedef struct {
-    ushort ionode;                              /* controller number */
-    unchar lock;                                /* lock/unlock */
-    unchar drive_cnt;                           /* drive count */
-    ushort drives[MAX_HDRIVES];                 /* drives */
+    u16 ionode;                              /* controller number */
+    u8 lock;                                /* lock/unlock */
+    u8 drive_cnt;                           /* drive count */
+    u16 drives[MAX_HDRIVES];                 /* drives */
 } gdth_ioctl_lockdrv;
 
 /* GDTIOCTL_LOCKCHN */
 typedef struct {
-    ushort ionode;                              /* controller number */
-    unchar lock;                                /* lock/unlock */
-    unchar channel;                             /* channel */
+    u16 ionode;                              /* controller number */
+    u8 lock;                                /* lock/unlock */
+    u8 channel;                             /* channel */
 } gdth_ioctl_lockchn;
 
 /* GDTIOCTL_OSVERS */
 typedef struct {
-    unchar version;                             /* OS version */
-    unchar subversion;                          /* OS subversion */
-    ushort revision;                            /* revision */
+    u8 version;                             /* OS version */
+    u8 subversion;                          /* OS subversion */
+    u16 revision;                            /* revision */
 } gdth_ioctl_osvers;
 
 /* GDTIOCTL_CTRTYPE */
 typedef struct {
-    ushort ionode;                              /* controller number */
-    unchar type;                                /* controller type */
-    ushort info;                                /* slot etc. */
-    ushort oem_id;                              /* OEM ID */
-    ushort bios_ver;                            /* not used */
-    ushort access;                              /* not used */
-    ushort ext_type;                            /* extended type */
-    ushort device_id;                           /* device ID */
-    ushort sub_device_id;                       /* sub device ID */
+    u16 ionode;                              /* controller number */
+    u8 type;                                /* controller type */
+    u16 info;                                /* slot etc. */
+    u16 oem_id;                              /* OEM ID */
+    u16 bios_ver;                            /* not used */
+    u16 access;                              /* not used */
+    u16 ext_type;                            /* extended type */
+    u16 device_id;                           /* device ID */
+    u16 sub_device_id;                       /* sub device ID */
 } gdth_ioctl_ctrtype;
 
 /* GDTIOCTL_EVENT */
 typedef struct {
-    ushort ionode;
+    u16 ionode;
     int erase;                                  /* erase event? */
     int handle;                                 /* event handle */
     gdth_evt_str event;
@@ -326,22 +318,22 @@ typedef struct {
 
 /* GDTIOCTL_RESCAN/GDTIOCTL_HDRLIST */
 typedef struct {
-    ushort ionode;                              /* controller number */
-    unchar flag;                                /* add/remove */
-    ushort hdr_no;                              /* drive no. */
+    u16 ionode;                              /* controller number */
+    u8 flag;                                /* add/remove */
+    u16 hdr_no;                              /* drive no. */
     struct {
-        unchar bus;                             /* SCSI bus */
-        unchar target;                          /* target ID */
-        unchar lun;                             /* LUN */
-        unchar cluster_type;                    /* cluster properties */
+        u8 bus;                             /* SCSI bus */
+        u8 target;                          /* target ID */
+        u8 lun;                             /* LUN */
+        u8 cluster_type;                    /* cluster properties */
     } hdr_list[MAX_HDRIVES];                    /* index is host drive number */
 } gdth_ioctl_rescan;
 
 /* GDTIOCTL_RESET_BUS/GDTIOCTL_RESET_DRV */
 typedef struct {
-    ushort ionode;                              /* controller number */
-    ushort number;                              /* bus/host drive number */
-    ushort status;                              /* status */
+    u16 ionode;                              /* controller number */
+    u16 number;                              /* bus/host drive number */
+    u16 status;                              /* status */
 } gdth_ioctl_reset;
 
 #endif
diff --git a/drivers/scsi/gdth_proc.c b/drivers/scsi/gdth_proc.c
index 1258da34fbc2..0572b9bf4bd6 100644
--- a/drivers/scsi/gdth_proc.c
+++ b/drivers/scsi/gdth_proc.c
@@ -3,6 +3,7 @@
  */
 
 #include <linux/completion.h>
+#include <linux/slab.h>
 
 int gdth_proc_info(struct Scsi_Host *host, char *buffer,char **start,off_t offset,int length,   
                    int inout)
@@ -43,7 +44,7 @@ static int gdth_set_asc_info(struct Scsi_Host *host, char *buffer,
     int i, found;
     gdth_cmd_str    gdtcmd;
     gdth_cpar_str   *pcpar;
-    ulong64         paddr;
+    u64         paddr;
 
     char            cmnd[MAX_COMMAND_SIZE];
     memset(cmnd, 0xff, 12);
@@ -156,8 +157,8 @@ static int gdth_get_info(char *buffer,char **start,off_t offset,int length,
     off_t begin = 0,pos = 0;
     int id, i, j, k, sec, flag;
     int no_mdrv = 0, drv_no, is_mirr;
-    ulong32 cnt;
-    ulong64 paddr;
+    u32 cnt;
+    u64 paddr;
     int rc = -ENOMEM;
 
     gdth_cmd_str *gdtcmd;
@@ -220,14 +221,14 @@ static int gdth_get_info(char *buffer,char **start,off_t offset,int length,
 
     if (ha->more_proc)
         sprintf(hrec, "%d.%02d.%02d-%c%03X", 
-                (unchar)(ha->binfo.upd_fw_ver>>24),
-                (unchar)(ha->binfo.upd_fw_ver>>16),
-                (unchar)(ha->binfo.upd_fw_ver),
+                (u8)(ha->binfo.upd_fw_ver>>24),
+                (u8)(ha->binfo.upd_fw_ver>>16),
+                (u8)(ha->binfo.upd_fw_ver),
                 ha->bfeat.raid ? 'R':'N',
                 ha->binfo.upd_revision);
     else
-        sprintf(hrec, "%d.%02d", (unchar)(ha->cpar.version>>8),
-                (unchar)(ha->cpar.version));
+        sprintf(hrec, "%d.%02d", (u8)(ha->cpar.version>>8),
+                (u8)(ha->cpar.version));
 
     size = sprintf(buffer+len,
                    " Driver Ver.:  \t%-10s\tFirmware Ver.: \t%s\n",
@@ -281,7 +282,7 @@ static int gdth_get_info(char *buffer,char **start,off_t offset,int length,
             pds->bid = ha->raw[i].local_no;
             pds->first = 0;
             pds->entries = ha->raw[i].pdev_cnt;
-            cnt = (3*GDTH_SCRATCH/4 - 5 * sizeof(ulong32)) /
+            cnt = (3*GDTH_SCRATCH/4 - 5 * sizeof(u32)) /
                 sizeof(pds->list[0]);
             if (pds->entries > cnt)
                 pds->entries = cnt;
@@ -604,7 +605,7 @@ static int gdth_get_info(char *buffer,char **start,off_t offset,int length,
 
             size = sprintf(buffer+len,
                            " Capacity [MB]:\t%-6d    \tStart Sector:  \t%d\n",
-                           (ulong32)(ha->hdr[i].size/2048), ha->hdr[i].start_sec);
+                           (u32)(ha->hdr[i].size/2048), ha->hdr[i].start_sec);
             len += size;  pos = begin + len;
             if (pos < offset) {
                 len = 0;
@@ -664,9 +665,9 @@ free_fail:
 }
 
 static char *gdth_ioctl_alloc(gdth_ha_str *ha, int size, int scratch,
-                              ulong64 *paddr)
+                              u64 *paddr)
 {
-    ulong flags;
+    unsigned long flags;
     char *ret_val;
 
     if (size == 0)
@@ -691,9 +692,9 @@ static char *gdth_ioctl_alloc(gdth_ha_str *ha, int size, int scratch,
     return ret_val;
 }
 
-static void gdth_ioctl_free(gdth_ha_str *ha, int size, char *buf, ulong64 paddr)
+static void gdth_ioctl_free(gdth_ha_str *ha, int size, char *buf, u64 paddr)
 {
-    ulong flags;
+    unsigned long flags;
 
     if (buf == ha->pscratch) {
         spin_lock_irqsave(&ha->smp_lock, flags);
@@ -705,16 +706,16 @@ static void gdth_ioctl_free(gdth_ha_str *ha, int size, char *buf, ulong64 paddr)
 }
 
 #ifdef GDTH_IOCTL_PROC
-static int gdth_ioctl_check_bin(gdth_ha_str *ha, ushort size)
+static int gdth_ioctl_check_bin(gdth_ha_str *ha, u16 size)
 {
-    ulong flags;
+    unsigned long flags;
     int ret_val;
 
     spin_lock_irqsave(&ha->smp_lock, flags);
 
     ret_val = FALSE;
     if (ha->scratch_busy) {
-        if (((gdth_iord_str *)ha->pscratch)->size == (ulong32)size)
+        if (((gdth_iord_str *)ha->pscratch)->size == (u32)size)
             ret_val = TRUE;
     }
     spin_unlock_irqrestore(&ha->smp_lock, flags);
@@ -724,11 +725,11 @@ static int gdth_ioctl_check_bin(gdth_ha_str *ha, ushort size)
 
 static void gdth_wait_completion(gdth_ha_str *ha, int busnum, int id)
 {
-    ulong flags;
+    unsigned long flags;
     int i;
     Scsi_Cmnd *scp;
     struct gdth_cmndinfo *cmndinfo;
-    unchar b, t;
+    u8 b, t;
 
     spin_lock_irqsave(&ha->smp_lock, flags);
 
@@ -738,8 +739,8 @@ static void gdth_wait_completion(gdth_ha_str *ha, int busnum, int id)
 
         b = scp->device->channel;
         t = scp->device->id;
-        if (!SPECIAL_SCP(scp) && t == (unchar)id && 
-            b == (unchar)busnum) {
+        if (!SPECIAL_SCP(scp) && t == (u8)id && 
+            b == (u8)busnum) {
             cmndinfo->wait_for_completion = 0;
             spin_unlock_irqrestore(&ha->smp_lock, flags);
             while (!cmndinfo->wait_for_completion)
diff --git a/drivers/scsi/gdth_proc.h b/drivers/scsi/gdth_proc.h
index 9b900cc9ebe8..dab15f59f2cc 100644
--- a/drivers/scsi/gdth_proc.h
+++ b/drivers/scsi/gdth_proc.h
@@ -17,8 +17,8 @@ static int gdth_set_asc_info(struct Scsi_Host *host, char *buffer,
                              int length, gdth_ha_str *ha);
 
 static char *gdth_ioctl_alloc(gdth_ha_str *ha, int size, int scratch,
-                              ulong64 *paddr);
-static void gdth_ioctl_free(gdth_ha_str *ha, int size, char *buf, ulong64 paddr);
+                              u64 *paddr);
+static void gdth_ioctl_free(gdth_ha_str *ha, int size, char *buf, u64 paddr);
 static void gdth_wait_completion(gdth_ha_str *ha, int busnum, int id);
 
 #endif
diff --git a/drivers/scsi/gvp11.c b/drivers/scsi/gvp11.c
index 5d1bf7e3d245..48f406850c65 100644
--- a/drivers/scsi/gvp11.c
+++ b/drivers/scsi/gvp11.c
@@ -1,5 +1,6 @@
 #include <linux/types.h>
 #include <linux/mm.h>
+#include <linux/slab.h>
 #include <linux/blkdev.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index c968cc31cd86..6660fa92ffa1 100644
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -24,6 +24,7 @@
 #include <linux/module.h>
 #include <linux/blkdev.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/kthread.h>
 #include <linux/string.h>
 #include <linux/mm.h>
@@ -180,14 +181,20 @@ void scsi_remove_host(struct Scsi_Host *shost)
 EXPORT_SYMBOL(scsi_remove_host);
 
 /**
- * scsi_add_host - add a scsi host
+ * scsi_add_host_with_dma - add a scsi host with dma device
  * @shost:      scsi host pointer to add
  * @dev:        a struct device of type scsi class
+ * @dma_dev:    dma device for the host
+ *
+ * Note: You rarely need to worry about this unless you're in a
+ * virtualised host environments, so use the simpler scsi_add_host()
+ * function instead.
  *
  * Return value: 
  *      0 on success / != 0 for error
  **/
-int scsi_add_host(struct Scsi_Host *shost, struct device *dev)
+int scsi_add_host_with_dma(struct Scsi_Host *shost, struct device *dev,
+                           struct device *dma_dev)
 {
         struct scsi_host_template *sht = shost->hostt;
         int error = -EINVAL;
@@ -207,6 +214,9 @@ int scsi_add_host(struct Scsi_Host *shost, struct device *dev)
 
         if (!shost->shost_gendev.parent)
                 shost->shost_gendev.parent = dev ? dev : &platform_bus;
+        shost->dma_dev = dma_dev;
+
+        device_enable_async_suspend(&shost->shost_gendev);
 
         error = device_add(&shost->shost_gendev);
         if (error)
@@ -215,6 +225,8 @@ int scsi_add_host(struct Scsi_Host *shost, struct device *dev)
         scsi_host_set_state(shost, SHOST_RUNNING);
         get_device(shost->shost_gendev.parent);
 
+        device_enable_async_suspend(&shost->shost_dev);
+
         error = device_add(&shost->shost_dev);
         if (error)
                 goto out_del_gendev;
@@ -262,7 +274,7 @@ int scsi_add_host(struct Scsi_Host *shost, struct device *dev)
  fail:
         return error;
 }
-EXPORT_SYMBOL(scsi_add_host);
+EXPORT_SYMBOL(scsi_add_host_with_dma);
 
 static void scsi_host_dev_release(struct device *dev)
 {
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
new file mode 100644
index 000000000000..183d3a43c280
--- /dev/null
+++ b/drivers/scsi/hpsa.c
@@ -0,0 +1,3854 @@
+/*
+ *    Disk Array driver for HP Smart Array SAS controllers
+ *    Copyright 2000, 2009 Hewlett-Packard Development Company, L.P.
+ *
+ *    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; version 2 of the License.
+ *
+ *    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, GOOD TITLE or
+ *    NON INFRINGEMENT.  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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *    Questions/Comments/Bugfixes to iss_storagedev@hp.com
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/types.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/fs.h>
+#include <linux/timer.h>
+#include <linux/seq_file.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+#include <linux/smp_lock.h>
+#include <linux/compat.h>
+#include <linux/blktrace_api.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
+#include <linux/dma-mapping.h>
+#include <linux/completion.h>
+#include <linux/moduleparam.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_tcq.h>
+#include <linux/cciss_ioctl.h>
+#include <linux/string.h>
+#include <linux/bitmap.h>
+#include <asm/atomic.h>
+#include <linux/kthread.h>
+#include "hpsa_cmd.h"
+#include "hpsa.h"
+
+/* HPSA_DRIVER_VERSION must be 3 byte values (0-255) separated by '.' */
+#define HPSA_DRIVER_VERSION "2.0.2-1"
+#define DRIVER_NAME "HP HPSA Driver (v " HPSA_DRIVER_VERSION ")"
+
+/* How long to wait (in milliseconds) for board to go into simple mode */
+#define MAX_CONFIG_WAIT 30000
+#define MAX_IOCTL_CONFIG_WAIT 1000
+
+/*define how many times we will try a command because of bus resets */
+#define MAX_CMD_RETRIES 3
+
+/* Embedded module documentation macros - see modules.h */
+MODULE_AUTHOR("Hewlett-Packard Company");
+MODULE_DESCRIPTION("Driver for HP Smart Array Controller version " \
+        HPSA_DRIVER_VERSION);
+MODULE_SUPPORTED_DEVICE("HP Smart Array Controllers");
+MODULE_VERSION(HPSA_DRIVER_VERSION);
+MODULE_LICENSE("GPL");
+
+static int hpsa_allow_any;
+module_param(hpsa_allow_any, int, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(hpsa_allow_any,
+                "Allow hpsa driver to access unknown HP Smart Array hardware");
+
+/* define the PCI info for the cards we can control */
+static const struct pci_device_id hpsa_pci_device_id[] = {
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3241},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3243},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3245},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3247},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3249},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x324a},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x324b},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3233},
+#define PCI_DEVICE_ID_HP_CISSF 0x333f
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSF,     0x103C, 0x333F},
+        {PCI_VENDOR_ID_HP,     PCI_ANY_ID,             PCI_ANY_ID, PCI_ANY_ID,
+                PCI_CLASS_STORAGE_RAID << 8, 0xffff << 8, 0},
+        {0,}
+};
+
+MODULE_DEVICE_TABLE(pci, hpsa_pci_device_id);
+
+/*  board_id = Subsystem Device ID & Vendor ID
+ *  product = Marketing Name for the board
+ *  access = Address of the struct of function pointers
+ */
+static struct board_type products[] = {
+        {0x3241103C, "Smart Array P212", &SA5_access},
+        {0x3243103C, "Smart Array P410", &SA5_access},
+        {0x3245103C, "Smart Array P410i", &SA5_access},
+        {0x3247103C, "Smart Array P411", &SA5_access},
+        {0x3249103C, "Smart Array P812", &SA5_access},
+        {0x324a103C, "Smart Array P712m", &SA5_access},
+        {0x324b103C, "Smart Array P711m", &SA5_access},
+        {0x3233103C, "StorageWorks P1210m", &SA5_access},
+        {0x333F103C, "StorageWorks P1210m", &SA5_access},
+        {0xFFFF103C, "Unknown Smart Array", &SA5_access},
+};
+
+static int number_of_controllers;
+
+static irqreturn_t do_hpsa_intr(int irq, void *dev_id);
+static int hpsa_ioctl(struct scsi_device *dev, int cmd, void *arg);
+static void start_io(struct ctlr_info *h);
+
+#ifdef CONFIG_COMPAT
+static int hpsa_compat_ioctl(struct scsi_device *dev, int cmd, void *arg);
+#endif
+
+static void cmd_free(struct ctlr_info *h, struct CommandList *c);
+static void cmd_special_free(struct ctlr_info *h, struct CommandList *c);
+static struct CommandList *cmd_alloc(struct ctlr_info *h);
+static struct CommandList *cmd_special_alloc(struct ctlr_info *h);
+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);
+
+static int hpsa_scsi_queue_command(struct scsi_cmnd *cmd,
+                void (*done)(struct scsi_cmnd *));
+static void hpsa_scan_start(struct Scsi_Host *);
+static int hpsa_scan_finished(struct Scsi_Host *sh,
+        unsigned long elapsed_time);
+static int hpsa_change_queue_depth(struct scsi_device *sdev,
+        int qdepth, int reason);
+
+static int hpsa_eh_device_reset_handler(struct scsi_cmnd *scsicmd);
+static int hpsa_slave_alloc(struct scsi_device *sdev);
+static void hpsa_slave_destroy(struct scsi_device *sdev);
+
+static ssize_t raid_level_show(struct device *dev,
+        struct device_attribute *attr, char *buf);
+static ssize_t lunid_show(struct device *dev,
+        struct device_attribute *attr, char *buf);
+static ssize_t unique_id_show(struct device *dev,
+        struct device_attribute *attr, char *buf);
+static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno);
+static ssize_t host_store_rescan(struct device *dev,
+         struct device_attribute *attr, const char *buf, size_t count);
+static int check_for_unit_attention(struct ctlr_info *h,
+        struct CommandList *c);
+static void check_ioctl_unit_attention(struct ctlr_info *h,
+        struct CommandList *c);
+/* performant mode helper functions */
+static void calc_bucket_map(int *bucket, int num_buckets,
+        int nsgs, int *bucket_map);
+static void hpsa_put_ctlr_into_performant_mode(struct ctlr_info *h);
+static inline u32 next_command(struct ctlr_info *h);
+
+static DEVICE_ATTR(raid_level, S_IRUGO, raid_level_show, NULL);
+static DEVICE_ATTR(lunid, S_IRUGO, lunid_show, NULL);
+static DEVICE_ATTR(unique_id, S_IRUGO, unique_id_show, NULL);
+static DEVICE_ATTR(rescan, S_IWUSR, NULL, host_store_rescan);
+
+static struct device_attribute *hpsa_sdev_attrs[] = {
+        &dev_attr_raid_level,
+        &dev_attr_lunid,
+        &dev_attr_unique_id,
+        NULL,
+};
+
+static struct device_attribute *hpsa_shost_attrs[] = {
+        &dev_attr_rescan,
+        NULL,
+};
+
+static struct scsi_host_template hpsa_driver_template = {
+        .module                 = THIS_MODULE,
+        .name                   = "hpsa",
+        .proc_name              = "hpsa",
+        .queuecommand           = hpsa_scsi_queue_command,
+        .scan_start             = hpsa_scan_start,
+        .scan_finished          = hpsa_scan_finished,
+        .change_queue_depth     = hpsa_change_queue_depth,
+        .this_id                = -1,
+        .use_clustering         = ENABLE_CLUSTERING,
+        .eh_device_reset_handler = hpsa_eh_device_reset_handler,
+        .ioctl                  = hpsa_ioctl,
+        .slave_alloc            = hpsa_slave_alloc,
+        .slave_destroy          = hpsa_slave_destroy,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl           = hpsa_compat_ioctl,
+#endif
+        .sdev_attrs = hpsa_sdev_attrs,
+        .shost_attrs = hpsa_shost_attrs,
+};
+
+static inline struct ctlr_info *sdev_to_hba(struct scsi_device *sdev)
+{
+        unsigned long *priv = shost_priv(sdev->host);
+        return (struct ctlr_info *) *priv;
+}
+
+static inline struct ctlr_info *shost_to_hba(struct Scsi_Host *sh)
+{
+        unsigned long *priv = shost_priv(sh);
+        return (struct ctlr_info *) *priv;
+}
+
+static int check_for_unit_attention(struct ctlr_info *h,
+        struct CommandList *c)
+{
+        if (c->err_info->SenseInfo[2] != UNIT_ATTENTION)
+                return 0;
+
+        switch (c->err_info->SenseInfo[12]) {
+        case STATE_CHANGED:
+                dev_warn(&h->pdev->dev, "hpsa%d: a state change "
+                        "detected, command retried\n", h->ctlr);
+                break;
+        case LUN_FAILED:
+                dev_warn(&h->pdev->dev, "hpsa%d: LUN failure "
+                        "detected, action required\n", h->ctlr);
+                break;
+        case REPORT_LUNS_CHANGED:
+                dev_warn(&h->pdev->dev, "hpsa%d: report LUN data "
+                        "changed, action required\n", h->ctlr);
+        /*
+         * Note: this REPORT_LUNS_CHANGED condition only occurs on the MSA2012.
+         */
+                break;
+        case POWER_OR_RESET:
+                dev_warn(&h->pdev->dev, "hpsa%d: a power on "
+                        "or device reset detected\n", h->ctlr);
+                break;
+        case UNIT_ATTENTION_CLEARED:
+                dev_warn(&h->pdev->dev, "hpsa%d: unit attention "
+                    "cleared by another initiator\n", h->ctlr);
+                break;
+        default:
+                dev_warn(&h->pdev->dev, "hpsa%d: unknown "
+                        "unit attention detected\n", h->ctlr);
+                break;
+        }
+        return 1;
+}
+
+static ssize_t host_store_rescan(struct device *dev,
+                                 struct device_attribute *attr,
+                                 const char *buf, size_t count)
+{
+        struct ctlr_info *h;
+        struct Scsi_Host *shost = class_to_shost(dev);
+        h = shost_to_hba(shost);
+        hpsa_scan_start(h->scsi_host);
+        return count;
+}
+
+/* Enqueuing and dequeuing functions for cmdlists. */
+static inline void addQ(struct hlist_head *list, struct CommandList *c)
+{
+        hlist_add_head(&c->list, list);
+}
+
+static inline u32 next_command(struct ctlr_info *h)
+{
+        u32 a;
+
+        if (unlikely(h->transMethod != CFGTBL_Trans_Performant))
+                return h->access.command_completed(h);
+
+        if ((*(h->reply_pool_head) & 1) == (h->reply_pool_wraparound)) {
+                a = *(h->reply_pool_head); /* Next cmd in ring buffer */
+                (h->reply_pool_head)++;
+                h->commands_outstanding--;
+        } else {
+                a = FIFO_EMPTY;
+        }
+        /* Check for wraparound */
+        if (h->reply_pool_head == (h->reply_pool + h->max_commands)) {
+                h->reply_pool_head = h->reply_pool;
+                h->reply_pool_wraparound ^= 1;
+        }
+        return a;
+}
+
+/* set_performant_mode: Modify the tag for cciss performant
+ * set bit 0 for pull model, bits 3-1 for block fetch
+ * register number
+ */
+static void set_performant_mode(struct ctlr_info *h, struct CommandList *c)
+{
+        if (likely(h->transMethod == CFGTBL_Trans_Performant))
+                c->busaddr |= 1 | (h->blockFetchTable[c->Header.SGList] << 1);
+}
+
+static void enqueue_cmd_and_start_io(struct ctlr_info *h,
+        struct CommandList *c)
+{
+        unsigned long flags;
+
+        set_performant_mode(h, c);
+        spin_lock_irqsave(&h->lock, flags);
+        addQ(&h->reqQ, c);
+        h->Qdepth++;
+        start_io(h);
+        spin_unlock_irqrestore(&h->lock, flags);
+}
+
+static inline void removeQ(struct CommandList *c)
+{
+        if (WARN_ON(hlist_unhashed(&c->list)))
+                return;
+        hlist_del_init(&c->list);
+}
+
+static inline int is_hba_lunid(unsigned char scsi3addr[])
+{
+        return memcmp(scsi3addr, RAID_CTLR_LUNID, 8) == 0;
+}
+
+static inline int is_logical_dev_addr_mode(unsigned char scsi3addr[])
+{
+        return (scsi3addr[3] & 0xC0) == 0x40;
+}
+
+static inline int is_scsi_rev_5(struct ctlr_info *h)
+{
+        if (!h->hba_inquiry_data)
+                return 0;
+        if ((h->hba_inquiry_data[2] & 0x07) == 5)
+                return 1;
+        return 0;
+}
+
+static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
+        "UNKNOWN"
+};
+#define RAID_UNKNOWN (ARRAY_SIZE(raid_label) - 1)
+
+static ssize_t raid_level_show(struct device *dev,
+             struct device_attribute *attr, char *buf)
+{
+        ssize_t l = 0;
+        unsigned char rlevel;
+        struct ctlr_info *h;
+        struct scsi_device *sdev;
+        struct hpsa_scsi_dev_t *hdev;
+        unsigned long flags;
+
+        sdev = to_scsi_device(dev);
+        h = sdev_to_hba(sdev);
+        spin_lock_irqsave(&h->lock, flags);
+        hdev = sdev->hostdata;
+        if (!hdev) {
+                spin_unlock_irqrestore(&h->lock, flags);
+                return -ENODEV;
+        }
+
+        /* Is this even a logical drive? */
+        if (!is_logical_dev_addr_mode(hdev->scsi3addr)) {
+                spin_unlock_irqrestore(&h->lock, flags);
+                l = snprintf(buf, PAGE_SIZE, "N/A\n");
+                return l;
+        }
+
+        rlevel = hdev->raid_level;
+        spin_unlock_irqrestore(&h->lock, flags);
+        if (rlevel > RAID_UNKNOWN)
+                rlevel = RAID_UNKNOWN;
+        l = snprintf(buf, PAGE_SIZE, "RAID %s\n", raid_label[rlevel]);
+        return l;
+}
+
+static ssize_t lunid_show(struct device *dev,
+             struct device_attribute *attr, char *buf)
+{
+        struct ctlr_info *h;
+        struct scsi_device *sdev;
+        struct hpsa_scsi_dev_t *hdev;
+        unsigned long flags;
+        unsigned char lunid[8];
+
+        sdev = to_scsi_device(dev);
+        h = sdev_to_hba(sdev);
+        spin_lock_irqsave(&h->lock, flags);
+        hdev = sdev->hostdata;
+        if (!hdev) {
+                spin_unlock_irqrestore(&h->lock, flags);
+                return -ENODEV;
+        }
+        memcpy(lunid, hdev->scsi3addr, sizeof(lunid));
+        spin_unlock_irqrestore(&h->lock, flags);
+        return snprintf(buf, 20, "0x%02x%02x%02x%02x%02x%02x%02x%02x\n",
+                lunid[0], lunid[1], lunid[2], lunid[3],
+                lunid[4], lunid[5], lunid[6], lunid[7]);
+}
+
+static ssize_t unique_id_show(struct device *dev,
+             struct device_attribute *attr, char *buf)
+{
+        struct ctlr_info *h;
+        struct scsi_device *sdev;
+        struct hpsa_scsi_dev_t *hdev;
+        unsigned long flags;
+        unsigned char sn[16];
+
+        sdev = to_scsi_device(dev);
+        h = sdev_to_hba(sdev);
+        spin_lock_irqsave(&h->lock, flags);
+        hdev = sdev->hostdata;
+        if (!hdev) {
+                spin_unlock_irqrestore(&h->lock, flags);
+                return -ENODEV;
+        }
+        memcpy(sn, hdev->device_id, sizeof(sn));
+        spin_unlock_irqrestore(&h->lock, flags);
+        return snprintf(buf, 16 * 2 + 2,
+                        "%02X%02X%02X%02X%02X%02X%02X%02X"
+                        "%02X%02X%02X%02X%02X%02X%02X%02X\n",
+                        sn[0], sn[1], sn[2], sn[3],
+                        sn[4], sn[5], sn[6], sn[7],
+                        sn[8], sn[9], sn[10], sn[11],
+                        sn[12], sn[13], sn[14], sn[15]);
+}
+
+static int hpsa_find_target_lun(struct ctlr_info *h,
+        unsigned char scsi3addr[], int bus, int *target, int *lun)
+{
+        /* finds an unused bus, target, lun for a new physical device
+         * assumes h->devlock is held
+         */
+        int i, found = 0;
+        DECLARE_BITMAP(lun_taken, HPSA_MAX_SCSI_DEVS_PER_HBA);
+
+        memset(&lun_taken[0], 0, HPSA_MAX_SCSI_DEVS_PER_HBA >> 3);
+
+        for (i = 0; i < h->ndevices; i++) {
+                if (h->dev[i]->bus == bus && h->dev[i]->target != -1)
+                        set_bit(h->dev[i]->target, lun_taken);
+        }
+
+        for (i = 0; i < HPSA_MAX_SCSI_DEVS_PER_HBA; i++) {
+                if (!test_bit(i, lun_taken)) {
+                        /* *bus = 1; */
+                        *target = i;
+                        *lun = 0;
+                        found = 1;
+                        break;
+                }
+        }
+        return !found;
+}
+
+/* Add an entry into h->dev[] array. */
+static int hpsa_scsi_add_entry(struct ctlr_info *h, int hostno,
+                struct hpsa_scsi_dev_t *device,
+                struct hpsa_scsi_dev_t *added[], int *nadded)
+{
+        /* assumes h->devlock is held */
+        int n = h->ndevices;
+        int i;
+        unsigned char addr1[8], addr2[8];
+        struct hpsa_scsi_dev_t *sd;
+
+        if (n >= HPSA_MAX_SCSI_DEVS_PER_HBA) {
+                dev_err(&h->pdev->dev, "too many devices, some will be "
+                        "inaccessible.\n");
+                return -1;
+        }
+
+        /* physical devices do not have lun or target assigned until now. */
+        if (device->lun != -1)
+                /* Logical device, lun is already assigned. */
+                goto lun_assigned;
+
+        /* If this device a non-zero lun of a multi-lun device
+         * byte 4 of the 8-byte LUN addr will contain the logical
+         * unit no, zero otherise.
+         */
+        if (device->scsi3addr[4] == 0) {
+                /* This is not a non-zero lun of a multi-lun device */
+                if (hpsa_find_target_lun(h, device->scsi3addr,
+                        device->bus, &device->target, &device->lun) != 0)
+                        return -1;
+                goto lun_assigned;
+        }
+
+        /* This is a non-zero lun of a multi-lun device.
+         * Search through our list and find the device which
+         * has the same 8 byte LUN address, excepting byte 4.
+         * Assign the same bus and target for this new LUN.
+         * Use the logical unit number from the firmware.
+         */
+        memcpy(addr1, device->scsi3addr, 8);
+        addr1[4] = 0;
+        for (i = 0; i < n; i++) {
+                sd = h->dev[i];
+                memcpy(addr2, sd->scsi3addr, 8);
+                addr2[4] = 0;
+                /* differ only in byte 4? */
+                if (memcmp(addr1, addr2, 8) == 0) {
+                        device->bus = sd->bus;
+                        device->target = sd->target;
+                        device->lun = device->scsi3addr[4];
+                        break;
+                }
+        }
+        if (device->lun == -1) {
+                dev_warn(&h->pdev->dev, "physical device with no LUN=0,"
+                        " suspect firmware bug or unsupported hardware "
+                        "configuration.\n");
+                        return -1;
+        }
+
+lun_assigned:
+
+        h->dev[n] = device;
+        h->ndevices++;
+        added[*nadded] = device;
+        (*nadded)++;
+
+        /* initially, (before registering with scsi layer) we don't
+         * know our hostno and we don't want to print anything first
+         * time anyway (the scsi layer's inquiries will show that info)
+         */
+        /* if (hostno != -1) */
+                dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d added.\n",
+                        scsi_device_type(device->devtype), hostno,
+                        device->bus, device->target, device->lun);
+        return 0;
+}
+
+/* Replace an entry from h->dev[] array. */
+static void hpsa_scsi_replace_entry(struct ctlr_info *h, int hostno,
+        int entry, struct hpsa_scsi_dev_t *new_entry,
+        struct hpsa_scsi_dev_t *added[], int *nadded,
+        struct hpsa_scsi_dev_t *removed[], int *nremoved)
+{
+        /* assumes h->devlock is held */
+        BUG_ON(entry < 0 || entry >= HPSA_MAX_SCSI_DEVS_PER_HBA);
+        removed[*nremoved] = h->dev[entry];
+        (*nremoved)++;
+        h->dev[entry] = new_entry;
+        added[*nadded] = new_entry;
+        (*nadded)++;
+        dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d changed.\n",
+                scsi_device_type(new_entry->devtype), hostno, new_entry->bus,
+                        new_entry->target, new_entry->lun);
+}
+
+/* Remove an entry from h->dev[] array. */
+static void hpsa_scsi_remove_entry(struct ctlr_info *h, int hostno, int entry,
+        struct hpsa_scsi_dev_t *removed[], int *nremoved)
+{
+        /* assumes h->devlock is held */
+        int i;
+        struct hpsa_scsi_dev_t *sd;
+
+        BUG_ON(entry < 0 || entry >= HPSA_MAX_SCSI_DEVS_PER_HBA);
+
+        sd = h->dev[entry];
+        removed[*nremoved] = h->dev[entry];
+        (*nremoved)++;
+
+        for (i = entry; i < h->ndevices-1; i++)
+                h->dev[i] = h->dev[i+1];
+        h->ndevices--;
+        dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d removed.\n",
+                scsi_device_type(sd->devtype), hostno, sd->bus, sd->target,
+                sd->lun);
+}
+
+#define SCSI3ADDR_EQ(a, b) ( \
+        (a)[7] == (b)[7] && \
+        (a)[6] == (b)[6] && \
+        (a)[5] == (b)[5] && \
+        (a)[4] == (b)[4] && \
+        (a)[3] == (b)[3] && \
+        (a)[2] == (b)[2] && \
+        (a)[1] == (b)[1] && \
+        (a)[0] == (b)[0])
+
+static void fixup_botched_add(struct ctlr_info *h,
+        struct hpsa_scsi_dev_t *added)
+{
+        /* called when scsi_add_device fails in order to re-adjust
+         * h->dev[] to match the mid layer's view.
+         */
+        unsigned long flags;
+        int i, j;
+
+        spin_lock_irqsave(&h->lock, flags);
+        for (i = 0; i < h->ndevices; i++) {
+                if (h->dev[i] == added) {
+                        for (j = i; j < h->ndevices-1; j++)
+                                h->dev[j] = h->dev[j+1];
+                        h->ndevices--;
+                        break;
+                }
+        }
+        spin_unlock_irqrestore(&h->lock, flags);
+        kfree(added);
+}
+
+static inline int device_is_the_same(struct hpsa_scsi_dev_t *dev1,
+        struct hpsa_scsi_dev_t *dev2)
+{
+        if ((is_logical_dev_addr_mode(dev1->scsi3addr) ||
+                (dev1->lun != -1 && dev2->lun != -1)) &&
+                dev1->devtype != 0x0C)
+                return (memcmp(dev1, dev2, sizeof(*dev1)) == 0);
+
+        /* we compare everything except lun and target as these
+         * are not yet assigned.  Compare parts likely
+         * to differ first
+         */
+        if (memcmp(dev1->scsi3addr, dev2->scsi3addr,
+                sizeof(dev1->scsi3addr)) != 0)
+                return 0;
+        if (memcmp(dev1->device_id, dev2->device_id,
+                sizeof(dev1->device_id)) != 0)
+                return 0;
+        if (memcmp(dev1->model, dev2->model, sizeof(dev1->model)) != 0)
+                return 0;
+        if (memcmp(dev1->vendor, dev2->vendor, sizeof(dev1->vendor)) != 0)
+                return 0;
+        if (memcmp(dev1->revision, dev2->revision, sizeof(dev1->revision)) != 0)
+                return 0;
+        if (dev1->devtype != dev2->devtype)
+                return 0;
+        if (dev1->raid_level != dev2->raid_level)
+                return 0;
+        if (dev1->bus != dev2->bus)
+                return 0;
+        return 1;
+}
+
+/* Find needle in haystack.  If exact match found, return DEVICE_SAME,
+ * and return needle location in *index.  If scsi3addr matches, but not
+ * vendor, model, serial num, etc. return DEVICE_CHANGED, and return needle
+ * location in *index.  If needle not found, return DEVICE_NOT_FOUND.
+ */
+static int hpsa_scsi_find_entry(struct hpsa_scsi_dev_t *needle,
+        struct hpsa_scsi_dev_t *haystack[], int haystack_size,
+        int *index)
+{
+        int i;
+#define DEVICE_NOT_FOUND 0
+#define DEVICE_CHANGED 1
+#define DEVICE_SAME 2
+        for (i = 0; i < haystack_size; i++) {
+                if (haystack[i] == NULL) /* previously removed. */
+                        continue;
+                if (SCSI3ADDR_EQ(needle->scsi3addr, haystack[i]->scsi3addr)) {
+                        *index = i;
+                        if (device_is_the_same(needle, haystack[i]))
+                                return DEVICE_SAME;
+                        else
+                                return DEVICE_CHANGED;
+                }
+        }
+        *index = -1;
+        return DEVICE_NOT_FOUND;
+}
+
+static void adjust_hpsa_scsi_table(struct ctlr_info *h, int hostno,
+        struct hpsa_scsi_dev_t *sd[], int nsds)
+{
+        /* sd contains scsi3 addresses and devtypes, and inquiry
+         * data.  This function takes what's in sd to be the current
+         * reality and updates h->dev[] to reflect that reality.
+         */
+        int i, entry, device_change, changes = 0;
+        struct hpsa_scsi_dev_t *csd;
+        unsigned long flags;
+        struct hpsa_scsi_dev_t **added, **removed;
+        int nadded, nremoved;
+        struct Scsi_Host *sh = NULL;
+
+        added = kzalloc(sizeof(*added) * HPSA_MAX_SCSI_DEVS_PER_HBA,
+                GFP_KERNEL);
+        removed = kzalloc(sizeof(*removed) * HPSA_MAX_SCSI_DEVS_PER_HBA,
+                GFP_KERNEL);
+
+        if (!added || !removed) {
+                dev_warn(&h->pdev->dev, "out of memory in "
+                        "adjust_hpsa_scsi_table\n");
+                goto free_and_out;
+        }
+
+        spin_lock_irqsave(&h->devlock, flags);
+
+        /* find any devices in h->dev[] that are not in
+         * sd[] and remove them from h->dev[], and for any
+         * devices which have changed, remove the old device
+         * info and add the new device info.
+         */
+        i = 0;
+        nremoved = 0;
+        nadded = 0;
+        while (i < h->ndevices) {
+                csd = h->dev[i];
+                device_change = hpsa_scsi_find_entry(csd, sd, nsds, &entry);
+                if (device_change == DEVICE_NOT_FOUND) {
+                        changes++;
+                        hpsa_scsi_remove_entry(h, hostno, i,
+                                removed, &nremoved);
+                        continue; /* remove ^^^, hence i not incremented */
+                } else if (device_change == DEVICE_CHANGED) {
+                        changes++;
+                        hpsa_scsi_replace_entry(h, hostno, i, sd[entry],
+                                added, &nadded, removed, &nremoved);
+                        /* Set it to NULL to prevent it from being freed
+                         * at the bottom of hpsa_update_scsi_devices()
+                         */
+                        sd[entry] = NULL;
+                }
+                i++;
+        }
+
+        /* Now, make sure every device listed in sd[] is also
+         * listed in h->dev[], adding them if they aren't found
+         */
+
+        for (i = 0; i < nsds; i++) {
+                if (!sd[i]) /* if already added above. */
+                        continue;
+                device_change = hpsa_scsi_find_entry(sd[i], h->dev,
+                                        h->ndevices, &entry);
+                if (device_change == DEVICE_NOT_FOUND) {
+                        changes++;
+                        if (hpsa_scsi_add_entry(h, hostno, sd[i],
+                                added, &nadded) != 0)
+                                break;
+                        sd[i] = NULL; /* prevent from being freed later. */
+                } else if (device_change == DEVICE_CHANGED) {
+                        /* should never happen... */
+                        changes++;
+                        dev_warn(&h->pdev->dev,
+                                "device unexpectedly changed.\n");
+                        /* but if it does happen, we just ignore that device */
+                }
+        }
+        spin_unlock_irqrestore(&h->devlock, flags);
+
+        /* Don't notify scsi mid layer of any changes the first time through
+         * (or if there are no changes) scsi_scan_host will do it later the
+         * first time through.
+         */
+        if (hostno == -1 || !changes)
+                goto free_and_out;
+
+        sh = h->scsi_host;
+        /* Notify scsi mid layer of any removed devices */
+        for (i = 0; i < nremoved; i++) {
+                struct scsi_device *sdev =
+                        scsi_device_lookup(sh, removed[i]->bus,
+                                removed[i]->target, removed[i]->lun);
+                if (sdev != NULL) {
+                        scsi_remove_device(sdev);
+                        scsi_device_put(sdev);
+                } else {
+                        /* We don't expect to get here.
+                         * future cmds to this device will get selection
+                         * timeout as if the device was gone.
+                         */
+                        dev_warn(&h->pdev->dev, "didn't find c%db%dt%dl%d "
+                                " for removal.", hostno, removed[i]->bus,
+                                removed[i]->target, removed[i]->lun);
+                }
+                kfree(removed[i]);
+                removed[i] = NULL;
+        }
+
+        /* Notify scsi mid layer of any added devices */
+        for (i = 0; i < nadded; i++) {
+                if (scsi_add_device(sh, added[i]->bus,
+                        added[i]->target, added[i]->lun) == 0)
+                        continue;
+                dev_warn(&h->pdev->dev, "scsi_add_device c%db%dt%dl%d failed, "
+                        "device not added.\n", hostno, added[i]->bus,
+                        added[i]->target, added[i]->lun);
+                /* now we have to remove it from h->dev,
+                 * since it didn't get added to scsi mid layer
+                 */
+                fixup_botched_add(h, added[i]);
+        }
+
+free_and_out:
+        kfree(added);
+        kfree(removed);
+}
+
+/*
+ * Lookup bus/target/lun and retrun corresponding struct hpsa_scsi_dev_t *
+ * Assume's h->devlock is held.
+ */
+static struct hpsa_scsi_dev_t *lookup_hpsa_scsi_dev(struct ctlr_info *h,
+        int bus, int target, int lun)
+{
+        int i;
+        struct hpsa_scsi_dev_t *sd;
+
+        for (i = 0; i < h->ndevices; i++) {
+                sd = h->dev[i];
+                if (sd->bus == bus && sd->target == target && sd->lun == lun)
+                        return sd;
+        }
+        return NULL;
+}
+
+/* link sdev->hostdata to our per-device structure. */
+static int hpsa_slave_alloc(struct scsi_device *sdev)
+{
+        struct hpsa_scsi_dev_t *sd;
+        unsigned long flags;
+        struct ctlr_info *h;
+
+        h = sdev_to_hba(sdev);
+        spin_lock_irqsave(&h->devlock, flags);
+        sd = lookup_hpsa_scsi_dev(h, sdev_channel(sdev),
+                sdev_id(sdev), sdev->lun);
+        if (sd != NULL)
+                sdev->hostdata = sd;
+        spin_unlock_irqrestore(&h->devlock, flags);
+        return 0;
+}
+
+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;
+
+        if (!h->cmd_sg_list)
+                return;
+        for (i = 0; i < h->nr_cmds; i++) {
+                kfree(h->cmd_sg_list[i]);
+                h->cmd_sg_list[i] = NULL;
+        }
+        kfree(h->cmd_sg_list);
+        h->cmd_sg_list = NULL;
+}
+
+static int hpsa_allocate_sg_chain_blocks(struct ctlr_info *h)
+{
+        int i;
+
+        if (h->chainsize <= 0)
+                return 0;
+
+        h->cmd_sg_list = kzalloc(sizeof(*h->cmd_sg_list) * h->nr_cmds,
+                                GFP_KERNEL);
+        if (!h->cmd_sg_list)
+                return -ENOMEM;
+        for (i = 0; i < h->nr_cmds; i++) {
+                h->cmd_sg_list[i] = kmalloc(sizeof(*h->cmd_sg_list[i]) *
+                                                h->chainsize, GFP_KERNEL);
+                if (!h->cmd_sg_list[i])
+                        goto clean;
+        }
+        return 0;
+
+clean:
+        hpsa_free_sg_chain_blocks(h);
+        return -ENOMEM;
+}
+
+static void hpsa_map_sg_chain_block(struct ctlr_info *h,
+        struct CommandList *c)
+{
+        struct SGDescriptor *chain_sg, *chain_block;
+        u64 temp64;
+
+        chain_sg = &c->SG[h->max_cmd_sg_entries - 1];
+        chain_block = h->cmd_sg_list[c->cmdindex];
+        chain_sg->Ext = HPSA_SG_CHAIN;
+        chain_sg->Len = sizeof(*chain_sg) *
+                (c->Header.SGTotal - h->max_cmd_sg_entries);
+        temp64 = pci_map_single(h->pdev, chain_block, chain_sg->Len,
+                                PCI_DMA_TODEVICE);
+        chain_sg->Addr.lower = (u32) (temp64 & 0x0FFFFFFFFULL);
+        chain_sg->Addr.upper = (u32) ((temp64 >> 32) & 0x0FFFFFFFFULL);
+}
+
+static void hpsa_unmap_sg_chain_block(struct ctlr_info *h,
+        struct CommandList *c)
+{
+        struct SGDescriptor *chain_sg;
+        union u64bit temp64;
+
+        if (c->Header.SGTotal <= h->max_cmd_sg_entries)
+                return;
+
+        chain_sg = &c->SG[h->max_cmd_sg_entries - 1];
+        temp64.val32.lower = chain_sg->Addr.lower;
+        temp64.val32.upper = chain_sg->Addr.upper;
+        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)
+{
+        struct scsi_cmnd *cmd;
+        struct ctlr_info *h;
+        struct ErrorInfo *ei;
+
+        unsigned char sense_key;
+        unsigned char asc;      /* additional sense code */
+        unsigned char ascq;     /* additional sense code qualifier */
+
+        ei = cp->err_info;
+        cmd = (struct scsi_cmnd *) cp->scsi_cmd;
+        h = cp->h;
+
+        scsi_dma_unmap(cmd); /* undo the DMA mappings */
+        if (cp->Header.SGTotal > h->max_cmd_sg_entries)
+                hpsa_unmap_sg_chain_block(h, cp);
+
+        cmd->result = (DID_OK << 16);           /* host byte */
+        cmd->result |= (COMMAND_COMPLETE << 8); /* msg byte */
+        cmd->result |= ei->ScsiStatus;
+
+        /* copy the sense data whether we need to or not. */
+        memcpy(cmd->sense_buffer, ei->SenseInfo,
+                ei->SenseLen > SCSI_SENSE_BUFFERSIZE ?
+                        SCSI_SENSE_BUFFERSIZE :
+                        ei->SenseLen);
+        scsi_set_resid(cmd, ei->ResidualCnt);
+
+        if (ei->CommandStatus == 0) {
+                cmd->scsi_done(cmd);
+                cmd_free(h, cp);
+                return;
+        }
+
+        /* an error has occurred */
+        switch (ei->CommandStatus) {
+
+        case CMD_TARGET_STATUS:
+                if (ei->ScsiStatus) {
+                        /* Get sense key */
+                        sense_key = 0xf & ei->SenseInfo[2];
+                        /* Get additional sense code */
+                        asc = ei->SenseInfo[12];
+                        /* Get addition sense code qualifier */
+                        ascq = ei->SenseInfo[13];
+                }
+
+                if (ei->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
+                        if (check_for_unit_attention(h, cp)) {
+                                cmd->result = DID_SOFT_ERROR << 16;
+                                break;
+                        }
+                        if (sense_key == ILLEGAL_REQUEST) {
+                                /*
+                                 * SCSI REPORT_LUNS is commonly unsupported on
+                                 * Smart Array.  Suppress noisy complaint.
+                                 */
+                                if (cp->Request.CDB[0] == REPORT_LUNS)
+                                        break;
+
+                                /* If ASC/ASCQ indicate Logical Unit
+                                 * Not Supported condition,
+                                 */
+                                if ((asc == 0x25) && (ascq == 0x0)) {
+                                        dev_warn(&h->pdev->dev, "cp %p "
+                                                "has check condition\n", cp);
+                                        break;
+                                }
+                        }
+
+                        if (sense_key == NOT_READY) {
+                                /* If Sense is Not Ready, Logical Unit
+                                 * Not ready, Manual Intervention
+                                 * required
+                                 */
+                                if ((asc == 0x04) && (ascq == 0x03)) {
+                                        dev_warn(&h->pdev->dev, "cp %p "
+                                                "has check condition: unit "
+                                                "not ready, manual "
+                                                "intervention required\n", cp);
+                                        break;
+                                }
+                        }
+                        if (sense_key == ABORTED_COMMAND) {
+                                /* Aborted command is retryable */
+                                dev_warn(&h->pdev->dev, "cp %p "
+                                        "has check condition: aborted command: "
+                                        "ASC: 0x%x, ASCQ: 0x%x\n",
+                                        cp, asc, ascq);
+                                cmd->result = DID_SOFT_ERROR << 16;
+                                break;
+                        }
+                        /* Must be some other type of check condition */
+                        dev_warn(&h->pdev->dev, "cp %p has check condition: "
+                                        "unknown type: "
+                                        "Sense: 0x%x, ASC: 0x%x, ASCQ: 0x%x, "
+                                        "Returning result: 0x%x, "
+                                        "cmd=[%02x %02x %02x %02x %02x "
+                                        "%02x %02x %02x %02x %02x %02x "
+                                        "%02x %02x %02x %02x %02x]\n",
+                                        cp, sense_key, asc, ascq,
+                                        cmd->result,
+                                        cmd->cmnd[0], cmd->cmnd[1],
+                                        cmd->cmnd[2], cmd->cmnd[3],
+                                        cmd->cmnd[4], cmd->cmnd[5],
+                                        cmd->cmnd[6], cmd->cmnd[7],
+                                        cmd->cmnd[8], cmd->cmnd[9],
+                                        cmd->cmnd[10], cmd->cmnd[11],
+                                        cmd->cmnd[12], cmd->cmnd[13],
+                                        cmd->cmnd[14], cmd->cmnd[15]);
+                        break;
+                }
+
+
+                /* Problem was not a check condition
+                 * Pass it up to the upper layers...
+                 */
+                if (ei->ScsiStatus) {
+                        dev_warn(&h->pdev->dev, "cp %p has status 0x%x "
+                                "Sense: 0x%x, ASC: 0x%x, ASCQ: 0x%x, "
+                                "Returning result: 0x%x\n",
+                                cp, ei->ScsiStatus,
+                                sense_key, asc, ascq,
+                                cmd->result);
+                } else {  /* scsi status is zero??? How??? */
+                        dev_warn(&h->pdev->dev, "cp %p SCSI status was 0. "
+                                "Returning no connection.\n", cp),
+
+                        /* Ordinarily, this case should never happen,
+                         * but there is a bug in some released firmware
+                         * revisions that allows it to happen if, for
+                         * example, a 4100 backplane loses power and
+                         * the tape drive is in it.  We assume that
+                         * it's a fatal error of some kind because we
+                         * can't show that it wasn't. We will make it
+                         * look like selection timeout since that is
+                         * the most common reason for this to occur,
+                         * and it's severe enough.
+                         */
+
+                        cmd->result = DID_NO_CONNECT << 16;
+                }
+                break;
+
+        case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
+                break;
+        case CMD_DATA_OVERRUN:
+                dev_warn(&h->pdev->dev, "cp %p has"
+                        " completed with data overrun "
+                        "reported\n", cp);
+                break;
+        case CMD_INVALID: {
+                /* print_bytes(cp, sizeof(*cp), 1, 0);
+                print_cmd(cp); */
+                /* We get CMD_INVALID if you address a non-existent device
+                 * instead of a selection timeout (no response).  You will
+                 * see this if you yank out a drive, then try to access it.
+                 * This is kind of a shame because it means that any other
+                 * CMD_INVALID (e.g. driver bug) will get interpreted as a
+                 * missing target. */
+                cmd->result = DID_NO_CONNECT << 16;
+        }
+                break;
+        case CMD_PROTOCOL_ERR:
+                dev_warn(&h->pdev->dev, "cp %p has "
+                        "protocol error \n", cp);
+                break;
+        case CMD_HARDWARE_ERR:
+                cmd->result = DID_ERROR << 16;
+                dev_warn(&h->pdev->dev, "cp %p had  hardware error\n", cp);
+                break;
+        case CMD_CONNECTION_LOST:
+                cmd->result = DID_ERROR << 16;
+                dev_warn(&h->pdev->dev, "cp %p had connection lost\n", cp);
+                break;
+        case CMD_ABORTED:
+                cmd->result = DID_ABORT << 16;
+                dev_warn(&h->pdev->dev, "cp %p was aborted with status 0x%x\n",
+                                cp, ei->ScsiStatus);
+                break;
+        case CMD_ABORT_FAILED:
+                cmd->result = DID_ERROR << 16;
+                dev_warn(&h->pdev->dev, "cp %p reports abort failed\n", cp);
+                break;
+        case CMD_UNSOLICITED_ABORT:
+                cmd->result = DID_RESET << 16;
+                dev_warn(&h->pdev->dev, "cp %p aborted do to an unsolicited "
+                        "abort\n", cp);
+                break;
+        case CMD_TIMEOUT:
+                cmd->result = DID_TIME_OUT << 16;
+                dev_warn(&h->pdev->dev, "cp %p timedout\n", cp);
+                break;
+        default:
+                cmd->result = DID_ERROR << 16;
+                dev_warn(&h->pdev->dev, "cp %p returned unknown status %x\n",
+                                cp, ei->CommandStatus);
+        }
+        cmd->scsi_done(cmd);
+        cmd_free(h, cp);
+}
+
+static int hpsa_scsi_detect(struct ctlr_info *h)
+{
+        struct Scsi_Host *sh;
+        int error;
+
+        sh = scsi_host_alloc(&hpsa_driver_template, sizeof(h));
+        if (sh == NULL)
+                goto fail;
+
+        sh->io_port = 0;
+        sh->n_io_port = 0;
+        sh->this_id = -1;
+        sh->max_channel = 3;
+        sh->max_cmd_len = MAX_COMMAND_SIZE;
+        sh->max_lun = HPSA_MAX_LUN;
+        sh->max_id = HPSA_MAX_LUN;
+        sh->can_queue = h->nr_cmds;
+        sh->cmd_per_lun = h->nr_cmds;
+        sh->sg_tablesize = h->maxsgentries;
+        h->scsi_host = sh;
+        sh->hostdata[0] = (unsigned long) h;
+        sh->irq = h->intr[PERF_MODE_INT];
+        sh->unique_id = sh->irq;
+        error = scsi_add_host(sh, &h->pdev->dev);
+        if (error)
+                goto fail_host_put;
+        scsi_scan_host(sh);
+        return 0;
+
+ fail_host_put:
+        dev_err(&h->pdev->dev, "hpsa_scsi_detect: scsi_add_host"
+                " failed for controller %d\n", h->ctlr);
+        scsi_host_put(sh);
+        return error;
+ fail:
+        dev_err(&h->pdev->dev, "hpsa_scsi_detect: scsi_host_alloc"
+                " failed for controller %d\n", h->ctlr);
+        return -ENOMEM;
+}
+
+static void hpsa_pci_unmap(struct pci_dev *pdev,
+        struct CommandList *c, int sg_used, int data_direction)
+{
+        int i;
+        union u64bit addr64;
+
+        for (i = 0; i < sg_used; i++) {
+                addr64.val32.lower = c->SG[i].Addr.lower;
+                addr64.val32.upper = c->SG[i].Addr.upper;
+                pci_unmap_single(pdev, (dma_addr_t) addr64.val, c->SG[i].Len,
+                        data_direction);
+        }
+}
+
+static void hpsa_map_one(struct pci_dev *pdev,
+                struct CommandList *cp,
+                unsigned char *buf,
+                size_t buflen,
+                int data_direction)
+{
+        u64 addr64;
+
+        if (buflen == 0 || data_direction == PCI_DMA_NONE) {
+                cp->Header.SGList = 0;
+                cp->Header.SGTotal = 0;
+                return;
+        }
+
+        addr64 = (u64) pci_map_single(pdev, buf, buflen, data_direction);
+        cp->SG[0].Addr.lower =
+          (u32) (addr64 & (u64) 0x00000000FFFFFFFF);
+        cp->SG[0].Addr.upper =
+          (u32) ((addr64 >> 32) & (u64) 0x00000000FFFFFFFF);
+        cp->SG[0].Len = buflen;
+        cp->Header.SGList = (u8) 1;   /* no. SGs contig in this cmd */
+        cp->Header.SGTotal = (u16) 1; /* total sgs in this cmd list */
+}
+
+static inline void hpsa_scsi_do_simple_cmd_core(struct ctlr_info *h,
+        struct CommandList *c)
+{
+        DECLARE_COMPLETION_ONSTACK(wait);
+
+        c->waiting = &wait;
+        enqueue_cmd_and_start_io(h, c);
+        wait_for_completion(&wait);
+}
+
+static void hpsa_scsi_do_simple_cmd_with_retry(struct ctlr_info *h,
+        struct CommandList *c, int data_direction)
+{
+        int retry_count = 0;
+
+        do {
+                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);
+        hpsa_pci_unmap(h->pdev, c, 1, data_direction);
+}
+
+static void hpsa_scsi_interpret_error(struct CommandList *cp)
+{
+        struct ErrorInfo *ei;
+        struct device *d = &cp->h->pdev->dev;
+
+        ei = cp->err_info;
+        switch (ei->CommandStatus) {
+        case CMD_TARGET_STATUS:
+                dev_warn(d, "cmd %p has completed with errors\n", cp);
+                dev_warn(d, "cmd %p has SCSI Status = %x\n", cp,
+                                ei->ScsiStatus);
+                if (ei->ScsiStatus == 0)
+                        dev_warn(d, "SCSI status is abnormally zero.  "
+                        "(probably indicates selection timeout "
+                        "reported incorrectly due to a known "
+                        "firmware bug, circa July, 2001.)\n");
+                break;
+        case CMD_DATA_UNDERRUN: /* let mid layer handle it. */
+                        dev_info(d, "UNDERRUN\n");
+                break;
+        case CMD_DATA_OVERRUN:
+                dev_warn(d, "cp %p has completed with data overrun\n", cp);
+                break;
+        case CMD_INVALID: {
+                /* controller unfortunately reports SCSI passthru's
+                 * to non-existent targets as invalid commands.
+                 */
+                dev_warn(d, "cp %p is reported invalid (probably means "
+                        "target device no longer present)\n", cp);
+                /* print_bytes((unsigned char *) cp, sizeof(*cp), 1, 0);
+                print_cmd(cp);  */
+                }
+                break;
+        case CMD_PROTOCOL_ERR:
+                dev_warn(d, "cp %p has protocol error \n", cp);
+                break;
+        case CMD_HARDWARE_ERR:
+                /* cmd->result = DID_ERROR << 16; */
+                dev_warn(d, "cp %p had hardware error\n", cp);
+                break;
+        case CMD_CONNECTION_LOST:
+                dev_warn(d, "cp %p had connection lost\n", cp);
+                break;
+        case CMD_ABORTED:
+                dev_warn(d, "cp %p was aborted\n", cp);
+                break;
+        case CMD_ABORT_FAILED:
+                dev_warn(d, "cp %p reports abort failed\n", cp);
+                break;
+        case CMD_UNSOLICITED_ABORT:
+                dev_warn(d, "cp %p aborted due to an unsolicited abort\n", cp);
+                break;
+        case CMD_TIMEOUT:
+                dev_warn(d, "cp %p timed out\n", cp);
+                break;
+        default:
+                dev_warn(d, "cp %p returned unknown status %x\n", cp,
+                                ei->CommandStatus);
+        }
+}
+
+static int hpsa_scsi_do_inquiry(struct ctlr_info *h, unsigned char *scsi3addr,
+                        unsigned char page, unsigned char *buf,
+                        unsigned char bufsize)
+{
+        int rc = IO_OK;
+        struct CommandList *c;
+        struct ErrorInfo *ei;
+
+        c = cmd_special_alloc(h);
+
+        if (c == NULL) {                        /* trouble... */
+                dev_warn(&h->pdev->dev, "cmd_special_alloc returned NULL!\n");
+                return -ENOMEM;
+        }
+
+        fill_cmd(c, HPSA_INQUIRY, h, buf, bufsize, page, scsi3addr, TYPE_CMD);
+        hpsa_scsi_do_simple_cmd_with_retry(h, c, PCI_DMA_FROMDEVICE);
+        ei = c->err_info;
+        if (ei->CommandStatus != 0 && ei->CommandStatus != CMD_DATA_UNDERRUN) {
+                hpsa_scsi_interpret_error(c);
+                rc = -1;
+        }
+        cmd_special_free(h, c);
+        return rc;
+}
+
+static int hpsa_send_reset(struct ctlr_info *h, unsigned char *scsi3addr)
+{
+        int rc = IO_OK;
+        struct CommandList *c;
+        struct ErrorInfo *ei;
+
+        c = cmd_special_alloc(h);
+
+        if (c == NULL) {                        /* trouble... */
+                dev_warn(&h->pdev->dev, "cmd_special_alloc returned NULL!\n");
+                return -ENOMEM;
+        }
+
+        fill_cmd(c, HPSA_DEVICE_RESET_MSG, h, NULL, 0, 0, scsi3addr, TYPE_MSG);
+        hpsa_scsi_do_simple_cmd_core(h, c);
+        /* no unmap needed here because no data xfer. */
+
+        ei = c->err_info;
+        if (ei->CommandStatus != 0) {
+                hpsa_scsi_interpret_error(c);
+                rc = -1;
+        }
+        cmd_special_free(h, c);
+        return rc;
+}
+
+static void hpsa_get_raid_level(struct ctlr_info *h,
+        unsigned char *scsi3addr, unsigned char *raid_level)
+{
+        int rc;
+        unsigned char *buf;
+
+        *raid_level = RAID_UNKNOWN;
+        buf = kzalloc(64, GFP_KERNEL);
+        if (!buf)
+                return;
+        rc = hpsa_scsi_do_inquiry(h, scsi3addr, 0xC1, buf, 64);
+        if (rc == 0)
+                *raid_level = buf[8];
+        if (*raid_level > RAID_UNKNOWN)
+                *raid_level = RAID_UNKNOWN;
+        kfree(buf);
+        return;
+}
+
+/* Get the device id from inquiry page 0x83 */
+static int hpsa_get_device_id(struct ctlr_info *h, unsigned char *scsi3addr,
+        unsigned char *device_id, int buflen)
+{
+        int rc;
+        unsigned char *buf;
+
+        if (buflen > 16)
+                buflen = 16;
+        buf = kzalloc(64, GFP_KERNEL);
+        if (!buf)
+                return -1;
+        rc = hpsa_scsi_do_inquiry(h, scsi3addr, 0x83, buf, 64);
+        if (rc == 0)
+                memcpy(device_id, &buf[8], buflen);
+        kfree(buf);
+        return rc != 0;
+}
+
+static int hpsa_scsi_do_report_luns(struct ctlr_info *h, int logical,
+                struct ReportLUNdata *buf, int bufsize,
+                int extended_response)
+{
+        int rc = IO_OK;
+        struct CommandList *c;
+        unsigned char scsi3addr[8];
+        struct ErrorInfo *ei;
+
+        c = cmd_special_alloc(h);
+        if (c == NULL) {                        /* trouble... */
+                dev_err(&h->pdev->dev, "cmd_special_alloc returned NULL!\n");
+                return -1;
+        }
+        /* address the controller */
+        memset(scsi3addr, 0, sizeof(scsi3addr));
+        fill_cmd(c, logical ? HPSA_REPORT_LOG : HPSA_REPORT_PHYS, h,
+                buf, bufsize, 0, scsi3addr, TYPE_CMD);
+        if (extended_response)
+                c->Request.CDB[1] = extended_response;
+        hpsa_scsi_do_simple_cmd_with_retry(h, c, PCI_DMA_FROMDEVICE);
+        ei = c->err_info;
+        if (ei->CommandStatus != 0 &&
+            ei->CommandStatus != CMD_DATA_UNDERRUN) {
+                hpsa_scsi_interpret_error(c);
+                rc = -1;
+        }
+        cmd_special_free(h, c);
+        return rc;
+}
+
+static inline int hpsa_scsi_do_report_phys_luns(struct ctlr_info *h,
+                struct ReportLUNdata *buf,
+                int bufsize, int extended_response)
+{
+        return hpsa_scsi_do_report_luns(h, 0, buf, bufsize, extended_response);
+}
+
+static inline int hpsa_scsi_do_report_log_luns(struct ctlr_info *h,
+                struct ReportLUNdata *buf, int bufsize)
+{
+        return hpsa_scsi_do_report_luns(h, 1, buf, bufsize, 0);
+}
+
+static inline void hpsa_set_bus_target_lun(struct hpsa_scsi_dev_t *device,
+        int bus, int target, int lun)
+{
+        device->bus = bus;
+        device->target = target;
+        device->lun = lun;
+}
+
+static int hpsa_update_device_info(struct ctlr_info *h,
+        unsigned char scsi3addr[], struct hpsa_scsi_dev_t *this_device)
+{
+#define OBDR_TAPE_INQ_SIZE 49
+        unsigned char *inq_buff;
+
+        inq_buff = kzalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
+        if (!inq_buff)
+                goto bail_out;
+
+        /* Do an inquiry to the device to see what it is. */
+        if (hpsa_scsi_do_inquiry(h, scsi3addr, 0, inq_buff,
+                (unsigned char) OBDR_TAPE_INQ_SIZE) != 0) {
+                /* Inquiry failed (msg printed already) */
+                dev_err(&h->pdev->dev,
+                        "hpsa_update_device_info: inquiry failed\n");
+                goto bail_out;
+        }
+
+        /* As a side effect, record the firmware version number
+         * if we happen to be talking to the RAID controller.
+         */
+        if (is_hba_lunid(scsi3addr))
+                memcpy(h->firm_ver, &inq_buff[32], 4);
+
+        this_device->devtype = (inq_buff[0] & 0x1f);
+        memcpy(this_device->scsi3addr, scsi3addr, 8);
+        memcpy(this_device->vendor, &inq_buff[8],
+                sizeof(this_device->vendor));
+        memcpy(this_device->model, &inq_buff[16],
+                sizeof(this_device->model));
+        memcpy(this_device->revision, &inq_buff[32],
+                sizeof(this_device->revision));
+        memset(this_device->device_id, 0,
+                sizeof(this_device->device_id));
+        hpsa_get_device_id(h, scsi3addr, this_device->device_id,
+                sizeof(this_device->device_id));
+
+        if (this_device->devtype == TYPE_DISK &&
+                is_logical_dev_addr_mode(scsi3addr))
+                hpsa_get_raid_level(h, scsi3addr, &this_device->raid_level);
+        else
+                this_device->raid_level = RAID_UNKNOWN;
+
+        kfree(inq_buff);
+        return 0;
+
+bail_out:
+        kfree(inq_buff);
+        return 1;
+}
+
+static unsigned char *msa2xxx_model[] = {
+        "MSA2012",
+        "MSA2024",
+        "MSA2312",
+        "MSA2324",
+        NULL,
+};
+
+static int is_msa2xxx(struct ctlr_info *h, struct hpsa_scsi_dev_t *device)
+{
+        int i;
+
+        for (i = 0; msa2xxx_model[i]; i++)
+                if (strncmp(device->model, msa2xxx_model[i],
+                        strlen(msa2xxx_model[i])) == 0)
+                        return 1;
+        return 0;
+}
+
+/* Helper function to assign bus, target, lun mapping of devices.
+ * Puts non-msa2xxx logical volumes on bus 0, msa2xxx logical
+ * volumes on bus 1, physical devices on bus 2. and the hba on bus 3.
+ * Logical drive target and lun are assigned at this time, but
+ * physical device lun and target assignment are deferred (assigned
+ * in hpsa_find_target_lun, called by hpsa_scsi_add_entry.)
+ */
+static void figure_bus_target_lun(struct ctlr_info *h,
+        u8 *lunaddrbytes, int *bus, int *target, int *lun,
+        struct hpsa_scsi_dev_t *device)
+{
+        u32 lunid;
+
+        if (is_logical_dev_addr_mode(lunaddrbytes)) {
+                /* logical device */
+                if (unlikely(is_scsi_rev_5(h))) {
+                        /* p1210m, logical drives lun assignments
+                         * match SCSI REPORT LUNS data.
+                         */
+                        lunid = le32_to_cpu(*((__le32 *) lunaddrbytes));
+                        *bus = 0;
+                        *target = 0;
+                        *lun = (lunid & 0x3fff) + 1;
+                } else {
+                        /* not p1210m... */
+                        lunid = le32_to_cpu(*((__le32 *) lunaddrbytes));
+                        if (is_msa2xxx(h, device)) {
+                                /* msa2xxx way, put logicals on bus 1
+                                 * and match target/lun numbers box
+                                 * reports.
+                                 */
+                                *bus = 1;
+                                *target = (lunid >> 16) & 0x3fff;
+                                *lun = lunid & 0x00ff;
+                        } else {
+                                /* Traditional smart array way. */
+                                *bus = 0;
+                                *lun = 0;
+                                *target = lunid & 0x3fff;
+                        }
+                }
+        } else {
+                /* physical device */
+                if (is_hba_lunid(lunaddrbytes))
+                        if (unlikely(is_scsi_rev_5(h))) {
+                                *bus = 0; /* put p1210m ctlr at 0,0,0 */
+                                *target = 0;
+                                *lun = 0;
+                                return;
+                        } else
+                                *bus = 3; /* traditional smartarray */
+                else
+                        *bus = 2; /* physical disk */
+                *target = -1;
+                *lun = -1; /* we will fill these in later. */
+        }
+}
+
+/*
+ * If there is no lun 0 on a target, linux won't find any devices.
+ * For the MSA2xxx boxes, we have to manually detect the enclosure
+ * which is at lun zero, as CCISS_REPORT_PHYSICAL_LUNS doesn't report
+ * it for some reason.  *tmpdevice is the target we're adding,
+ * this_device is a pointer into the current element of currentsd[]
+ * that we're building up in update_scsi_devices(), below.
+ * lunzerobits is a bitmap that tracks which targets already have a
+ * lun 0 assigned.
+ * Returns 1 if an enclosure was added, 0 if not.
+ */
+static int add_msa2xxx_enclosure_device(struct ctlr_info *h,
+        struct hpsa_scsi_dev_t *tmpdevice,
+        struct hpsa_scsi_dev_t *this_device, u8 *lunaddrbytes,
+        int bus, int target, int lun, unsigned long lunzerobits[],
+        int *nmsa2xxx_enclosures)
+{
+        unsigned char scsi3addr[8];
+
+        if (test_bit(target, lunzerobits))
+                return 0; /* There is already a lun 0 on this target. */
+
+        if (!is_logical_dev_addr_mode(lunaddrbytes))
+                return 0; /* It's the logical targets that may lack lun 0. */
+
+        if (!is_msa2xxx(h, tmpdevice))
+                return 0; /* It's only the MSA2xxx that have this problem. */
+
+        if (lun == 0) /* if lun is 0, then obviously we have a lun 0. */
+                return 0;
+
+        if (is_hba_lunid(scsi3addr))
+                return 0; /* Don't add the RAID controller here. */
+
+        if (is_scsi_rev_5(h))
+                return 0; /* p1210m doesn't need to do this. */
+
+#define MAX_MSA2XXX_ENCLOSURES 32
+        if (*nmsa2xxx_enclosures >= MAX_MSA2XXX_ENCLOSURES) {
+                dev_warn(&h->pdev->dev, "Maximum number of MSA2XXX "
+                        "enclosures exceeded.  Check your hardware "
+                        "configuration.");
+                return 0;
+        }
+
+        memset(scsi3addr, 0, 8);
+        scsi3addr[3] = target;
+        if (hpsa_update_device_info(h, scsi3addr, this_device))
+                return 0;
+        (*nmsa2xxx_enclosures)++;
+        hpsa_set_bus_target_lun(this_device, bus, target, 0);
+        set_bit(target, lunzerobits);
+        return 1;
+}
+
+/*
+ * Do CISS_REPORT_PHYS and CISS_REPORT_LOG.  Data is returned in physdev,
+ * logdev.  The number of luns in physdev and logdev are returned in
+ * *nphysicals and *nlogicals, respectively.
+ * Returns 0 on success, -1 otherwise.
+ */
+static int hpsa_gather_lun_info(struct ctlr_info *h,
+        int reportlunsize,
+        struct ReportLUNdata *physdev, u32 *nphysicals,
+        struct ReportLUNdata *logdev, u32 *nlogicals)
+{
+        if (hpsa_scsi_do_report_phys_luns(h, physdev, reportlunsize, 0)) {
+                dev_err(&h->pdev->dev, "report physical LUNs failed.\n");
+                return -1;
+        }
+        *nphysicals = be32_to_cpu(*((__be32 *)physdev->LUNListLength)) / 8;
+        if (*nphysicals > HPSA_MAX_PHYS_LUN) {
+                dev_warn(&h->pdev->dev, "maximum physical LUNs (%d) exceeded."
+                        "  %d LUNs ignored.\n", HPSA_MAX_PHYS_LUN,
+                        *nphysicals - HPSA_MAX_PHYS_LUN);
+                *nphysicals = HPSA_MAX_PHYS_LUN;
+        }
+        if (hpsa_scsi_do_report_log_luns(h, logdev, reportlunsize)) {
+                dev_err(&h->pdev->dev, "report logical LUNs failed.\n");
+                return -1;
+        }
+        *nlogicals = be32_to_cpu(*((__be32 *) logdev->LUNListLength)) / 8;
+        /* Reject Logicals in excess of our max capability. */
+        if (*nlogicals > HPSA_MAX_LUN) {
+                dev_warn(&h->pdev->dev,
+                        "maximum logical LUNs (%d) exceeded.  "
+                        "%d LUNs ignored.\n", HPSA_MAX_LUN,
+                        *nlogicals - HPSA_MAX_LUN);
+                        *nlogicals = HPSA_MAX_LUN;
+        }
+        if (*nlogicals + *nphysicals > HPSA_MAX_PHYS_LUN) {
+                dev_warn(&h->pdev->dev,
+                        "maximum logical + physical LUNs (%d) exceeded. "
+                        "%d LUNs ignored.\n", HPSA_MAX_PHYS_LUN,
+                        *nphysicals + *nlogicals - HPSA_MAX_PHYS_LUN);
+                *nlogicals = HPSA_MAX_PHYS_LUN - *nphysicals;
+        }
+        return 0;
+}
+
+u8 *figure_lunaddrbytes(struct ctlr_info *h, int raid_ctlr_position, int i,
+        int nphysicals, int nlogicals, struct ReportLUNdata *physdev_list,
+        struct ReportLUNdata *logdev_list)
+{
+        /* Helper function, figure out where the LUN ID info is coming from
+         * given index i, lists of physical and logical devices, where in
+         * the list the raid controller is supposed to appear (first or last)
+         */
+
+        int logicals_start = nphysicals + (raid_ctlr_position == 0);
+        int last_device = nphysicals + nlogicals + (raid_ctlr_position == 0);
+
+        if (i == raid_ctlr_position)
+                return RAID_CTLR_LUNID;
+
+        if (i < logicals_start)
+                return &physdev_list->LUN[i - (raid_ctlr_position == 0)][0];
+
+        if (i < last_device)
+                return &logdev_list->LUN[i - nphysicals -
+                        (raid_ctlr_position == 0)][0];
+        BUG();
+        return NULL;
+}
+
+static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
+{
+        /* the idea here is we could get notified
+         * that some devices have changed, so we do a report
+         * physical luns and report logical luns cmd, and adjust
+         * our list of devices accordingly.
+         *
+         * The scsi3addr's of devices won't change so long as the
+         * adapter is not reset.  That means we can rescan and
+         * tell which devices we already know about, vs. new
+         * devices, vs.  disappearing devices.
+         */
+        struct ReportLUNdata *physdev_list = NULL;
+        struct ReportLUNdata *logdev_list = NULL;
+        unsigned char *inq_buff = NULL;
+        u32 nphysicals = 0;
+        u32 nlogicals = 0;
+        u32 ndev_allocated = 0;
+        struct hpsa_scsi_dev_t **currentsd, *this_device, *tmpdevice;
+        int ncurrent = 0;
+        int reportlunsize = sizeof(*physdev_list) + HPSA_MAX_PHYS_LUN * 8;
+        int i, nmsa2xxx_enclosures, ndevs_to_allocate;
+        int bus, target, lun;
+        int raid_ctlr_position;
+        DECLARE_BITMAP(lunzerobits, HPSA_MAX_TARGETS_PER_CTLR);
+
+        currentsd = kzalloc(sizeof(*currentsd) * HPSA_MAX_SCSI_DEVS_PER_HBA,
+                GFP_KERNEL);
+        physdev_list = kzalloc(reportlunsize, GFP_KERNEL);
+        logdev_list = kzalloc(reportlunsize, GFP_KERNEL);
+        inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
+        tmpdevice = kzalloc(sizeof(*tmpdevice), GFP_KERNEL);
+
+        if (!currentsd || !physdev_list || !logdev_list ||
+                !inq_buff || !tmpdevice) {
+                dev_err(&h->pdev->dev, "out of memory\n");
+                goto out;
+        }
+        memset(lunzerobits, 0, sizeof(lunzerobits));
+
+        if (hpsa_gather_lun_info(h, reportlunsize, physdev_list, &nphysicals,
+                        logdev_list, &nlogicals))
+                goto out;
+
+        /* We might see up to 32 MSA2xxx enclosures, actually 8 of them
+         * but each of them 4 times through different paths.  The plus 1
+         * is for the RAID controller.
+         */
+        ndevs_to_allocate = nphysicals + nlogicals + MAX_MSA2XXX_ENCLOSURES + 1;
+
+        /* Allocate the per device structures */
+        for (i = 0; i < ndevs_to_allocate; i++) {
+                currentsd[i] = kzalloc(sizeof(*currentsd[i]), GFP_KERNEL);
+                if (!currentsd[i]) {
+                        dev_warn(&h->pdev->dev, "out of memory at %s:%d\n",
+                                __FILE__, __LINE__);
+                        goto out;
+                }
+                ndev_allocated++;
+        }
+
+        if (unlikely(is_scsi_rev_5(h)))
+                raid_ctlr_position = 0;
+        else
+                raid_ctlr_position = nphysicals + nlogicals;
+
+        /* adjust our table of devices */
+        nmsa2xxx_enclosures = 0;
+        for (i = 0; i < nphysicals + nlogicals + 1; i++) {
+                u8 *lunaddrbytes;
+
+                /* Figure out where the LUN ID info is coming from */
+                lunaddrbytes = figure_lunaddrbytes(h, raid_ctlr_position,
+                        i, nphysicals, nlogicals, physdev_list, logdev_list);
+                /* skip masked physical devices. */
+                if (lunaddrbytes[3] & 0xC0 &&
+                        i < nphysicals + (raid_ctlr_position == 0))
+                        continue;
+
+                /* Get device type, vendor, model, device id */
+                if (hpsa_update_device_info(h, lunaddrbytes, tmpdevice))
+                        continue; /* skip it if we can't talk to it. */
+                figure_bus_target_lun(h, lunaddrbytes, &bus, &target, &lun,
+                        tmpdevice);
+                this_device = currentsd[ncurrent];
+
+                /*
+                 * For the msa2xxx boxes, we have to insert a LUN 0 which
+                 * doesn't show up in CCISS_REPORT_PHYSICAL data, but there
+                 * is nonetheless an enclosure device there.  We have to
+                 * present that otherwise linux won't find anything if
+                 * there is no lun 0.
+                 */
+                if (add_msa2xxx_enclosure_device(h, tmpdevice, this_device,
+                                lunaddrbytes, bus, target, lun, lunzerobits,
+                                &nmsa2xxx_enclosures)) {
+                        ncurrent++;
+                        this_device = currentsd[ncurrent];
+                }
+
+                *this_device = *tmpdevice;
+                hpsa_set_bus_target_lun(this_device, bus, target, lun);
+
+                switch (this_device->devtype) {
+                case TYPE_ROM: {
+                        /* We don't *really* support actual CD-ROM devices,
+                         * just "One Button Disaster Recovery" tape drive
+                         * which temporarily pretends to be a CD-ROM drive.
+                         * So we check that the device is really an OBDR tape
+                         * device by checking for "$DR-10" in bytes 43-48 of
+                         * the inquiry data.
+                         */
+                                char obdr_sig[7];
+#define OBDR_TAPE_SIG "$DR-10"
+                                strncpy(obdr_sig, &inq_buff[43], 6);
+                                obdr_sig[6] = '\0';
+                                if (strncmp(obdr_sig, OBDR_TAPE_SIG, 6) != 0)
+                                        /* Not OBDR device, ignore it. */
+                                        break;
+                        }
+                        ncurrent++;
+                        break;
+                case TYPE_DISK:
+                        if (i < nphysicals)
+                                break;
+                        ncurrent++;
+                        break;
+                case TYPE_TAPE:
+                case TYPE_MEDIUM_CHANGER:
+                        ncurrent++;
+                        break;
+                case TYPE_RAID:
+                        /* Only present the Smartarray HBA as a RAID controller.
+                         * If it's a RAID controller other than the HBA itself
+                         * (an external RAID controller, MSA500 or similar)
+                         * don't present it.
+                         */
+                        if (!is_hba_lunid(lunaddrbytes))
+                                break;
+                        ncurrent++;
+                        break;
+                default:
+                        break;
+                }
+                if (ncurrent >= HPSA_MAX_SCSI_DEVS_PER_HBA)
+                        break;
+        }
+        adjust_hpsa_scsi_table(h, hostno, currentsd, ncurrent);
+out:
+        kfree(tmpdevice);
+        for (i = 0; i < ndev_allocated; i++)
+                kfree(currentsd[i]);
+        kfree(currentsd);
+        kfree(inq_buff);
+        kfree(physdev_list);
+        kfree(logdev_list);
+}
+
+/* hpsa_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
+ * dma mapping  and fills in the scatter gather entries of the
+ * hpsa command, cp.
+ */
+static int hpsa_scatter_gather(struct ctlr_info *h,
+                struct CommandList *cp,
+                struct scsi_cmnd *cmd)
+{
+        unsigned int len;
+        struct scatterlist *sg;
+        u64 addr64;
+        int use_sg, i, sg_index, chained;
+        struct SGDescriptor *curr_sg;
+
+        BUG_ON(scsi_sg_count(cmd) > h->maxsgentries);
+
+        use_sg = scsi_dma_map(cmd);
+        if (use_sg < 0)
+                return use_sg;
+
+        if (!use_sg)
+                goto sglist_finished;
+
+        curr_sg = cp->SG;
+        chained = 0;
+        sg_index = 0;
+        scsi_for_each_sg(cmd, sg, use_sg, i) {
+                if (i == h->max_cmd_sg_entries - 1 &&
+                        use_sg > h->max_cmd_sg_entries) {
+                        chained = 1;
+                        curr_sg = h->cmd_sg_list[cp->cmdindex];
+                        sg_index = 0;
+                }
+                addr64 = (u64) sg_dma_address(sg);
+                len  = sg_dma_len(sg);
+                curr_sg->Addr.lower = (u32) (addr64 & 0x0FFFFFFFFULL);
+                curr_sg->Addr.upper = (u32) ((addr64 >> 32) & 0x0FFFFFFFFULL);
+                curr_sg->Len = len;
+                curr_sg->Ext = 0;  /* we are not chaining */
+                curr_sg++;
+        }
+
+        if (use_sg + chained > h->maxSG)
+                h->maxSG = use_sg + chained;
+
+        if (chained) {
+                cp->Header.SGList = h->max_cmd_sg_entries;
+                cp->Header.SGTotal = (u16) (use_sg + 1);
+                hpsa_map_sg_chain_block(h, cp);
+                return 0;
+        }
+
+sglist_finished:
+
+        cp->Header.SGList = (u8) use_sg;   /* no. SGs contig in this cmd */
+        cp->Header.SGTotal = (u16) use_sg; /* total sgs in this cmd list */
+        return 0;
+}
+
+
+static int hpsa_scsi_queue_command(struct scsi_cmnd *cmd,
+        void (*done)(struct scsi_cmnd *))
+{
+        struct ctlr_info *h;
+        struct hpsa_scsi_dev_t *dev;
+        unsigned char scsi3addr[8];
+        struct CommandList *c;
+        unsigned long flags;
+
+        /* Get the ptr to our adapter structure out of cmd->host. */
+        h = sdev_to_hba(cmd->device);
+        dev = cmd->device->hostdata;
+        if (!dev) {
+                cmd->result = DID_NO_CONNECT << 16;
+                done(cmd);
+                return 0;
+        }
+        memcpy(scsi3addr, dev->scsi3addr, sizeof(scsi3addr));
+
+        /* Need a lock as this is being allocated from the pool */
+        spin_lock_irqsave(&h->lock, flags);
+        c = cmd_alloc(h);
+        spin_unlock_irqrestore(&h->lock, flags);
+        if (c == NULL) {                        /* trouble... */
+                dev_err(&h->pdev->dev, "cmd_alloc returned NULL!\n");
+                return SCSI_MLQUEUE_HOST_BUSY;
+        }
+
+        /* Fill in the command list header */
+
+        cmd->scsi_done = done;    /* save this for use by completion code */
+
+        /* save c in case we have to abort it  */
+        cmd->host_scribble = (unsigned char *) c;
+
+        c->cmd_type = CMD_SCSI;
+        c->scsi_cmd = cmd;
+        c->Header.ReplyQueue = 0;  /* unused in simple mode */
+        memcpy(&c->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
+        c->Header.Tag.lower = (c->cmdindex << DIRECT_LOOKUP_SHIFT);
+        c->Header.Tag.lower |= DIRECT_LOOKUP_BIT;
+
+        /* Fill in the request block... */
+
+        c->Request.Timeout = 0;
+        memset(c->Request.CDB, 0, sizeof(c->Request.CDB));
+        BUG_ON(cmd->cmd_len > sizeof(c->Request.CDB));
+        c->Request.CDBLen = cmd->cmd_len;
+        memcpy(c->Request.CDB, cmd->cmnd, cmd->cmd_len);
+        c->Request.Type.Type = TYPE_CMD;
+        c->Request.Type.Attribute = ATTR_SIMPLE;
+        switch (cmd->sc_data_direction) {
+        case DMA_TO_DEVICE:
+                c->Request.Type.Direction = XFER_WRITE;
+                break;
+        case DMA_FROM_DEVICE:
+                c->Request.Type.Direction = XFER_READ;
+                break;
+        case DMA_NONE:
+                c->Request.Type.Direction = XFER_NONE;
+                break;
+        case DMA_BIDIRECTIONAL:
+                /* This can happen if a buggy application does a scsi passthru
+                 * and sets both inlen and outlen to non-zero. ( see
+                 * ../scsi/scsi_ioctl.c:scsi_ioctl_send_command() )
+                 */
+
+                c->Request.Type.Direction = XFER_RSVD;
+                /* This is technically wrong, and hpsa controllers should
+                 * reject it with CMD_INVALID, which is the most correct
+                 * response, but non-fibre backends appear to let it
+                 * slide by, and give the same results as if this field
+                 * were set correctly.  Either way is acceptable for
+                 * our purposes here.
+                 */
+
+                break;
+
+        default:
+                dev_err(&h->pdev->dev, "unknown data direction: %d\n",
+                        cmd->sc_data_direction);
+                BUG();
+                break;
+        }
+
+        if (hpsa_scatter_gather(h, c, cmd) < 0) { /* Fill SG list */
+                cmd_free(h, c);
+                return SCSI_MLQUEUE_HOST_BUSY;
+        }
+        enqueue_cmd_and_start_io(h, c);
+        /* the cmd'll come back via intr handler in complete_scsi_command()  */
+        return 0;
+}
+
+static void hpsa_scan_start(struct Scsi_Host *sh)
+{
+        struct ctlr_info *h = shost_to_hba(sh);
+        unsigned long flags;
+
+        /* wait until any scan already in progress is finished. */
+        while (1) {
+                spin_lock_irqsave(&h->scan_lock, flags);
+                if (h->scan_finished)
+                        break;
+                spin_unlock_irqrestore(&h->scan_lock, flags);
+                wait_event(h->scan_wait_queue, h->scan_finished);
+                /* Note: We don't need to worry about a race between this
+                 * thread and driver unload because the midlayer will
+                 * have incremented the reference count, so unload won't
+                 * happen if we're in here.
+                 */
+        }
+        h->scan_finished = 0; /* mark scan as in progress */
+        spin_unlock_irqrestore(&h->scan_lock, flags);
+
+        hpsa_update_scsi_devices(h, h->scsi_host->host_no);
+
+        spin_lock_irqsave(&h->scan_lock, flags);
+        h->scan_finished = 1; /* mark scan as finished. */
+        wake_up_all(&h->scan_wait_queue);
+        spin_unlock_irqrestore(&h->scan_lock, flags);
+}
+
+static int hpsa_scan_finished(struct Scsi_Host *sh,
+        unsigned long elapsed_time)
+{
+        struct ctlr_info *h = shost_to_hba(sh);
+        unsigned long flags;
+        int finished;
+
+        spin_lock_irqsave(&h->scan_lock, flags);
+        finished = h->scan_finished;
+        spin_unlock_irqrestore(&h->scan_lock, flags);
+        return finished;
+}
+
+static int hpsa_change_queue_depth(struct scsi_device *sdev,
+        int qdepth, int reason)
+{
+        struct ctlr_info *h = sdev_to_hba(sdev);
+
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -ENOTSUPP;
+
+        if (qdepth < 1)
+                qdepth = 1;
+        else
+                if (qdepth > h->nr_cmds)
+                        qdepth = h->nr_cmds;
+        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+        return sdev->queue_depth;
+}
+
+static void hpsa_unregister_scsi(struct ctlr_info *h)
+{
+        /* we are being forcibly unloaded, and may not refuse. */
+        scsi_remove_host(h->scsi_host);
+        scsi_host_put(h->scsi_host);
+        h->scsi_host = NULL;
+}
+
+static int hpsa_register_scsi(struct ctlr_info *h)
+{
+        int rc;
+
+        rc = hpsa_scsi_detect(h);
+        if (rc != 0)
+                dev_err(&h->pdev->dev, "hpsa_register_scsi: failed"
+                        " hpsa_scsi_detect(), rc is %d\n", rc);
+        return rc;
+}
+
+static int wait_for_device_to_become_ready(struct ctlr_info *h,
+        unsigned char lunaddr[])
+{
+        int rc = 0;
+        int count = 0;
+        int waittime = 1; /* seconds */
+        struct CommandList *c;
+
+        c = cmd_special_alloc(h);
+        if (!c) {
+                dev_warn(&h->pdev->dev, "out of memory in "
+                        "wait_for_device_to_become_ready.\n");
+                return IO_ERROR;
+        }
+
+        /* Send test unit ready until device ready, or give up. */
+        while (count < HPSA_TUR_RETRY_LIMIT) {
+
+                /* Wait for a bit.  do this first, because if we send
+                 * the TUR right away, the reset will just abort it.
+                 */
+                msleep(1000 * waittime);
+                count++;
+
+                /* Increase wait time with each try, up to a point. */
+                if (waittime < HPSA_MAX_WAIT_INTERVAL_SECS)
+                        waittime = waittime * 2;
+
+                /* Send the Test Unit Ready */
+                fill_cmd(c, TEST_UNIT_READY, h, NULL, 0, 0, lunaddr, TYPE_CMD);
+                hpsa_scsi_do_simple_cmd_core(h, c);
+                /* no unmap needed here because no data xfer. */
+
+                if (c->err_info->CommandStatus == CMD_SUCCESS)
+                        break;
+
+                if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
+                        c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION &&
+                        (c->err_info->SenseInfo[2] == NO_SENSE ||
+                        c->err_info->SenseInfo[2] == UNIT_ATTENTION))
+                        break;
+
+                dev_warn(&h->pdev->dev, "waiting %d secs "
+                        "for device to become ready.\n", waittime);
+                rc = 1; /* device not ready. */
+        }
+
+        if (rc)
+                dev_warn(&h->pdev->dev, "giving up on device.\n");
+        else
+                dev_warn(&h->pdev->dev, "device is ready.\n");
+
+        cmd_special_free(h, c);
+        return rc;
+}
+
+/* Need at least one of these error handlers to keep ../scsi/hosts.c from
+ * complaining.  Doing a host- or bus-reset can't do anything good here.
+ */
+static int hpsa_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
+{
+        int rc;
+        struct ctlr_info *h;
+        struct hpsa_scsi_dev_t *dev;
+
+        /* find the controller to which the command to be aborted was sent */
+        h = sdev_to_hba(scsicmd->device);
+        if (h == NULL) /* paranoia */
+                return FAILED;
+        dev = scsicmd->device->hostdata;
+        if (!dev) {
+                dev_err(&h->pdev->dev, "hpsa_eh_device_reset_handler: "
+                        "device lookup failed.\n");
+                return FAILED;
+        }
+        dev_warn(&h->pdev->dev, "resetting device %d:%d:%d:%d\n",
+                h->scsi_host->host_no, dev->bus, dev->target, dev->lun);
+        /* send a reset to the SCSI LUN which the command was sent to */
+        rc = hpsa_send_reset(h, dev->scsi3addr);
+        if (rc == 0 && wait_for_device_to_become_ready(h, dev->scsi3addr) == 0)
+                return SUCCESS;
+
+        dev_warn(&h->pdev->dev, "resetting device failed.\n");
+        return FAILED;
+}
+
+/*
+ * For operations that cannot sleep, a command block is allocated at init,
+ * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
+ * which ones are free or in use.  Lock must be held when calling this.
+ * cmd_free() is the complement.
+ */
+static struct CommandList *cmd_alloc(struct ctlr_info *h)
+{
+        struct CommandList *c;
+        int i;
+        union u64bit temp64;
+        dma_addr_t cmd_dma_handle, err_dma_handle;
+
+        do {
+                i = find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds);
+                if (i == h->nr_cmds)
+                        return NULL;
+        } while (test_and_set_bit
+                 (i & (BITS_PER_LONG - 1),
+                  h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0);
+        c = h->cmd_pool + i;
+        memset(c, 0, sizeof(*c));
+        cmd_dma_handle = h->cmd_pool_dhandle
+            + i * sizeof(*c);
+        c->err_info = h->errinfo_pool + i;
+        memset(c->err_info, 0, sizeof(*c->err_info));
+        err_dma_handle = h->errinfo_pool_dhandle
+            + i * sizeof(*c->err_info);
+        h->nr_allocs++;
+
+        c->cmdindex = i;
+
+        INIT_HLIST_NODE(&c->list);
+        c->busaddr = (u32) cmd_dma_handle;
+        temp64.val = (u64) err_dma_handle;
+        c->ErrDesc.Addr.lower = temp64.val32.lower;
+        c->ErrDesc.Addr.upper = temp64.val32.upper;
+        c->ErrDesc.Len = sizeof(*c->err_info);
+
+        c->h = h;
+        return c;
+}
+
+/* For operations that can wait for kmalloc to possibly sleep,
+ * this routine can be called. Lock need not be held to call
+ * cmd_special_alloc. cmd_special_free() is the complement.
+ */
+static struct CommandList *cmd_special_alloc(struct ctlr_info *h)
+{
+        struct CommandList *c;
+        union u64bit temp64;
+        dma_addr_t cmd_dma_handle, err_dma_handle;
+
+        c = pci_alloc_consistent(h->pdev, sizeof(*c), &cmd_dma_handle);
+        if (c == NULL)
+                return NULL;
+        memset(c, 0, sizeof(*c));
+
+        c->cmdindex = -1;
+
+        c->err_info = pci_alloc_consistent(h->pdev, sizeof(*c->err_info),
+                    &err_dma_handle);
+
+        if (c->err_info == NULL) {
+                pci_free_consistent(h->pdev,
+                        sizeof(*c), c, cmd_dma_handle);
+                return NULL;
+        }
+        memset(c->err_info, 0, sizeof(*c->err_info));
+
+        INIT_HLIST_NODE(&c->list);
+        c->busaddr = (u32) cmd_dma_handle;
+        temp64.val = (u64) err_dma_handle;
+        c->ErrDesc.Addr.lower = temp64.val32.lower;
+        c->ErrDesc.Addr.upper = temp64.val32.upper;
+        c->ErrDesc.Len = sizeof(*c->err_info);
+
+        c->h = h;
+        return c;
+}
+
+static void cmd_free(struct ctlr_info *h, struct CommandList *c)
+{
+        int i;
+
+        i = c - h->cmd_pool;
+        clear_bit(i & (BITS_PER_LONG - 1),
+                  h->cmd_pool_bits + (i / BITS_PER_LONG));
+        h->nr_frees++;
+}
+
+static void cmd_special_free(struct ctlr_info *h, struct CommandList *c)
+{
+        union u64bit temp64;
+
+        temp64.val32.lower = c->ErrDesc.Addr.lower;
+        temp64.val32.upper = c->ErrDesc.Addr.upper;
+        pci_free_consistent(h->pdev, sizeof(*c->err_info),
+                            c->err_info, (dma_addr_t) temp64.val);
+        pci_free_consistent(h->pdev, sizeof(*c),
+                            c, (dma_addr_t) c->busaddr);
+}
+
+#ifdef CONFIG_COMPAT
+
+static int hpsa_ioctl32_passthru(struct scsi_device *dev, int cmd, void *arg)
+{
+        IOCTL32_Command_struct __user *arg32 =
+            (IOCTL32_Command_struct __user *) arg;
+        IOCTL_Command_struct arg64;
+        IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
+        int err;
+        u32 cp;
+
+        err = 0;
+        err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
+                           sizeof(arg64.LUN_info));
+        err |= copy_from_user(&arg64.Request, &arg32->Request,
+                           sizeof(arg64.Request));
+        err |= copy_from_user(&arg64.error_info, &arg32->error_info,
+                           sizeof(arg64.error_info));
+        err |= get_user(arg64.buf_size, &arg32->buf_size);
+        err |= get_user(cp, &arg32->buf);
+        arg64.buf = compat_ptr(cp);
+        err |= copy_to_user(p, &arg64, sizeof(arg64));
+
+        if (err)
+                return -EFAULT;
+
+        err = hpsa_ioctl(dev, CCISS_PASSTHRU, (void *)p);
+        if (err)
+                return err;
+        err |= copy_in_user(&arg32->error_info, &p->error_info,
+                         sizeof(arg32->error_info));
+        if (err)
+                return -EFAULT;
+        return err;
+}
+
+static int hpsa_ioctl32_big_passthru(struct scsi_device *dev,
+        int cmd, void *arg)
+{
+        BIG_IOCTL32_Command_struct __user *arg32 =
+            (BIG_IOCTL32_Command_struct __user *) arg;
+        BIG_IOCTL_Command_struct arg64;
+        BIG_IOCTL_Command_struct __user *p =
+            compat_alloc_user_space(sizeof(arg64));
+        int err;
+        u32 cp;
+
+        err = 0;
+        err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
+                           sizeof(arg64.LUN_info));
+        err |= copy_from_user(&arg64.Request, &arg32->Request,
+                           sizeof(arg64.Request));
+        err |= copy_from_user(&arg64.error_info, &arg32->error_info,
+                           sizeof(arg64.error_info));
+        err |= get_user(arg64.buf_size, &arg32->buf_size);
+        err |= get_user(arg64.malloc_size, &arg32->malloc_size);
+        err |= get_user(cp, &arg32->buf);
+        arg64.buf = compat_ptr(cp);
+        err |= copy_to_user(p, &arg64, sizeof(arg64));
+
+        if (err)
+                return -EFAULT;
+
+        err = hpsa_ioctl(dev, CCISS_BIG_PASSTHRU, (void *)p);
+        if (err)
+                return err;
+        err |= copy_in_user(&arg32->error_info, &p->error_info,
+                         sizeof(arg32->error_info));
+        if (err)
+                return -EFAULT;
+        return err;
+}
+
+static int hpsa_compat_ioctl(struct scsi_device *dev, int cmd, void *arg)
+{
+        switch (cmd) {
+        case CCISS_GETPCIINFO:
+        case CCISS_GETINTINFO:
+        case CCISS_SETINTINFO:
+        case CCISS_GETNODENAME:
+        case CCISS_SETNODENAME:
+        case CCISS_GETHEARTBEAT:
+        case CCISS_GETBUSTYPES:
+        case CCISS_GETFIRMVER:
+        case CCISS_GETDRIVVER:
+        case CCISS_REVALIDVOLS:
+        case CCISS_DEREGDISK:
+        case CCISS_REGNEWDISK:
+        case CCISS_REGNEWD:
+        case CCISS_RESCANDISK:
+        case CCISS_GETLUNINFO:
+                return hpsa_ioctl(dev, cmd, arg);
+
+        case CCISS_PASSTHRU32:
+                return hpsa_ioctl32_passthru(dev, cmd, arg);
+        case CCISS_BIG_PASSTHRU32:
+                return hpsa_ioctl32_big_passthru(dev, cmd, arg);
+
+        default:
+                return -ENOIOCTLCMD;
+        }
+}
+#endif
+
+static int hpsa_getpciinfo_ioctl(struct ctlr_info *h, void __user *argp)
+{
+        struct hpsa_pci_info pciinfo;
+
+        if (!argp)
+                return -EINVAL;
+        pciinfo.domain = pci_domain_nr(h->pdev->bus);
+        pciinfo.bus = h->pdev->bus->number;
+        pciinfo.dev_fn = h->pdev->devfn;
+        pciinfo.board_id = h->board_id;
+        if (copy_to_user(argp, &pciinfo, sizeof(pciinfo)))
+                return -EFAULT;
+        return 0;
+}
+
+static int hpsa_getdrivver_ioctl(struct ctlr_info *h, void __user *argp)
+{
+        DriverVer_type DriverVer;
+        unsigned char vmaj, vmin, vsubmin;
+        int rc;
+
+        rc = sscanf(HPSA_DRIVER_VERSION, "%hhu.%hhu.%hhu",
+                &vmaj, &vmin, &vsubmin);
+        if (rc != 3) {
+                dev_info(&h->pdev->dev, "driver version string '%s' "
+                        "unrecognized.", HPSA_DRIVER_VERSION);
+                vmaj = 0;
+                vmin = 0;
+                vsubmin = 0;
+        }
+        DriverVer = (vmaj << 16) | (vmin << 8) | vsubmin;
+        if (!argp)
+                return -EINVAL;
+        if (copy_to_user(argp, &DriverVer, sizeof(DriverVer_type)))
+                return -EFAULT;
+        return 0;
+}
+
+static int hpsa_passthru_ioctl(struct ctlr_info *h, void __user *argp)
+{
+        IOCTL_Command_struct iocommand;
+        struct CommandList *c;
+        char *buff = NULL;
+        union u64bit temp64;
+
+        if (!argp)
+                return -EINVAL;
+        if (!capable(CAP_SYS_RAWIO))
+                return -EPERM;
+        if (copy_from_user(&iocommand, argp, sizeof(iocommand)))
+                return -EFAULT;
+        if ((iocommand.buf_size < 1) &&
+            (iocommand.Request.Type.Direction != XFER_NONE)) {
+                return -EINVAL;
+        }
+        if (iocommand.buf_size > 0) {
+                buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
+                if (buff == NULL)
+                        return -EFAULT;
+        }
+        if (iocommand.Request.Type.Direction == XFER_WRITE) {
+                /* Copy the data into the buffer we created */
+                if (copy_from_user(buff, iocommand.buf, iocommand.buf_size)) {
+                        kfree(buff);
+                        return -EFAULT;
+                }
+        } else
+                memset(buff, 0, iocommand.buf_size);
+        c = cmd_special_alloc(h);
+        if (c == NULL) {
+                kfree(buff);
+                return -ENOMEM;
+        }
+        /* Fill in the command type */
+        c->cmd_type = CMD_IOCTL_PEND;
+        /* Fill in Command Header */
+        c->Header.ReplyQueue = 0; /* unused in simple mode */
+        if (iocommand.buf_size > 0) {   /* buffer to fill */
+                c->Header.SGList = 1;
+                c->Header.SGTotal = 1;
+        } else  { /* no buffers to fill */
+                c->Header.SGList = 0;
+                c->Header.SGTotal = 0;
+        }
+        memcpy(&c->Header.LUN, &iocommand.LUN_info, sizeof(c->Header.LUN));
+        /* use the kernel address the cmd block for tag */
+        c->Header.Tag.lower = c->busaddr;
+
+        /* Fill in Request block */
+        memcpy(&c->Request, &iocommand.Request,
+                sizeof(c->Request));
+
+        /* Fill in the scatter gather information */
+        if (iocommand.buf_size > 0) {
+                temp64.val = pci_map_single(h->pdev, buff,
+                        iocommand.buf_size, PCI_DMA_BIDIRECTIONAL);
+                c->SG[0].Addr.lower = temp64.val32.lower;
+                c->SG[0].Addr.upper = temp64.val32.upper;
+                c->SG[0].Len = iocommand.buf_size;
+                c->SG[0].Ext = 0; /* we are not chaining*/
+        }
+        hpsa_scsi_do_simple_cmd_core(h, c);
+        hpsa_pci_unmap(h->pdev, c, 1, PCI_DMA_BIDIRECTIONAL);
+        check_ioctl_unit_attention(h, c);
+
+        /* Copy the error information out */
+        memcpy(&iocommand.error_info, c->err_info,
+                sizeof(iocommand.error_info));
+        if (copy_to_user(argp, &iocommand, sizeof(iocommand))) {
+                kfree(buff);
+                cmd_special_free(h, c);
+                return -EFAULT;
+        }
+
+        if (iocommand.Request.Type.Direction == XFER_READ) {
+                /* Copy the data out of the buffer we created */
+                if (copy_to_user(iocommand.buf, buff, iocommand.buf_size)) {
+                        kfree(buff);
+                        cmd_special_free(h, c);
+                        return -EFAULT;
+                }
+        }
+        kfree(buff);
+        cmd_special_free(h, c);
+        return 0;
+}
+
+static int hpsa_big_passthru_ioctl(struct ctlr_info *h, void __user *argp)
+{
+        BIG_IOCTL_Command_struct *ioc;
+        struct CommandList *c;
+        unsigned char **buff = NULL;
+        int *buff_size = NULL;
+        union u64bit temp64;
+        BYTE sg_used = 0;
+        int status = 0;
+        int i;
+        u32 left;
+        u32 sz;
+        BYTE __user *data_ptr;
+
+        if (!argp)
+                return -EINVAL;
+        if (!capable(CAP_SYS_RAWIO))
+                return -EPERM;
+        ioc = (BIG_IOCTL_Command_struct *)
+            kmalloc(sizeof(*ioc), GFP_KERNEL);
+        if (!ioc) {
+                status = -ENOMEM;
+                goto cleanup1;
+        }
+        if (copy_from_user(ioc, argp, sizeof(*ioc))) {
+                status = -EFAULT;
+                goto cleanup1;
+        }
+        if ((ioc->buf_size < 1) &&
+            (ioc->Request.Type.Direction != XFER_NONE)) {
+                status = -EINVAL;
+                goto cleanup1;
+        }
+        /* Check kmalloc limits  using all SGs */
+        if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
+                status = -EINVAL;
+                goto cleanup1;
+        }
+        if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
+                status = -EINVAL;
+                goto cleanup1;
+        }
+        buff = kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
+        if (!buff) {
+                status = -ENOMEM;
+                goto cleanup1;
+        }
+        buff_size = kmalloc(MAXSGENTRIES * sizeof(int), GFP_KERNEL);
+        if (!buff_size) {
+                status = -ENOMEM;
+                goto cleanup1;
+        }
+        left = ioc->buf_size;
+        data_ptr = ioc->buf;
+        while (left) {
+                sz = (left > ioc->malloc_size) ? ioc->malloc_size : left;
+                buff_size[sg_used] = sz;
+                buff[sg_used] = kmalloc(sz, GFP_KERNEL);
+                if (buff[sg_used] == NULL) {
+                        status = -ENOMEM;
+                        goto cleanup1;
+                }
+                if (ioc->Request.Type.Direction == XFER_WRITE) {
+                        if (copy_from_user(buff[sg_used], data_ptr, sz)) {
+                                status = -ENOMEM;
+                                goto cleanup1;
+                        }
+                } else
+                        memset(buff[sg_used], 0, sz);
+                left -= sz;
+                data_ptr += sz;
+                sg_used++;
+        }
+        c = cmd_special_alloc(h);
+        if (c == NULL) {
+                status = -ENOMEM;
+                goto cleanup1;
+        }
+        c->cmd_type = CMD_IOCTL_PEND;
+        c->Header.ReplyQueue = 0;
+
+        if (ioc->buf_size > 0) {
+                c->Header.SGList = sg_used;
+                c->Header.SGTotal = sg_used;
+        } else {
+                c->Header.SGList = 0;
+                c->Header.SGTotal = 0;
+        }
+        memcpy(&c->Header.LUN, &ioc->LUN_info, sizeof(c->Header.LUN));
+        c->Header.Tag.lower = c->busaddr;
+        memcpy(&c->Request, &ioc->Request, sizeof(c->Request));
+        if (ioc->buf_size > 0) {
+                int i;
+                for (i = 0; i < sg_used; i++) {
+                        temp64.val = pci_map_single(h->pdev, buff[i],
+                                    buff_size[i], PCI_DMA_BIDIRECTIONAL);
+                        c->SG[i].Addr.lower = temp64.val32.lower;
+                        c->SG[i].Addr.upper = temp64.val32.upper;
+                        c->SG[i].Len = buff_size[i];
+                        /* we are not chaining */
+                        c->SG[i].Ext = 0;
+                }
+        }
+        hpsa_scsi_do_simple_cmd_core(h, c);
+        hpsa_pci_unmap(h->pdev, c, sg_used, PCI_DMA_BIDIRECTIONAL);
+        check_ioctl_unit_attention(h, c);
+        /* Copy the error information out */
+        memcpy(&ioc->error_info, c->err_info, sizeof(ioc->error_info));
+        if (copy_to_user(argp, ioc, sizeof(*ioc))) {
+                cmd_special_free(h, c);
+                status = -EFAULT;
+                goto cleanup1;
+        }
+        if (ioc->Request.Type.Direction == XFER_READ) {
+                /* Copy the data out of the buffer we created */
+                BYTE __user *ptr = ioc->buf;
+                for (i = 0; i < sg_used; i++) {
+                        if (copy_to_user(ptr, buff[i], buff_size[i])) {
+                                cmd_special_free(h, c);
+                                status = -EFAULT;
+                                goto cleanup1;
+                        }
+                        ptr += buff_size[i];
+                }
+        }
+        cmd_special_free(h, c);
+        status = 0;
+cleanup1:
+        if (buff) {
+                for (i = 0; i < sg_used; i++)
+                        kfree(buff[i]);
+                kfree(buff);
+        }
+        kfree(buff_size);
+        kfree(ioc);
+        return status;
+}
+
+static void check_ioctl_unit_attention(struct ctlr_info *h,
+        struct CommandList *c)
+{
+        if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
+                        c->err_info->ScsiStatus != SAM_STAT_CHECK_CONDITION)
+                (void) check_for_unit_attention(h, c);
+}
+/*
+ * ioctl
+ */
+static int hpsa_ioctl(struct scsi_device *dev, int cmd, void *arg)
+{
+        struct ctlr_info *h;
+        void __user *argp = (void __user *)arg;
+
+        h = sdev_to_hba(dev);
+
+        switch (cmd) {
+        case CCISS_DEREGDISK:
+        case CCISS_REGNEWDISK:
+        case CCISS_REGNEWD:
+                hpsa_scan_start(h->scsi_host);
+                return 0;
+        case CCISS_GETPCIINFO:
+                return hpsa_getpciinfo_ioctl(h, argp);
+        case CCISS_GETDRIVVER:
+                return hpsa_getdrivver_ioctl(h, argp);
+        case CCISS_PASSTHRU:
+                return hpsa_passthru_ioctl(h, argp);
+        case CCISS_BIG_PASSTHRU:
+                return hpsa_big_passthru_ioctl(h, argp);
+        default:
+                return -ENOTTY;
+        }
+}
+
+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)
+{
+        int pci_dir = XFER_NONE;
+
+        c->cmd_type = CMD_IOCTL_PEND;
+        c->Header.ReplyQueue = 0;
+        if (buff != NULL && size > 0) {
+                c->Header.SGList = 1;
+                c->Header.SGTotal = 1;
+        } else {
+                c->Header.SGList = 0;
+                c->Header.SGTotal = 0;
+        }
+        c->Header.Tag.lower = c->busaddr;
+        memcpy(c->Header.LUN.LunAddrBytes, scsi3addr, 8);
+
+        c->Request.Type.Type = cmd_type;
+        if (cmd_type == TYPE_CMD) {
+                switch (cmd) {
+                case HPSA_INQUIRY:
+                        /* are we trying to read a vital product page */
+                        if (page_code != 0) {
+                                c->Request.CDB[1] = 0x01;
+                                c->Request.CDB[2] = page_code;
+                        }
+                        c->Request.CDBLen = 6;
+                        c->Request.Type.Attribute = ATTR_SIMPLE;
+                        c->Request.Type.Direction = XFER_READ;
+                        c->Request.Timeout = 0;
+                        c->Request.CDB[0] = HPSA_INQUIRY;
+                        c->Request.CDB[4] = size & 0xFF;
+                        break;
+                case HPSA_REPORT_LOG:
+                case HPSA_REPORT_PHYS:
+                        /* Talking to controller so It's a physical command
+                           mode = 00 target = 0.  Nothing to write.
+                         */
+                        c->Request.CDBLen = 12;
+                        c->Request.Type.Attribute = ATTR_SIMPLE;
+                        c->Request.Type.Direction = XFER_READ;
+                        c->Request.Timeout = 0;
+                        c->Request.CDB[0] = cmd;
+                        c->Request.CDB[6] = (size >> 24) & 0xFF; /* MSB */
+                        c->Request.CDB[7] = (size >> 16) & 0xFF;
+                        c->Request.CDB[8] = (size >> 8) & 0xFF;
+                        c->Request.CDB[9] = size & 0xFF;
+                        break;
+
+                case HPSA_READ_CAPACITY:
+                        c->Request.CDBLen = 10;
+                        c->Request.Type.Attribute = ATTR_SIMPLE;
+                        c->Request.Type.Direction = XFER_READ;
+                        c->Request.Timeout = 0;
+                        c->Request.CDB[0] = cmd;
+                        break;
+                case HPSA_CACHE_FLUSH:
+                        c->Request.CDBLen = 12;
+                        c->Request.Type.Attribute = ATTR_SIMPLE;
+                        c->Request.Type.Direction = XFER_WRITE;
+                        c->Request.Timeout = 0;
+                        c->Request.CDB[0] = BMIC_WRITE;
+                        c->Request.CDB[6] = BMIC_CACHE_FLUSH;
+                        break;
+                case TEST_UNIT_READY:
+                        c->Request.CDBLen = 6;
+                        c->Request.Type.Attribute = ATTR_SIMPLE;
+                        c->Request.Type.Direction = XFER_NONE;
+                        c->Request.Timeout = 0;
+                        break;
+                default:
+                        dev_warn(&h->pdev->dev, "unknown command 0x%c\n", cmd);
+                        BUG();
+                        return;
+                }
+        } else if (cmd_type == TYPE_MSG) {
+                switch (cmd) {
+
+                case  HPSA_DEVICE_RESET_MSG:
+                        c->Request.CDBLen = 16;
+                        c->Request.Type.Type =  1; /* It is a MSG not a CMD */
+                        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 */
+                        c->Request.CDB[1] = 0x03;  /* Reset target above */
+                        /* If bytes 4-7 are zero, it means reset the */
+                        /* LunID device */
+                        c->Request.CDB[4] = 0x00;
+                        c->Request.CDB[5] = 0x00;
+                        c->Request.CDB[6] = 0x00;
+                        c->Request.CDB[7] = 0x00;
+                break;
+
+                default:
+                        dev_warn(&h->pdev->dev, "unknown message type %d\n",
+                                cmd);
+                        BUG();
+                }
+        } else {
+                dev_warn(&h->pdev->dev, "unknown command type %d\n", cmd_type);
+                BUG();
+        }
+
+        switch (c->Request.Type.Direction) {
+        case XFER_READ:
+                pci_dir = PCI_DMA_FROMDEVICE;
+                break;
+        case XFER_WRITE:
+                pci_dir = PCI_DMA_TODEVICE;
+                break;
+        case XFER_NONE:
+                pci_dir = PCI_DMA_NONE;
+                break;
+        default:
+                pci_dir = PCI_DMA_BIDIRECTIONAL;
+        }
+
+        hpsa_map_one(h->pdev, c, buff, size, pci_dir);
+
+        return;
+}
+
+/*
+ * Map (physical) PCI mem into (virtual) kernel space
+ */
+static void __iomem *remap_pci_mem(ulong base, ulong size)
+{
+        ulong page_base = ((ulong) base) & PAGE_MASK;
+        ulong page_offs = ((ulong) base) - page_base;
+        void __iomem *page_remapped = ioremap(page_base, page_offs + size);
+
+        return page_remapped ? (page_remapped + page_offs) : NULL;
+}
+
+/* Takes cmds off the submission queue and sends them to the hardware,
+ * then puts them on the queue of cmds waiting for completion.
+ */
+static void start_io(struct ctlr_info *h)
+{
+        struct CommandList *c;
+
+        while (!hlist_empty(&h->reqQ)) {
+                c = hlist_entry(h->reqQ.first, struct CommandList, list);
+                /* can't do anything if fifo is full */
+                if ((h->access.fifo_full(h))) {
+                        dev_warn(&h->pdev->dev, "fifo full\n");
+                        break;
+                }
+
+                /* Get the first entry from the Request Q */
+                removeQ(c);
+                h->Qdepth--;
+
+                /* Tell the controller execute command */
+                h->access.submit_command(h, c);
+
+                /* Put job onto the completed Q */
+                addQ(&h->cmpQ, c);
+        }
+}
+
+static inline unsigned long get_next_completion(struct ctlr_info *h)
+{
+        return h->access.command_completed(h);
+}
+
+static inline bool interrupt_pending(struct ctlr_info *h)
+{
+        return h->access.intr_pending(h);
+}
+
+static inline long interrupt_not_for_us(struct ctlr_info *h)
+{
+        return !(h->msi_vector || h->msix_vector) &&
+                ((h->access.intr_pending(h) == 0) ||
+                (h->interrupts_enabled == 0));
+}
+
+static inline int bad_tag(struct ctlr_info *h, u32 tag_index,
+        u32 raw_tag)
+{
+        if (unlikely(tag_index >= h->nr_cmds)) {
+                dev_warn(&h->pdev->dev, "bad tag 0x%08x ignored.\n", raw_tag);
+                return 1;
+        }
+        return 0;
+}
+
+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);
+        else if (c->cmd_type == CMD_IOCTL_PEND)
+                complete(c->waiting);
+}
+
+static inline u32 hpsa_tag_contains_index(u32 tag)
+{
+#define DIRECT_LOOKUP_BIT 0x10
+        return tag & DIRECT_LOOKUP_BIT;
+}
+
+static inline u32 hpsa_tag_to_index(u32 tag)
+{
+#define DIRECT_LOOKUP_SHIFT 5
+        return tag >> DIRECT_LOOKUP_SHIFT;
+}
+
+static inline u32 hpsa_tag_discard_error_bits(u32 tag)
+{
+#define HPSA_ERROR_BITS 0x03
+        return tag & ~HPSA_ERROR_BITS;
+}
+
+/* process completion of an indexed ("direct lookup") command */
+static inline u32 process_indexed_cmd(struct ctlr_info *h,
+        u32 raw_tag)
+{
+        u32 tag_index;
+        struct CommandList *c;
+
+        tag_index = hpsa_tag_to_index(raw_tag);
+        if (bad_tag(h, tag_index, raw_tag))
+                return next_command(h);
+        c = h->cmd_pool + tag_index;
+        finish_cmd(c, raw_tag);
+        return next_command(h);
+}
+
+/* process completion of a non-indexed command */
+static inline u32 process_nonindexed_cmd(struct ctlr_info *h,
+        u32 raw_tag)
+{
+        u32 tag;
+        struct CommandList *c = NULL;
+        struct hlist_node *tmp;
+
+        tag = hpsa_tag_discard_error_bits(raw_tag);
+        hlist_for_each_entry(c, tmp, &h->cmpQ, list) {
+                if ((c->busaddr & 0xFFFFFFE0) == (tag & 0xFFFFFFE0)) {
+                        finish_cmd(c, raw_tag);
+                        return next_command(h);
+                }
+        }
+        bad_tag(h, h->nr_cmds + 1, raw_tag);
+        return next_command(h);
+}
+
+static irqreturn_t do_hpsa_intr(int irq, void *dev_id)
+{
+        struct ctlr_info *h = dev_id;
+        unsigned long flags;
+        u32 raw_tag;
+
+        if (interrupt_not_for_us(h))
+                return IRQ_NONE;
+        spin_lock_irqsave(&h->lock, flags);
+        raw_tag = get_next_completion(h);
+        while (raw_tag != FIFO_EMPTY) {
+                if (hpsa_tag_contains_index(raw_tag))
+                        raw_tag = process_indexed_cmd(h, raw_tag);
+                else
+                        raw_tag = process_nonindexed_cmd(h, raw_tag);
+        }
+        spin_unlock_irqrestore(&h->lock, flags);
+        return IRQ_HANDLED;
+}
+
+/* Send a message CDB to the firmware. */
+static __devinit int hpsa_message(struct pci_dev *pdev, unsigned char opcode,
+                                                unsigned char type)
+{
+        struct Command {
+                struct CommandListHeader CommandHeader;
+                struct RequestBlock Request;
+                struct ErrDescriptor ErrorDescriptor;
+        };
+        struct Command *cmd;
+        static const size_t cmd_sz = sizeof(*cmd) +
+                                        sizeof(cmd->ErrorDescriptor);
+        dma_addr_t paddr64;
+        uint32_t paddr32, tag;
+        void __iomem *vaddr;
+        int i, err;
+
+        vaddr = pci_ioremap_bar(pdev, 0);
+        if (vaddr == NULL)
+                return -ENOMEM;
+
+        /* The Inbound Post Queue only accepts 32-bit physical addresses for the
+         * CCISS commands, so they must be allocated from the lower 4GiB of
+         * memory.
+         */
+        err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+        if (err) {
+                iounmap(vaddr);
+                return -ENOMEM;
+        }
+
+        cmd = pci_alloc_consistent(pdev, cmd_sz, &paddr64);
+        if (cmd == NULL) {
+                iounmap(vaddr);
+                return -ENOMEM;
+        }
+
+        /* This must fit, because of the 32-bit consistent DMA mask.  Also,
+         * although there's no guarantee, we assume that the address is at
+         * least 4-byte aligned (most likely, it's page-aligned).
+         */
+        paddr32 = paddr64;
+
+        cmd->CommandHeader.ReplyQueue = 0;
+        cmd->CommandHeader.SGList = 0;
+        cmd->CommandHeader.SGTotal = 0;
+        cmd->CommandHeader.Tag.lower = paddr32;
+        cmd->CommandHeader.Tag.upper = 0;
+        memset(&cmd->CommandHeader.LUN.LunAddrBytes, 0, 8);
+
+        cmd->Request.CDBLen = 16;
+        cmd->Request.Type.Type = TYPE_MSG;
+        cmd->Request.Type.Attribute = ATTR_HEADOFQUEUE;
+        cmd->Request.Type.Direction = XFER_NONE;
+        cmd->Request.Timeout = 0; /* Don't time out */
+        cmd->Request.CDB[0] = opcode;
+        cmd->Request.CDB[1] = type;
+        memset(&cmd->Request.CDB[2], 0, 14); /* rest of the CDB is reserved */
+        cmd->ErrorDescriptor.Addr.lower = paddr32 + sizeof(*cmd);
+        cmd->ErrorDescriptor.Addr.upper = 0;
+        cmd->ErrorDescriptor.Len = sizeof(struct ErrorInfo);
+
+        writel(paddr32, vaddr + SA5_REQUEST_PORT_OFFSET);
+
+        for (i = 0; i < HPSA_MSG_SEND_RETRY_LIMIT; i++) {
+                tag = readl(vaddr + SA5_REPLY_PORT_OFFSET);
+                if (hpsa_tag_discard_error_bits(tag) == paddr32)
+                        break;
+                msleep(HPSA_MSG_SEND_RETRY_INTERVAL_MSECS);
+        }
+
+        iounmap(vaddr);
+
+        /* we leak the DMA buffer here ... no choice since the controller could
+         *  still complete the command.
+         */
+        if (i == HPSA_MSG_SEND_RETRY_LIMIT) {
+                dev_err(&pdev->dev, "controller message %02x:%02x timed out\n",
+                        opcode, type);
+                return -ETIMEDOUT;
+        }
+
+        pci_free_consistent(pdev, cmd_sz, cmd, paddr64);
+
+        if (tag & HPSA_ERROR_BIT) {
+                dev_err(&pdev->dev, "controller message %02x:%02x failed\n",
+                        opcode, type);
+                return -EIO;
+        }
+
+        dev_info(&pdev->dev, "controller message %02x:%02x succeeded\n",
+                opcode, type);
+        return 0;
+}
+
+#define hpsa_soft_reset_controller(p) hpsa_message(p, 1, 0)
+#define hpsa_noop(p) hpsa_message(p, 3, 0)
+
+static __devinit int hpsa_reset_msi(struct pci_dev *pdev)
+{
+/* the #defines are stolen from drivers/pci/msi.h. */
+#define msi_control_reg(base)           (base + PCI_MSI_FLAGS)
+#define PCI_MSIX_FLAGS_ENABLE           (1 << 15)
+
+        int pos;
+        u16 control = 0;
+
+        pos = pci_find_capability(pdev, PCI_CAP_ID_MSI);
+        if (pos) {
+                pci_read_config_word(pdev, msi_control_reg(pos), &control);
+                if (control & PCI_MSI_FLAGS_ENABLE) {
+                        dev_info(&pdev->dev, "resetting MSI\n");
+                        pci_write_config_word(pdev, msi_control_reg(pos),
+                                        control & ~PCI_MSI_FLAGS_ENABLE);
+                }
+        }
+
+        pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
+        if (pos) {
+                pci_read_config_word(pdev, msi_control_reg(pos), &control);
+                if (control & PCI_MSIX_FLAGS_ENABLE) {
+                        dev_info(&pdev->dev, "resetting MSI-X\n");
+                        pci_write_config_word(pdev, msi_control_reg(pos),
+                                        control & ~PCI_MSIX_FLAGS_ENABLE);
+                }
+        }
+
+        return 0;
+}
+
+/* This does a hard reset of the controller using PCI power management
+ * states.
+ */
+static __devinit int hpsa_hard_reset_controller(struct pci_dev *pdev)
+{
+        u16 pmcsr, saved_config_space[32];
+        int i, pos;
+
+        dev_info(&pdev->dev, "using PCI PM to reset controller\n");
+
+        /* This is very nearly the same thing as
+         *
+         * pci_save_state(pci_dev);
+         * pci_set_power_state(pci_dev, PCI_D3hot);
+         * pci_set_power_state(pci_dev, PCI_D0);
+         * pci_restore_state(pci_dev);
+         *
+         * but we can't use these nice canned kernel routines on
+         * kexec, because they also check the MSI/MSI-X state in PCI
+         * configuration space and do the wrong thing when it is
+         * set/cleared.  Also, the pci_save/restore_state functions
+         * violate the ordering requirements for restoring the
+         * configuration space from the CCISS document (see the
+         * comment below).  So we roll our own ....
+         */
+
+        for (i = 0; i < 32; i++)
+                pci_read_config_word(pdev, 2*i, &saved_config_space[i]);
+
+        pos = pci_find_capability(pdev, PCI_CAP_ID_PM);
+        if (pos == 0) {
+                dev_err(&pdev->dev,
+                        "hpsa_reset_controller: PCI PM not supported\n");
+                return -ENODEV;
+        }
+
+        /* Quoting from the Open CISS Specification: "The Power
+         * Management Control/Status Register (CSR) controls the power
+         * state of the device.  The normal operating state is D0,
+         * CSR=00h.  The software off state is D3, CSR=03h.  To reset
+         * the controller, place the interface device in D3 then to
+         * D0, this causes a secondary PCI reset which will reset the
+         * controller."
+         */
+
+        /* enter the D3hot power management state */
+        pci_read_config_word(pdev, pos + PCI_PM_CTRL, &pmcsr);
+        pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
+        pmcsr |= PCI_D3hot;
+        pci_write_config_word(pdev, pos + PCI_PM_CTRL, pmcsr);
+
+        msleep(500);
+
+        /* enter the D0 power management state */
+        pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
+        pmcsr |= PCI_D0;
+        pci_write_config_word(pdev, pos + PCI_PM_CTRL, pmcsr);
+
+        msleep(500);
+
+        /* Restore the PCI configuration space.  The Open CISS
+         * Specification says, "Restore the PCI Configuration
+         * Registers, offsets 00h through 60h. It is important to
+         * restore the command register, 16-bits at offset 04h,
+         * last. Do not restore the configuration status register,
+         * 16-bits at offset 06h."  Note that the offset is 2*i.
+         */
+        for (i = 0; i < 32; i++) {
+                if (i == 2 || i == 3)
+                        continue;
+                pci_write_config_word(pdev, 2*i, saved_config_space[i]);
+        }
+        wmb();
+        pci_write_config_word(pdev, 4, saved_config_space[2]);
+
+        return 0;
+}
+
+/*
+ *  We cannot read the structure directly, for portability we must use
+ *   the io functions.
+ *   This is for debug only.
+ */
+#ifdef HPSA_DEBUG
+static void print_cfg_table(struct device *dev, struct CfgTable *tb)
+{
+        int i;
+        char temp_name[17];
+
+        dev_info(dev, "Controller Configuration information\n");
+        dev_info(dev, "------------------------------------\n");
+        for (i = 0; i < 4; i++)
+                temp_name[i] = readb(&(tb->Signature[i]));
+        temp_name[4] = '\0';
+        dev_info(dev, "   Signature = %s\n", temp_name);
+        dev_info(dev, "   Spec Number = %d\n", readl(&(tb->SpecValence)));
+        dev_info(dev, "   Transport methods supported = 0x%x\n",
+               readl(&(tb->TransportSupport)));
+        dev_info(dev, "   Transport methods active = 0x%x\n",
+               readl(&(tb->TransportActive)));
+        dev_info(dev, "   Requested transport Method = 0x%x\n",
+               readl(&(tb->HostWrite.TransportRequest)));
+        dev_info(dev, "   Coalesce Interrupt Delay = 0x%x\n",
+               readl(&(tb->HostWrite.CoalIntDelay)));
+        dev_info(dev, "   Coalesce Interrupt Count = 0x%x\n",
+               readl(&(tb->HostWrite.CoalIntCount)));
+        dev_info(dev, "   Max outstanding commands = 0x%d\n",
+               readl(&(tb->CmdsOutMax)));
+        dev_info(dev, "   Bus Types = 0x%x\n", readl(&(tb->BusTypes)));
+        for (i = 0; i < 16; i++)
+                temp_name[i] = readb(&(tb->ServerName[i]));
+        temp_name[16] = '\0';
+        dev_info(dev, "   Server Name = %s\n", temp_name);
+        dev_info(dev, "   Heartbeat Counter = 0x%x\n\n\n",
+                readl(&(tb->HeartBeat)));
+}
+#endif                          /* HPSA_DEBUG */
+
+static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
+{
+        int i, offset, mem_type, bar_type;
+
+        if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
+                return 0;
+        offset = 0;
+        for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
+                bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE;
+                if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
+                        offset += 4;
+                else {
+                        mem_type = pci_resource_flags(pdev, i) &
+                            PCI_BASE_ADDRESS_MEM_TYPE_MASK;
+                        switch (mem_type) {
+                        case PCI_BASE_ADDRESS_MEM_TYPE_32:
+                        case PCI_BASE_ADDRESS_MEM_TYPE_1M:
+                                offset += 4;    /* 32 bit */
+                                break;
+                        case PCI_BASE_ADDRESS_MEM_TYPE_64:
+                                offset += 8;
+                                break;
+                        default:        /* reserved in PCI 2.2 */
+                                dev_warn(&pdev->dev,
+                                       "base address is invalid\n");
+                                return -1;
+                                break;
+                        }
+                }
+                if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
+                        return i + 1;
+        }
+        return -1;
+}
+
+/* If MSI/MSI-X is supported by the kernel we will try to enable it on
+ * controllers that are capable. If not, we use IO-APIC mode.
+ */
+
+static void __devinit hpsa_interrupt_mode(struct ctlr_info *h,
+                                           struct pci_dev *pdev, u32 board_id)
+{
+#ifdef CONFIG_PCI_MSI
+        int err;
+        struct msix_entry hpsa_msix_entries[4] = { {0, 0}, {0, 1},
+        {0, 2}, {0, 3}
+        };
+
+        /* Some boards advertise MSI but don't really support it */
+        if ((board_id == 0x40700E11) ||
+            (board_id == 0x40800E11) ||
+            (board_id == 0x40820E11) || (board_id == 0x40830E11))
+                goto default_int_mode;
+        if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
+                dev_info(&pdev->dev, "MSIX\n");
+                err = pci_enable_msix(pdev, hpsa_msix_entries, 4);
+                if (!err) {
+                        h->intr[0] = hpsa_msix_entries[0].vector;
+                        h->intr[1] = hpsa_msix_entries[1].vector;
+                        h->intr[2] = hpsa_msix_entries[2].vector;
+                        h->intr[3] = hpsa_msix_entries[3].vector;
+                        h->msix_vector = 1;
+                        return;
+                }
+                if (err > 0) {
+                        dev_warn(&pdev->dev, "only %d MSI-X vectors "
+                               "available\n", err);
+                        goto default_int_mode;
+                } else {
+                        dev_warn(&pdev->dev, "MSI-X init failed %d\n",
+                               err);
+                        goto default_int_mode;
+                }
+        }
+        if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
+                dev_info(&pdev->dev, "MSI\n");
+                if (!pci_enable_msi(pdev))
+                        h->msi_vector = 1;
+                else
+                        dev_warn(&pdev->dev, "MSI init failed\n");
+        }
+default_int_mode:
+#endif                          /* CONFIG_PCI_MSI */
+        /* if we get here we're going to use the default interrupt mode */
+        h->intr[PERF_MODE_INT] = pdev->irq;
+}
+
+static int __devinit hpsa_pci_init(struct ctlr_info *h, struct pci_dev *pdev)
+{
+        ushort subsystem_vendor_id, subsystem_device_id, command;
+        u32 board_id, scratchpad = 0;
+        u64 cfg_offset;
+        u32 cfg_base_addr;
+        u64 cfg_base_addr_index;
+        u32 trans_offset;
+        int i, prod_index, err;
+
+        subsystem_vendor_id = pdev->subsystem_vendor;
+        subsystem_device_id = pdev->subsystem_device;
+        board_id = (((u32) (subsystem_device_id << 16) & 0xffff0000) |
+                    subsystem_vendor_id);
+
+        for (i = 0; i < ARRAY_SIZE(products); i++)
+                if (board_id == products[i].board_id)
+                        break;
+
+        prod_index = i;
+
+        if (prod_index == ARRAY_SIZE(products)) {
+                prod_index--;
+                if (subsystem_vendor_id != PCI_VENDOR_ID_HP ||
+                                !hpsa_allow_any) {
+                        dev_warn(&pdev->dev, "unrecognized board ID:"
+                                " 0x%08lx, ignoring.\n",
+                                (unsigned long) board_id);
+                        return -ENODEV;
+                }
+        }
+        /* check to see if controller has been disabled
+         * BEFORE trying to enable it
+         */
+        (void)pci_read_config_word(pdev, PCI_COMMAND, &command);
+        if (!(command & 0x02)) {
+                dev_warn(&pdev->dev, "controller appears to be disabled\n");
+                return -ENODEV;
+        }
+
+        err = pci_enable_device(pdev);
+        if (err) {
+                dev_warn(&pdev->dev, "unable to enable PCI device\n");
+                return err;
+        }
+
+        err = pci_request_regions(pdev, "hpsa");
+        if (err) {
+                dev_err(&pdev->dev, "cannot obtain PCI resources, aborting\n");
+                return err;
+        }
+
+        /* If the kernel supports MSI/MSI-X we will try to enable that,
+         * else we use the IO-APIC interrupt assigned to us by system ROM.
+         */
+        hpsa_interrupt_mode(h, pdev, board_id);
+
+        /* find the memory BAR */
+        for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
+                if (pci_resource_flags(pdev, i) & IORESOURCE_MEM)
+                        break;
+        }
+        if (i == DEVICE_COUNT_RESOURCE) {
+                dev_warn(&pdev->dev, "no memory BAR found\n");
+                err = -ENODEV;
+                goto err_out_free_res;
+        }
+
+        h->paddr = pci_resource_start(pdev, i); /* addressing mode bits
+                                                 * already removed
+                                                 */
+
+        h->vaddr = remap_pci_mem(h->paddr, 0x250);
+
+        /* Wait for the board to become ready.  */
+        for (i = 0; i < HPSA_BOARD_READY_ITERATIONS; i++) {
+                scratchpad = readl(h->vaddr + SA5_SCRATCHPAD_OFFSET);
+                if (scratchpad == HPSA_FIRMWARE_READY)
+                        break;
+                msleep(HPSA_BOARD_READY_POLL_INTERVAL_MSECS);
+        }
+        if (scratchpad != HPSA_FIRMWARE_READY) {
+                dev_warn(&pdev->dev, "board not ready, timed out.\n");
+                err = -ENODEV;
+                goto err_out_free_res;
+        }
+
+        /* get the address index number */
+        cfg_base_addr = readl(h->vaddr + SA5_CTCFG_OFFSET);
+        cfg_base_addr &= (u32) 0x0000ffff;
+        cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
+        if (cfg_base_addr_index == -1) {
+                dev_warn(&pdev->dev, "cannot find cfg_base_addr_index\n");
+                err = -ENODEV;
+                goto err_out_free_res;
+        }
+
+        cfg_offset = readl(h->vaddr + SA5_CTMEM_OFFSET);
+        h->cfgtable = remap_pci_mem(pci_resource_start(pdev,
+                               cfg_base_addr_index) + cfg_offset,
+                                sizeof(h->cfgtable));
+        /* Find performant mode table. */
+        trans_offset = readl(&(h->cfgtable->TransMethodOffset));
+        h->transtable = remap_pci_mem(pci_resource_start(pdev,
+                                cfg_base_addr_index)+cfg_offset+trans_offset,
+                                sizeof(*h->transtable));
+
+        h->board_id = board_id;
+        h->max_commands = readl(&(h->cfgtable->MaxPerformantModeCommands));
+        h->maxsgentries = readl(&(h->cfgtable->MaxScatterGatherElements));
+
+        /*
+         * Limit in-command s/g elements to 32 save dma'able memory.
+         * Howvever spec says if 0, use 31
+         */
+
+        h->max_cmd_sg_entries = 31;
+        if (h->maxsgentries > 512) {
+                h->max_cmd_sg_entries = 32;
+                h->chainsize = h->maxsgentries - h->max_cmd_sg_entries + 1;
+                h->maxsgentries--; /* save one for chain pointer */
+        } else {
+                h->maxsgentries = 31; /* default to traditional values */
+                h->chainsize = 0;
+        }
+
+        h->product_name = products[prod_index].product_name;
+        h->access = *(products[prod_index].access);
+        /* Allow room for some ioctls */
+        h->nr_cmds = h->max_commands - 4;
+
+        if ((readb(&h->cfgtable->Signature[0]) != 'C') ||
+            (readb(&h->cfgtable->Signature[1]) != 'I') ||
+            (readb(&h->cfgtable->Signature[2]) != 'S') ||
+            (readb(&h->cfgtable->Signature[3]) != 'S')) {
+                dev_warn(&pdev->dev, "not a valid CISS config table\n");
+                err = -ENODEV;
+                goto err_out_free_res;
+        }
+#ifdef CONFIG_X86
+        {
+                /* Need to enable prefetch in the SCSI core for 6400 in x86 */
+                u32 prefetch;
+                prefetch = readl(&(h->cfgtable->SCSI_Prefetch));
+                prefetch |= 0x100;
+                writel(prefetch, &(h->cfgtable->SCSI_Prefetch));
+        }
+#endif
+
+        /* Disabling DMA prefetch for the P600
+         * An ASIC bug may result in a prefetch beyond
+         * physical memory.
+         */
+        if (board_id == 0x3225103C) {
+                u32 dma_prefetch;
+                dma_prefetch = readl(h->vaddr + I2O_DMA1_CFG);
+                dma_prefetch |= 0x8000;
+                writel(dma_prefetch, h->vaddr + I2O_DMA1_CFG);
+        }
+
+        h->max_commands = readl(&(h->cfgtable->CmdsOutMax));
+        /* Update the field, and then ring the doorbell */
+        writel(CFGTBL_Trans_Simple, &(h->cfgtable->HostWrite.TransportRequest));
+        writel(CFGTBL_ChangeReq, h->vaddr + SA5_DOORBELL);
+
+        /* under certain very rare conditions, this can take awhile.
+         * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
+         * as we enter this code.)
+         */
+        for (i = 0; i < MAX_CONFIG_WAIT; i++) {
+                if (!(readl(h->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
+                        break;
+                /* delay and try again */
+                msleep(10);
+        }
+
+#ifdef HPSA_DEBUG
+        print_cfg_table(&pdev->dev, h->cfgtable);
+#endif                          /* HPSA_DEBUG */
+
+        if (!(readl(&(h->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) {
+                dev_warn(&pdev->dev, "unable to get board into simple mode\n");
+                err = -ENODEV;
+                goto err_out_free_res;
+        }
+        return 0;
+
+err_out_free_res:
+        /*
+         * Deliberately omit pci_disable_device(): it does something nasty to
+         * Smart Array controllers that pci_enable_device does not undo
+         */
+        pci_release_regions(pdev);
+        return err;
+}
+
+static void __devinit hpsa_hba_inquiry(struct ctlr_info *h)
+{
+        int rc;
+
+#define HBA_INQUIRY_BYTE_COUNT 64
+        h->hba_inquiry_data = kmalloc(HBA_INQUIRY_BYTE_COUNT, GFP_KERNEL);
+        if (!h->hba_inquiry_data)
+                return;
+        rc = hpsa_scsi_do_inquiry(h, RAID_CTLR_LUNID, 0,
+                h->hba_inquiry_data, HBA_INQUIRY_BYTE_COUNT);
+        if (rc != 0) {
+                kfree(h->hba_inquiry_data);
+                h->hba_inquiry_data = NULL;
+        }
+}
+
+static int __devinit hpsa_init_one(struct pci_dev *pdev,
+                                    const struct pci_device_id *ent)
+{
+        int i, rc;
+        int dac;
+        struct ctlr_info *h;
+
+        if (number_of_controllers == 0)
+                printk(KERN_INFO DRIVER_NAME "\n");
+        if (reset_devices) {
+                /* Reset the controller with a PCI power-cycle */
+                if (hpsa_hard_reset_controller(pdev) || hpsa_reset_msi(pdev))
+                        return -ENODEV;
+
+                /* Some devices (notably the HP Smart Array 5i Controller)
+                   need a little pause here */
+                msleep(HPSA_POST_RESET_PAUSE_MSECS);
+
+                /* Now try to get the controller to respond to a no-op */
+                for (i = 0; i < HPSA_POST_RESET_NOOP_RETRIES; i++) {
+                        if (hpsa_noop(pdev) == 0)
+                                break;
+                        else
+                                dev_warn(&pdev->dev, "no-op failed%s\n",
+                                                (i < 11 ? "; re-trying" : ""));
+                }
+        }
+
+        /* 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
+         * the driver.  See comments in hpsa.h for more info.
+         */
+#define COMMANDLIST_ALIGNMENT 32
+        BUILD_BUG_ON(sizeof(struct CommandList) % COMMANDLIST_ALIGNMENT);
+        h = kzalloc(sizeof(*h), GFP_KERNEL);
+        if (!h)
+                return -ENOMEM;
+
+        h->busy_initializing = 1;
+        INIT_HLIST_HEAD(&h->cmpQ);
+        INIT_HLIST_HEAD(&h->reqQ);
+        rc = hpsa_pci_init(h, pdev);
+        if (rc != 0)
+                goto clean1;
+
+        sprintf(h->devname, "hpsa%d", number_of_controllers);
+        h->ctlr = number_of_controllers;
+        number_of_controllers++;
+        h->pdev = pdev;
+
+        /* configure PCI DMA stuff */
+        rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
+        if (rc == 0) {
+                dac = 1;
+        } else {
+                rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+                if (rc == 0) {
+                        dac = 0;
+                } else {
+                        dev_err(&pdev->dev, "no suitable DMA available\n");
+                        goto clean1;
+                }
+        }
+
+        /* make sure the board interrupts are off */
+        h->access.set_intr_mask(h, HPSA_INTR_OFF);
+        rc = request_irq(h->intr[PERF_MODE_INT], do_hpsa_intr,
+                        IRQF_DISABLED, h->devname, h);
+        if (rc) {
+                dev_err(&pdev->dev, "unable to get irq %d for %s\n",
+                       h->intr[PERF_MODE_INT], h->devname);
+                goto clean2;
+        }
+
+        dev_info(&pdev->dev, "%s: <0x%x> at IRQ %d%s using DAC\n",
+               h->devname, pdev->device,
+               h->intr[PERF_MODE_INT], 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;
+                goto clean4;
+        }
+        if (hpsa_allocate_sg_chain_blocks(h))
+                goto clean4;
+        spin_lock_init(&h->lock);
+        spin_lock_init(&h->scan_lock);
+        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));
+
+        hpsa_scsi_setup(h);
+
+        /* 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;
+        return 1;
+
+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);
+        free_irq(h->intr[PERF_MODE_INT], h);
+clean2:
+clean1:
+        h->busy_initializing = 0;
+        kfree(h);
+        return rc;
+}
+
+static void hpsa_flush_cache(struct ctlr_info *h)
+{
+        char *flush_buf;
+        struct CommandList *c;
+
+        flush_buf = kzalloc(4, GFP_KERNEL);
+        if (!flush_buf)
+                return;
+
+        c = cmd_special_alloc(h);
+        if (!c) {
+                dev_warn(&h->pdev->dev, "cmd_special_alloc returned NULL!\n");
+                goto out_of_memory;
+        }
+        fill_cmd(c, HPSA_CACHE_FLUSH, h, flush_buf, 4, 0,
+                RAID_CTLR_LUNID, TYPE_CMD);
+        hpsa_scsi_do_simple_cmd_with_retry(h, c, PCI_DMA_TODEVICE);
+        if (c->err_info->CommandStatus != 0)
+                dev_warn(&h->pdev->dev,
+                        "error flushing cache on controller\n");
+        cmd_special_free(h, c);
+out_of_memory:
+        kfree(flush_buf);
+}
+
+static void hpsa_shutdown(struct pci_dev *pdev)
+{
+        struct ctlr_info *h;
+
+        h = pci_get_drvdata(pdev);
+        /* Turn board interrupts off  and send the flush cache command
+         * sendcmd will turn off interrupt, and send the flush...
+         * To write all data in the battery backed cache to disks
+         */
+        hpsa_flush_cache(h);
+        h->access.set_intr_mask(h, HPSA_INTR_OFF);
+        free_irq(h->intr[PERF_MODE_INT], 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 */
+}
+
+static void __devexit hpsa_remove_one(struct pci_dev *pdev)
+{
+        struct ctlr_info *h;
+
+        if (pci_get_drvdata(pdev) == NULL) {
+                dev_err(&pdev->dev, "unable to remove device \n");
+                return;
+        }
+        h = pci_get_drvdata(pdev);
+        hpsa_unregister_scsi(h);        /* unhook from SCSI subsystem */
+        hpsa_shutdown(pdev);
+        iounmap(h->vaddr);
+        hpsa_free_sg_chain_blocks(h);
+        pci_free_consistent(h->pdev,
+                h->nr_cmds * sizeof(struct CommandList),
+                h->cmd_pool, h->cmd_pool_dhandle);
+        pci_free_consistent(h->pdev,
+                h->nr_cmds * sizeof(struct ErrorInfo),
+                h->errinfo_pool, h->errinfo_pool_dhandle);
+        pci_free_consistent(h->pdev, h->reply_pool_size,
+                h->reply_pool, h->reply_pool_dhandle);
+        kfree(h->cmd_pool_bits);
+        kfree(h->blockFetchTable);
+        kfree(h->hba_inquiry_data);
+        /*
+         * Deliberately omit pci_disable_device(): it does something nasty to
+         * Smart Array controllers that pci_enable_device does not undo
+         */
+        pci_release_regions(pdev);
+        pci_set_drvdata(pdev, NULL);
+        kfree(h);
+}
+
+static int hpsa_suspend(__attribute__((unused)) struct pci_dev *pdev,
+        __attribute__((unused)) pm_message_t state)
+{
+        return -ENOSYS;
+}
+
+static int hpsa_resume(__attribute__((unused)) struct pci_dev *pdev)
+{
+        return -ENOSYS;
+}
+
+static struct pci_driver hpsa_pci_driver = {
+        .name = "hpsa",
+        .probe = hpsa_init_one,
+        .remove = __devexit_p(hpsa_remove_one),
+        .id_table = hpsa_pci_device_id, /* id_table */
+        .shutdown = hpsa_shutdown,
+        .suspend = hpsa_suspend,
+        .resume = hpsa_resume,
+};
+
+/* Fill in bucket_map[], given nsgs (the max number of
+ * scatter gather elements supported) and bucket[],
+ * which is an array of 8 integers.  The bucket[] array
+ * contains 8 different DMA transfer sizes (in 16
+ * byte increments) which the controller uses to fetch
+ * commands.  This function fills in bucket_map[], which
+ * maps a given number of scatter gather elements to one of
+ * the 8 DMA transfer sizes.  The point of it is to allow the
+ * controller to only do as much DMA as needed to fetch the
+ * command, with the DMA transfer size encoded in the lower
+ * bits of the command address.
+ */
+static void  calc_bucket_map(int bucket[], int num_buckets,
+        int nsgs, int *bucket_map)
+{
+        int i, j, b, size;
+
+        /* even a command with 0 SGs requires 4 blocks */
+#define MINIMUM_TRANSFER_BLOCKS 4
+#define NUM_BUCKETS 8
+        /* Note, bucket_map must have nsgs+1 entries. */
+        for (i = 0; i <= nsgs; i++) {
+                /* Compute size of a command with i SG entries */
+                size = i + MINIMUM_TRANSFER_BLOCKS;
+                b = num_buckets; /* Assume the biggest bucket */
+                /* Find the bucket that is just big enough */
+                for (j = 0; j < 8; j++) {
+                        if (bucket[j] >= size) {
+                                b = j;
+                                break;
+                        }
+                }
+                /* for a command with i SG entries, use bucket b. */
+                bucket_map[i] = b;
+        }
+}
+
+static void hpsa_put_ctlr_into_performant_mode(struct ctlr_info *h)
+{
+        u32 trans_support;
+        u64 trans_offset;
+        /*  5 = 1 s/g entry or 4k
+         *  6 = 2 s/g entry or 8k
+         *  8 = 4 s/g entry or 16k
+         * 10 = 6 s/g entry or 24k
+         */
+        int bft[8] = {5, 6, 8, 10, 12, 20, 28, 35}; /* for scatter/gathers */
+        int i = 0;
+        int l = 0;
+        unsigned long register_value;
+
+        trans_support = readl(&(h->cfgtable->TransportSupport));
+        if (!(trans_support & PERFORMANT_MODE))
+                return;
+
+        h->max_commands = readl(&(h->cfgtable->MaxPerformantModeCommands));
+        h->max_sg_entries = 32;
+        /* Performant mode ring buffer and supporting data structures */
+        h->reply_pool_size = h->max_commands * sizeof(u64);
+        h->reply_pool = pci_alloc_consistent(h->pdev, h->reply_pool_size,
+                                &(h->reply_pool_dhandle));
+
+        /* Need a block fetch table for performant mode */
+        h->blockFetchTable = kmalloc(((h->max_sg_entries+1) *
+                                sizeof(u32)), GFP_KERNEL);
+
+        if ((h->reply_pool == NULL)
+                || (h->blockFetchTable == NULL))
+                goto clean_up;
+
+        h->reply_pool_wraparound = 1; /* spec: init to 1 */
+
+        /* Controller spec: zero out this buffer. */
+        memset(h->reply_pool, 0, h->reply_pool_size);
+        h->reply_pool_head = h->reply_pool;
+
+        trans_offset = readl(&(h->cfgtable->TransMethodOffset));
+        bft[7] = h->max_sg_entries + 4;
+        calc_bucket_map(bft, ARRAY_SIZE(bft), 32, h->blockFetchTable);
+        for (i = 0; i < 8; i++)
+                writel(bft[i], &h->transtable->BlockFetch[i]);
+
+        /* size of controller ring buffer */
+        writel(h->max_commands, &h->transtable->RepQSize);
+        writel(1, &h->transtable->RepQCount);
+        writel(0, &h->transtable->RepQCtrAddrLow32);
+        writel(0, &h->transtable->RepQCtrAddrHigh32);
+        writel(h->reply_pool_dhandle, &h->transtable->RepQAddr0Low32);
+        writel(0, &h->transtable->RepQAddr0High32);
+        writel(CFGTBL_Trans_Performant,
+                &(h->cfgtable->HostWrite.TransportRequest));
+        writel(CFGTBL_ChangeReq, h->vaddr + SA5_DOORBELL);
+        /* under certain very rare conditions, this can take awhile.
+         * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
+         * as we enter this code.) */
+        for (l = 0; l < MAX_CONFIG_WAIT; l++) {
+                register_value = readl(h->vaddr + SA5_DOORBELL);
+                if (!(register_value & CFGTBL_ChangeReq))
+                        break;
+                /* delay and try again */
+                set_current_state(TASK_INTERRUPTIBLE);
+                schedule_timeout(10);
+        }
+        register_value = readl(&(h->cfgtable->TransportActive));
+        if (!(register_value & CFGTBL_Trans_Performant)) {
+                dev_warn(&h->pdev->dev, "unable to get board into"
+                                        " performant mode\n");
+                return;
+        }
+
+        /* Change the access methods to the performant access methods */
+        h->access = SA5_performant_access;
+        h->transMethod = CFGTBL_Trans_Performant;
+
+        return;
+
+clean_up:
+        if (h->reply_pool)
+                pci_free_consistent(h->pdev, h->reply_pool_size,
+                        h->reply_pool, h->reply_pool_dhandle);
+        kfree(h->blockFetchTable);
+}
+
+/*
+ *  This is it.  Register the PCI driver information for the cards we control
+ *  the OS will call our registered routines when it finds one of our cards.
+ */
+static int __init hpsa_init(void)
+{
+        return pci_register_driver(&hpsa_pci_driver);
+}
+
+static void __exit hpsa_cleanup(void)
+{
+        pci_unregister_driver(&hpsa_pci_driver);
+}
+
+module_init(hpsa_init);
+module_exit(hpsa_cleanup);
diff --git a/drivers/scsi/hpsa.h b/drivers/scsi/hpsa.h
new file mode 100644
index 000000000000..1bb5233b09a0
--- /dev/null
+++ b/drivers/scsi/hpsa.h
@@ -0,0 +1,362 @@
+/*
+ *    Disk Array driver for HP Smart Array SAS controllers
+ *    Copyright 2000, 2009 Hewlett-Packard Development Company, L.P.
+ *
+ *    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; version 2 of the License.
+ *
+ *    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, GOOD TITLE or
+ *    NON INFRINGEMENT.  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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *    Questions/Comments/Bugfixes to iss_storagedev@hp.com
+ *
+ */
+#ifndef HPSA_H
+#define HPSA_H
+
+#include <scsi/scsicam.h>
+
+#define IO_OK           0
+#define IO_ERROR        1
+
+struct ctlr_info;
+
+struct access_method {
+        void (*submit_command)(struct ctlr_info *h,
+                struct CommandList *c);
+        void (*set_intr_mask)(struct ctlr_info *h, unsigned long val);
+        unsigned long (*fifo_full)(struct ctlr_info *h);
+        bool (*intr_pending)(struct ctlr_info *h);
+        unsigned long (*command_completed)(struct ctlr_info *h);
+};
+
+struct hpsa_scsi_dev_t {
+        int devtype;
+        int bus, target, lun;           /* as presented to the OS */
+        unsigned char scsi3addr[8];     /* as presented to the HW */
+#define RAID_CTLR_LUNID "\0\0\0\0\0\0\0\0"
+        unsigned char device_id[16];    /* from inquiry pg. 0x83 */
+        unsigned char vendor[8];        /* bytes 8-15 of inquiry data */
+        unsigned char model[16];        /* bytes 16-31 of inquiry data */
+        unsigned char revision[4];      /* bytes 32-35 of inquiry data */
+        unsigned char raid_level;       /* from inquiry page 0xC1 */
+};
+
+struct ctlr_info {
+        int     ctlr;
+        char    devname[8];
+        char    *product_name;
+        char    firm_ver[4]; /* Firmware version */
+        struct pci_dev *pdev;
+        u32     board_id;
+        void __iomem *vaddr;
+        unsigned long paddr;
+        int     nr_cmds; /* Number of commands allowed on this controller */
+        struct CfgTable __iomem *cfgtable;
+        int     max_sg_entries;
+        int     interrupts_enabled;
+        int     major;
+        int     max_commands;
+        int     commands_outstanding;
+        int     max_outstanding; /* Debug */
+        int     usage_count;  /* number of opens all all minor devices */
+#       define PERF_MODE_INT    0
+#       define DOORBELL_INT     1
+#       define SIMPLE_MODE_INT  2
+#       define MEMQ_MODE_INT    3
+        unsigned int intr[4];
+        unsigned int msix_vector;
+        unsigned int msi_vector;
+        struct access_method access;
+
+        /* queue and queue Info */
+        struct hlist_head reqQ;
+        struct hlist_head cmpQ;
+        unsigned int Qdepth;
+        unsigned int maxQsinceinit;
+        unsigned int maxSG;
+        spinlock_t lock;
+        int maxsgentries;
+        u8 max_cmd_sg_entries;
+        int chainsize;
+        struct SGDescriptor **cmd_sg_list;
+
+        /* pointers to command and error info pool */
+        struct CommandList      *cmd_pool;
+        dma_addr_t              cmd_pool_dhandle;
+        struct ErrorInfo        *errinfo_pool;
+        dma_addr_t              errinfo_pool_dhandle;
+        unsigned long           *cmd_pool_bits;
+        int                     nr_allocs;
+        int                     nr_frees;
+        int                     busy_initializing;
+        int                     busy_scanning;
+        int                     scan_finished;
+        spinlock_t              scan_lock;
+        wait_queue_head_t       scan_wait_queue;
+
+        struct Scsi_Host *scsi_host;
+        spinlock_t devlock; /* to protect hba[ctlr]->dev[];  */
+        int ndevices; /* number of used elements in .dev[] array. */
+#define HPSA_MAX_SCSI_DEVS_PER_HBA 256
+        struct hpsa_scsi_dev_t *dev[HPSA_MAX_SCSI_DEVS_PER_HBA];
+        /*
+         * Performant mode tables.
+         */
+        u32 trans_support;
+        u32 trans_offset;
+        struct TransTable_struct *transtable;
+        unsigned long transMethod;
+
+        /*
+         * Performant mode completion buffer
+         */
+        u64 *reply_pool;
+        dma_addr_t reply_pool_dhandle;
+        u64 *reply_pool_head;
+        size_t reply_pool_size;
+        unsigned char reply_pool_wraparound;
+        u32 *blockFetchTable;
+        unsigned char *hba_inquiry_data;
+};
+#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_MSG_SEND_RETRY_LIMIT 10
+#define HPSA_MSG_SEND_RETRY_INTERVAL_MSECS 1000
+
+/* Maximum time in seconds driver will wait for command completions
+ * when polling before giving up.
+ */
+#define HPSA_MAX_POLL_TIME_SECS (20)
+
+/* During SCSI error recovery, HPSA_TUR_RETRY_LIMIT defines
+ * how many times to retry TEST UNIT READY on a device
+ * while waiting for it to become ready before giving up.
+ * HPSA_MAX_WAIT_INTERVAL_SECS is the max wait interval
+ * between sending TURs while waiting for a device
+ * to become ready.
+ */
+#define HPSA_TUR_RETRY_LIMIT (20)
+#define HPSA_MAX_WAIT_INTERVAL_SECS (30)
+
+/* HPSA_BOARD_READY_WAIT_SECS is how long to wait for a board
+ * to become ready, in seconds, before giving up on it.
+ * HPSA_BOARD_READY_POLL_INTERVAL_MSECS * is how long to wait
+ * between polling the board to see if it is ready, in
+ * milliseconds.  HPSA_BOARD_READY_POLL_INTERVAL and
+ * HPSA_BOARD_READY_ITERATIONS are derived from those.
+ */
+#define HPSA_BOARD_READY_WAIT_SECS (120)
+#define HPSA_BOARD_READY_POLL_INTERVAL_MSECS (100)
+#define HPSA_BOARD_READY_POLL_INTERVAL \
+        ((HPSA_BOARD_READY_POLL_INTERVAL_MSECS * HZ) / 1000)
+#define HPSA_BOARD_READY_ITERATIONS \
+        ((HPSA_BOARD_READY_WAIT_SECS * 1000) / \
+                HPSA_BOARD_READY_POLL_INTERVAL_MSECS)
+#define HPSA_POST_RESET_PAUSE_MSECS (3000)
+#define HPSA_POST_RESET_NOOP_RETRIES (12)
+
+/*  Defining the diffent access_menthods */
+/*
+ * Memory mapped FIFO interface (SMART 53xx cards)
+ */
+#define SA5_DOORBELL    0x20
+#define SA5_REQUEST_PORT_OFFSET 0x40
+#define SA5_REPLY_INTR_MASK_OFFSET      0x34
+#define SA5_REPLY_PORT_OFFSET           0x44
+#define SA5_INTR_STATUS         0x30
+#define SA5_SCRATCHPAD_OFFSET   0xB0
+
+#define SA5_CTCFG_OFFSET        0xB4
+#define SA5_CTMEM_OFFSET        0xB8
+
+#define SA5_INTR_OFF            0x08
+#define SA5B_INTR_OFF           0x04
+#define SA5_INTR_PENDING        0x08
+#define SA5B_INTR_PENDING       0x04
+#define FIFO_EMPTY              0xffffffff
+#define HPSA_FIRMWARE_READY     0xffff0000 /* value in scratchpad register */
+
+#define HPSA_ERROR_BIT          0x02
+
+/* Performant mode flags */
+#define SA5_PERF_INTR_PENDING   0x04
+#define SA5_PERF_INTR_OFF       0x05
+#define SA5_OUTDB_STATUS_PERF_BIT       0x01
+#define SA5_OUTDB_CLEAR_PERF_BIT        0x01
+#define SA5_OUTDB_CLEAR         0xA0
+#define SA5_OUTDB_CLEAR_PERF_BIT        0x01
+#define SA5_OUTDB_STATUS        0x9C
+
+
+#define HPSA_INTR_ON    1
+#define HPSA_INTR_OFF   0
+/*
+        Send the command to the hardware
+*/
+static void SA5_submit_command(struct ctlr_info *h,
+        struct CommandList *c)
+{
+        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);
+        h->commands_outstanding++;
+        if (h->commands_outstanding > h->max_outstanding)
+                h->max_outstanding = h->commands_outstanding;
+}
+
+/*
+ *  This card is the opposite of the other cards.
+ *   0 turns interrupts on...
+ *   0x08 turns them off...
+ */
+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);
+        } else { /* Turn them off */
+                h->interrupts_enabled = 0;
+                writel(SA5_INTR_OFF,
+                        h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
+        }
+}
+
+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);
+        } else {
+                h->interrupts_enabled = 0;
+                writel(SA5_PERF_INTR_OFF,
+                        h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
+        }
+}
+
+static unsigned long SA5_performant_completed(struct ctlr_info *h)
+{
+        unsigned long register_value = FIFO_EMPTY;
+
+        /* flush the controller write of the reply queue by reading
+         * outbound doorbell status register.
+         */
+        register_value = readl(h->vaddr + SA5_OUTDB_STATUS);
+        /* msi auto clears the interrupt pending bit. */
+        if (!(h->msi_vector || h->msix_vector)) {
+                writel(SA5_OUTDB_CLEAR_PERF_BIT, h->vaddr + SA5_OUTDB_CLEAR);
+                /* Do a read in order to flush the write to the controller
+                 * (as per spec.)
+                 */
+                register_value = readl(h->vaddr + SA5_OUTDB_STATUS);
+        }
+
+        if ((*(h->reply_pool_head) & 1) == (h->reply_pool_wraparound)) {
+                register_value = *(h->reply_pool_head);
+                (h->reply_pool_head)++;
+                h->commands_outstanding--;
+        } else {
+                register_value = FIFO_EMPTY;
+        }
+        /* Check for wraparound */
+        if (h->reply_pool_head == (h->reply_pool + h->max_commands)) {
+                h->reply_pool_head = h->reply_pool;
+                h->reply_pool_wraparound ^= 1;
+        }
+
+        return register_value;
+}
+
+/*
+ *  Returns true if fifo is full.
+ *
+ */
+static unsigned long SA5_fifo_full(struct ctlr_info *h)
+{
+        if (h->commands_outstanding >= h->max_commands)
+                return 1;
+        else
+                return 0;
+
+}
+/*
+ *   returns value read from hardware.
+ *     returns FIFO_EMPTY if there is nothing to read
+ */
+static unsigned long SA5_completed(struct ctlr_info *h)
+{
+        unsigned long register_value
+                = readl(h->vaddr + SA5_REPLY_PORT_OFFSET);
+
+        if (register_value != FIFO_EMPTY)
+                h->commands_outstanding--;
+
+#ifdef HPSA_DEBUG
+        if (register_value != FIFO_EMPTY)
+                dev_dbg(&h->pdev->dev, "Read %lx back from board\n",
+                        register_value);
+        else
+                dev_dbg(&h->pdev->dev, "hpsa: FIFO Empty read\n");
+#endif
+
+        return register_value;
+}
+/*
+ *      Returns true if an interrupt is pending..
+ */
+static bool SA5_intr_pending(struct ctlr_info *h)
+{
+        unsigned long register_value  =
+                readl(h->vaddr + SA5_INTR_STATUS);
+        dev_dbg(&h->pdev->dev, "intr_pending %lx\n", register_value);
+        return register_value & SA5_INTR_PENDING;
+}
+
+static bool SA5_performant_intr_pending(struct ctlr_info *h)
+{
+        unsigned long register_value = readl(h->vaddr + SA5_INTR_STATUS);
+
+        if (!register_value)
+                return false;
+
+        if (h->msi_vector || h->msix_vector)
+                return true;
+
+        /* Read outbound doorbell to flush */
+        register_value = readl(h->vaddr + SA5_OUTDB_STATUS);
+        return register_value & SA5_OUTDB_STATUS_PERF_BIT;
+}
+
+static struct access_method SA5_access = {
+        SA5_submit_command,
+        SA5_intr_mask,
+        SA5_fifo_full,
+        SA5_intr_pending,
+        SA5_completed,
+};
+
+static struct access_method SA5_performant_access = {
+        SA5_submit_command,
+        SA5_performant_intr_mask,
+        SA5_fifo_full,
+        SA5_performant_intr_pending,
+        SA5_performant_completed,
+};
+
+struct board_type {
+        u32     board_id;
+        char    *product_name;
+        struct access_method *access;
+};
+
+#endif /* HPSA_H */
+
diff --git a/drivers/scsi/hpsa_cmd.h b/drivers/scsi/hpsa_cmd.h
new file mode 100644
index 000000000000..56fb9827681e
--- /dev/null
+++ b/drivers/scsi/hpsa_cmd.h
@@ -0,0 +1,378 @@
+/*
+ *    Disk Array driver for HP Smart Array SAS controllers
+ *    Copyright 2000, 2009 Hewlett-Packard Development Company, L.P.
+ *
+ *    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; version 2 of the License.
+ *
+ *    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, GOOD TITLE or
+ *    NON INFRINGEMENT.  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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ *    Questions/Comments/Bugfixes to iss_storagedev@hp.com
+ *
+ */
+#ifndef HPSA_CMD_H
+#define HPSA_CMD_H
+
+/* general boundary defintions */
+#define SENSEINFOBYTES          32 /* may vary between hbas */
+#define MAXSGENTRIES            32
+#define HPSA_SG_CHAIN           0x80000000
+#define MAXREPLYQS              256
+
+/* Command Status value */
+#define CMD_SUCCESS             0x0000
+#define CMD_TARGET_STATUS       0x0001
+#define CMD_DATA_UNDERRUN       0x0002
+#define CMD_DATA_OVERRUN        0x0003
+#define CMD_INVALID             0x0004
+#define CMD_PROTOCOL_ERR        0x0005
+#define CMD_HARDWARE_ERR        0x0006
+#define CMD_CONNECTION_LOST     0x0007
+#define CMD_ABORTED             0x0008
+#define CMD_ABORT_FAILED        0x0009
+#define CMD_UNSOLICITED_ABORT   0x000A
+#define CMD_TIMEOUT             0x000B
+#define CMD_UNABORTABLE         0x000C
+
+/* Unit Attentions ASC's as defined for the MSA2012sa */
+#define POWER_OR_RESET                  0x29
+#define STATE_CHANGED                   0x2a
+#define UNIT_ATTENTION_CLEARED          0x2f
+#define LUN_FAILED                      0x3e
+#define REPORT_LUNS_CHANGED             0x3f
+
+/* Unit Attentions ASCQ's as defined for the MSA2012sa */
+
+        /* These ASCQ's defined for ASC = POWER_OR_RESET */
+#define POWER_ON_RESET                  0x00
+#define POWER_ON_REBOOT                 0x01
+#define SCSI_BUS_RESET                  0x02
+#define MSA_TARGET_RESET                0x03
+#define CONTROLLER_FAILOVER             0x04
+#define TRANSCEIVER_SE                  0x05
+#define TRANSCEIVER_LVD                 0x06
+
+        /* These ASCQ's defined for ASC = STATE_CHANGED */
+#define RESERVATION_PREEMPTED           0x03
+#define ASYM_ACCESS_CHANGED             0x06
+#define LUN_CAPACITY_CHANGED            0x09
+
+/* transfer direction */
+#define XFER_NONE               0x00
+#define XFER_WRITE              0x01
+#define XFER_READ               0x02
+#define XFER_RSVD               0x03
+
+/* task attribute */
+#define ATTR_UNTAGGED           0x00
+#define ATTR_SIMPLE             0x04
+#define ATTR_HEADOFQUEUE        0x05
+#define ATTR_ORDERED            0x06
+#define ATTR_ACA                0x07
+
+/* cdb type */
+#define TYPE_CMD                                0x00
+#define TYPE_MSG                                0x01
+
+/* config space register offsets */
+#define CFG_VENDORID            0x00
+#define CFG_DEVICEID            0x02
+#define CFG_I2OBAR              0x10
+#define CFG_MEM1BAR             0x14
+
+/* i2o space register offsets */
+#define I2O_IBDB_SET            0x20
+#define I2O_IBDB_CLEAR          0x70
+#define I2O_INT_STATUS          0x30
+#define I2O_INT_MASK            0x34
+#define I2O_IBPOST_Q            0x40
+#define I2O_OBPOST_Q            0x44
+#define I2O_DMA1_CFG            0x214
+
+/* Configuration Table */
+#define CFGTBL_ChangeReq        0x00000001l
+#define CFGTBL_AccCmds          0x00000001l
+
+#define CFGTBL_Trans_Simple     0x00000002l
+#define CFGTBL_Trans_Performant 0x00000004l
+
+#define CFGTBL_BusType_Ultra2   0x00000001l
+#define CFGTBL_BusType_Ultra3   0x00000002l
+#define CFGTBL_BusType_Fibre1G  0x00000100l
+#define CFGTBL_BusType_Fibre2G  0x00000200l
+struct vals32 {
+        u32   lower;
+        u32   upper;
+};
+
+union u64bit {
+        struct vals32 val32;
+        u64 val;
+};
+
+/* FIXME this is a per controller value (barf!) */
+#define HPSA_MAX_TARGETS_PER_CTLR 16
+#define HPSA_MAX_LUN 256
+#define HPSA_MAX_PHYS_LUN 1024
+
+/* SCSI-3 Commands */
+#pragma pack(1)
+
+#define HPSA_INQUIRY 0x12
+struct InquiryData {
+        u8 data_byte[36];
+};
+
+#define HPSA_REPORT_LOG 0xc2    /* Report Logical LUNs */
+#define HPSA_REPORT_PHYS 0xc3   /* Report Physical LUNs */
+struct ReportLUNdata {
+        u8 LUNListLength[4];
+        u32 reserved;
+        u8 LUN[HPSA_MAX_LUN][8];
+};
+
+struct ReportExtendedLUNdata {
+        u8 LUNListLength[4];
+        u8 extended_response_flag;
+        u8 reserved[3];
+        u8 LUN[HPSA_MAX_LUN][24];
+};
+
+struct SenseSubsystem_info {
+        u8 reserved[36];
+        u8 portname[8];
+        u8 reserved1[1108];
+};
+
+#define HPSA_READ_CAPACITY 0x25 /* Read Capacity */
+struct ReadCapdata {
+        u8 total_size[4];       /* Total size in blocks */
+        u8 block_size[4];       /* Size of blocks in bytes */
+};
+
+#if 0
+/* 12 byte commands not implemented in firmware yet. */
+#define HPSA_READ       0xa8
+#define HPSA_WRITE      0xaa
+#endif
+
+#define HPSA_READ   0x28    /* Read(10) */
+#define HPSA_WRITE  0x2a    /* Write(10) */
+
+/* BMIC commands */
+#define BMIC_READ 0x26
+#define BMIC_WRITE 0x27
+#define BMIC_CACHE_FLUSH 0xc2
+#define HPSA_CACHE_FLUSH 0x01   /* C2 was already being used by HPSA */
+
+/* Command List Structure */
+union SCSI3Addr {
+        struct {
+                u8 Dev;
+                u8 Bus:6;
+                u8 Mode:2;        /* b00 */
+        } PeripDev;
+        struct {
+                u8 DevLSB;
+                u8 DevMSB:6;
+                u8 Mode:2;        /* b01 */
+        } LogDev;
+        struct {
+                u8 Dev:5;
+                u8 Bus:3;
+                u8 Targ:6;
+                u8 Mode:2;        /* b10 */
+        } LogUnit;
+};
+
+struct PhysDevAddr {
+        u32             TargetId:24;
+        u32             Bus:6;
+        u32             Mode:2;
+        /* 2 level target device addr */
+        union SCSI3Addr  Target[2];
+};
+
+struct LogDevAddr {
+        u32            VolId:30;
+        u32            Mode:2;
+        u8             reserved[4];
+};
+
+union LUNAddr {
+        u8               LunAddrBytes[8];
+        union SCSI3Addr    SCSI3Lun[4];
+        struct PhysDevAddr PhysDev;
+        struct LogDevAddr  LogDev;
+};
+
+struct CommandListHeader {
+        u8              ReplyQueue;
+        u8              SGList;
+        u16             SGTotal;
+        struct vals32     Tag;
+        union LUNAddr     LUN;
+};
+
+struct RequestBlock {
+        u8   CDBLen;
+        struct {
+                u8 Type:3;
+                u8 Attribute:3;
+                u8 Direction:2;
+        } Type;
+        u16  Timeout;
+        u8   CDB[16];
+};
+
+struct ErrDescriptor {
+        struct vals32 Addr;
+        u32  Len;
+};
+
+struct SGDescriptor {
+        struct vals32 Addr;
+        u32  Len;
+        u32  Ext;
+};
+
+union MoreErrInfo {
+        struct {
+                u8  Reserved[3];
+                u8  Type;
+                u32 ErrorInfo;
+        } Common_Info;
+        struct {
+                u8  Reserved[2];
+                u8  offense_size; /* size of offending entry */
+                u8  offense_num;  /* byte # of offense 0-base */
+                u32 offense_value;
+        } Invalid_Cmd;
+};
+struct ErrorInfo {
+        u8               ScsiStatus;
+        u8               SenseLen;
+        u16              CommandStatus;
+        u32              ResidualCnt;
+        union MoreErrInfo  MoreErrInfo;
+        u8               SenseInfo[SENSEINFOBYTES];
+};
+/* Command types */
+#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 HPSA_ERROR_BIT          0x02
+struct ctlr_info; /* defined in hpsa.h */
+/* The size of this structure needs to be divisible by 32
+ * on all architectures because low 5 bits of the addresses
+ * are used as follows:
+ *
+ * bit 0: to device, used to indicate "performant mode" command
+ *        from device, indidcates error status.
+ * bit 1-3: to device, indicates block fetch table entry for
+ *          reducing DMA in fetching commands from host memory.
+ * bit 4: used to indicate whether tag is "direct lookup" (index),
+ *        or a bus address.
+ */
+
+struct CommandList {
+        struct CommandListHeader Header;
+        struct RequestBlock      Request;
+        struct ErrDescriptor     ErrDesc;
+        struct SGDescriptor      SG[MAXSGENTRIES];
+        /* information associated with the command */
+        u32                        busaddr; /* physical addr of this record */
+        struct ErrorInfo *err_info; /* pointer to the allocated mem */
+        struct ctlr_info           *h;
+        int                        cmd_type;
+        long                       cmdindex;
+        struct hlist_node list;
+        struct request *rq;
+        struct completion *waiting;
+        void   *scsi_cmd;
+
+/* on 64 bit architectures, to get this to be 32-byte-aligned
+ * it so happens we need PAD_64 bytes of padding, on 32 bit systems,
+ * we need PAD_32 bytes of padding (see below).   This does that.
+ * If it happens that 64 bit and 32 bit systems need different
+ * padding, PAD_32 and PAD_64 can be set independently, and.
+ * the code below will do the right thing.
+ */
+#define IS_32_BIT ((8 - sizeof(long))/4)
+#define IS_64_BIT (!IS_32_BIT)
+#define PAD_32 (4)
+#define PAD_64 (4)
+#define COMMANDLIST_PAD (IS_32_BIT * PAD_32 + IS_64_BIT * PAD_64)
+        u8 pad[COMMANDLIST_PAD];
+};
+
+/* Configuration Table Structure */
+struct HostWrite {
+        u32 TransportRequest;
+        u32 Reserved;
+        u32 CoalIntDelay;
+        u32 CoalIntCount;
+};
+
+#define SIMPLE_MODE     0x02
+#define PERFORMANT_MODE 0x04
+#define MEMQ_MODE       0x08
+
+struct CfgTable {
+        u8            Signature[4];
+        u32             SpecValence;
+        u32           TransportSupport;
+        u32           TransportActive;
+        struct          HostWrite HostWrite;
+        u32           CmdsOutMax;
+        u32           BusTypes;
+        u32           TransMethodOffset;
+        u8            ServerName[16];
+        u32           HeartBeat;
+        u32           SCSI_Prefetch;
+        u32             MaxScatterGatherElements;
+        u32             MaxLogicalUnits;
+        u32             MaxPhysicalDevices;
+        u32             MaxPhysicalDrivesPerLogicalUnit;
+        u32             MaxPerformantModeCommands;
+};
+
+#define NUM_BLOCKFETCH_ENTRIES 8
+struct TransTable_struct {
+        u32            BlockFetch[NUM_BLOCKFETCH_ENTRIES];
+        u32            RepQSize;
+        u32            RepQCount;
+        u32            RepQCtrAddrLow32;
+        u32            RepQCtrAddrHigh32;
+        u32            RepQAddr0Low32;
+        u32            RepQAddr0High32;
+};
+
+struct hpsa_pci_info {
+        unsigned char   bus;
+        unsigned char   dev_fn;
+        unsigned short  domain;
+        u32             board_id;
+};
+
+#pragma pack()
+#endif /* HPSA_CMD_H */
diff --git a/drivers/scsi/hptiop.c b/drivers/scsi/hptiop.c
index a0e7e711ff9d..645f7cdf21ab 100644
--- a/drivers/scsi/hptiop.c
+++ b/drivers/scsi/hptiop.c
@@ -25,6 +25,7 @@
 #include <linux/delay.h>
 #include <linux/timer.h>
 #include <linux/spinlock.h>
+#include <linux/gfp.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/div64.h>
@@ -834,7 +835,7 @@ static int hptiop_reset_hba(struct hptiop_hba *hba)
                         atomic_read(&hba->resetting) == 0, 60 * HZ);
 
         if (atomic_read(&hba->resetting)) {
-                /* IOP is in unkown state, abort reset */
+                /* IOP is in unknown state, abort reset */
                 printk(KERN_ERR "scsi%d: reset failed\n", hba->host->host_no);
                 return -1;
         }
@@ -861,10 +862,13 @@ static int hptiop_reset(struct scsi_cmnd *scp)
 }
 
 static int hptiop_adjust_disk_queue_depth(struct scsi_device *sdev,
-                                                int queue_depth)
+                                          int queue_depth, int reason)
 {
         struct hptiop_hba *hba = (struct hptiop_hba *)sdev->host->hostdata;
 
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
         if (queue_depth > hba->max_requests)
                 queue_depth = hba->max_requests;
         scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
diff --git a/drivers/scsi/ibmmca.c b/drivers/scsi/ibmmca.c
index 9c1e6a5b5af0..9a4b69d4f4eb 100644
--- a/drivers/scsi/ibmmca.c
+++ b/drivers/scsi/ibmmca.c
@@ -2336,7 +2336,7 @@ static int option_setup(char *str)
         char *cur = str;
         int i = 1;
 
-        while (cur && isdigit(*cur) && i <= IM_MAX_HOSTS) {
+        while (cur && isdigit(*cur) && i < IM_MAX_HOSTS) {
                 ints[i++] = simple_strtoul(cur, NULL, 0);
                 if ((cur = strchr(cur, ',')) != NULL)
                         cur++;
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c
index bb2c696c006a..c2eea711a5ce 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.c
+++ b/drivers/scsi/ibmvscsi/ibmvfc.c
@@ -28,7 +28,9 @@
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/kthread.h>
+#include <linux/slab.h>
 #include <linux/of.h>
+#include <linux/pm.h>
 #include <linux/stringify.h>
 #include <asm/firmware.h>
 #include <asm/irq.h>
@@ -39,6 +41,7 @@
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_tcq.h>
 #include <scsi/scsi_transport_fc.h>
+#include <scsi/scsi_bsg_fc.h>
 #include "ibmvfc.h"
 
 static unsigned int init_timeout = IBMVFC_INIT_TIMEOUT;
@@ -558,12 +561,11 @@ static void ibmvfc_link_down(struct ibmvfc_host *vhost,
 /**
  * ibmvfc_init_host - Start host initialization
  * @vhost:              ibmvfc host struct
- * @relogin:    is this a re-login?
  *
  * Return value:
  *      nothing
  **/
-static void ibmvfc_init_host(struct ibmvfc_host *vhost, int relogin)
+static void ibmvfc_init_host(struct ibmvfc_host *vhost)
 {
         struct ibmvfc_target *tgt;
 
@@ -577,10 +579,8 @@ static void ibmvfc_init_host(struct ibmvfc_host *vhost, int relogin)
         }
 
         if (!ibmvfc_set_host_state(vhost, IBMVFC_INITIALIZING)) {
-                if (!relogin) {
-                        memset(vhost->async_crq.msgs, 0, PAGE_SIZE);
-                        vhost->async_crq.cur = 0;
-                }
+                memset(vhost->async_crq.msgs, 0, PAGE_SIZE);
+                vhost->async_crq.cur = 0;
 
                 list_for_each_entry(tgt, &vhost->targets, queue)
                         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
@@ -1678,6 +1678,276 @@ static void ibmvfc_sync_completion(struct ibmvfc_event *evt)
 }
 
 /**
+ * ibmvfc_bsg_timeout_done - Completion handler for cancelling BSG commands
+ * @evt:        struct ibmvfc_event
+ *
+ **/
+static void ibmvfc_bsg_timeout_done(struct ibmvfc_event *evt)
+{
+        struct ibmvfc_host *vhost = evt->vhost;
+
+        ibmvfc_free_event(evt);
+        vhost->aborting_passthru = 0;
+        dev_info(vhost->dev, "Passthru command cancelled\n");
+}
+
+/**
+ * ibmvfc_bsg_timeout - Handle a BSG timeout
+ * @job:        struct fc_bsg_job that timed out
+ *
+ * Returns:
+ *      0 on success / other on failure
+ **/
+static int ibmvfc_bsg_timeout(struct fc_bsg_job *job)
+{
+        struct ibmvfc_host *vhost = shost_priv(job->shost);
+        unsigned long port_id = (unsigned long)job->dd_data;
+        struct ibmvfc_event *evt;
+        struct ibmvfc_tmf *tmf;
+        unsigned long flags;
+        int rc;
+
+        ENTER;
+        spin_lock_irqsave(vhost->host->host_lock, flags);
+        if (vhost->aborting_passthru || vhost->state != IBMVFC_ACTIVE) {
+                __ibmvfc_reset_host(vhost);
+                spin_unlock_irqrestore(vhost->host->host_lock, flags);
+                return 0;
+        }
+
+        vhost->aborting_passthru = 1;
+        evt = ibmvfc_get_event(vhost);
+        ibmvfc_init_event(evt, ibmvfc_bsg_timeout_done, IBMVFC_MAD_FORMAT);
+
+        tmf = &evt->iu.tmf;
+        memset(tmf, 0, sizeof(*tmf));
+        tmf->common.version = 1;
+        tmf->common.opcode = IBMVFC_TMF_MAD;
+        tmf->common.length = sizeof(*tmf);
+        tmf->scsi_id = port_id;
+        tmf->cancel_key = IBMVFC_PASSTHRU_CANCEL_KEY;
+        tmf->my_cancel_key = IBMVFC_INTERNAL_CANCEL_KEY;
+        rc = ibmvfc_send_event(evt, vhost, default_timeout);
+
+        if (rc != 0) {
+                vhost->aborting_passthru = 0;
+                dev_err(vhost->dev, "Failed to send cancel event. rc=%d\n", rc);
+                rc = -EIO;
+        } else
+                dev_info(vhost->dev, "Cancelling passthru command to port id 0x%lx\n",
+                         port_id);
+
+        spin_unlock_irqrestore(vhost->host->host_lock, flags);
+
+        LEAVE;
+        return rc;
+}
+
+/**
+ * ibmvfc_bsg_plogi - PLOGI into a target to handle a BSG command
+ * @vhost:              struct ibmvfc_host to send command
+ * @port_id:    port ID to send command
+ *
+ * Returns:
+ *      0 on success / other on failure
+ **/
+static int ibmvfc_bsg_plogi(struct ibmvfc_host *vhost, unsigned int port_id)
+{
+        struct ibmvfc_port_login *plogi;
+        struct ibmvfc_target *tgt;
+        struct ibmvfc_event *evt;
+        union ibmvfc_iu rsp_iu;
+        unsigned long flags;
+        int rc = 0, issue_login = 1;
+
+        ENTER;
+        spin_lock_irqsave(vhost->host->host_lock, flags);
+        list_for_each_entry(tgt, &vhost->targets, queue) {
+                if (tgt->scsi_id == port_id) {
+                        issue_login = 0;
+                        break;
+                }
+        }
+
+        if (!issue_login)
+                goto unlock_out;
+        if (unlikely((rc = ibmvfc_host_chkready(vhost))))
+                goto unlock_out;
+
+        evt = ibmvfc_get_event(vhost);
+        ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_MAD_FORMAT);
+        plogi = &evt->iu.plogi;
+        memset(plogi, 0, sizeof(*plogi));
+        plogi->common.version = 1;
+        plogi->common.opcode = IBMVFC_PORT_LOGIN;
+        plogi->common.length = sizeof(*plogi);
+        plogi->scsi_id = port_id;
+        evt->sync_iu = &rsp_iu;
+        init_completion(&evt->comp);
+
+        rc = ibmvfc_send_event(evt, vhost, default_timeout);
+        spin_unlock_irqrestore(vhost->host->host_lock, flags);
+
+        if (rc)
+                return -EIO;
+
+        wait_for_completion(&evt->comp);
+
+        if (rsp_iu.plogi.common.status)
+                rc = -EIO;
+
+        spin_lock_irqsave(vhost->host->host_lock, flags);
+        ibmvfc_free_event(evt);
+unlock_out:
+        spin_unlock_irqrestore(vhost->host->host_lock, flags);
+        LEAVE;
+        return rc;
+}
+
+/**
+ * ibmvfc_bsg_request - Handle a BSG request
+ * @job:        struct fc_bsg_job to be executed
+ *
+ * Returns:
+ *      0 on success / other on failure
+ **/
+static int ibmvfc_bsg_request(struct fc_bsg_job *job)
+{
+        struct ibmvfc_host *vhost = shost_priv(job->shost);
+        struct fc_rport *rport = job->rport;
+        struct ibmvfc_passthru_mad *mad;
+        struct ibmvfc_event *evt;
+        union ibmvfc_iu rsp_iu;
+        unsigned long flags, port_id = -1;
+        unsigned int code = job->request->msgcode;
+        int rc = 0, req_seg, rsp_seg, issue_login = 0;
+        u32 fc_flags, rsp_len;
+
+        ENTER;
+        job->reply->reply_payload_rcv_len = 0;
+        if (rport)
+                port_id = rport->port_id;
+
+        switch (code) {
+        case FC_BSG_HST_ELS_NOLOGIN:
+                port_id = (job->request->rqst_data.h_els.port_id[0] << 16) |
+                        (job->request->rqst_data.h_els.port_id[1] << 8) |
+                        job->request->rqst_data.h_els.port_id[2];
+        case FC_BSG_RPT_ELS:
+                fc_flags = IBMVFC_FC_ELS;
+                break;
+        case FC_BSG_HST_CT:
+                issue_login = 1;
+                port_id = (job->request->rqst_data.h_ct.port_id[0] << 16) |
+                        (job->request->rqst_data.h_ct.port_id[1] << 8) |
+                        job->request->rqst_data.h_ct.port_id[2];
+        case FC_BSG_RPT_CT:
+                fc_flags = IBMVFC_FC_CT_IU;
+                break;
+        default:
+                return -ENOTSUPP;
+        };
+
+        if (port_id == -1)
+                return -EINVAL;
+        if (!mutex_trylock(&vhost->passthru_mutex))
+                return -EBUSY;
+
+        job->dd_data = (void *)port_id;
+        req_seg = dma_map_sg(vhost->dev, job->request_payload.sg_list,
+                             job->request_payload.sg_cnt, DMA_TO_DEVICE);
+
+        if (!req_seg) {
+                mutex_unlock(&vhost->passthru_mutex);
+                return -ENOMEM;
+        }
+
+        rsp_seg = dma_map_sg(vhost->dev, job->reply_payload.sg_list,
+                             job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+
+        if (!rsp_seg) {
+                dma_unmap_sg(vhost->dev, job->request_payload.sg_list,
+                             job->request_payload.sg_cnt, DMA_TO_DEVICE);
+                mutex_unlock(&vhost->passthru_mutex);
+                return -ENOMEM;
+        }
+
+        if (req_seg > 1 || rsp_seg > 1) {
+                rc = -EINVAL;
+                goto out;
+        }
+
+        if (issue_login)
+                rc = ibmvfc_bsg_plogi(vhost, port_id);
+
+        spin_lock_irqsave(vhost->host->host_lock, flags);
+
+        if (unlikely(rc || (rport && (rc = fc_remote_port_chkready(rport)))) ||
+            unlikely((rc = ibmvfc_host_chkready(vhost)))) {
+                spin_unlock_irqrestore(vhost->host->host_lock, flags);
+                goto out;
+        }
+
+        evt = ibmvfc_get_event(vhost);
+        ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_MAD_FORMAT);
+        mad = &evt->iu.passthru;
+
+        memset(mad, 0, sizeof(*mad));
+        mad->common.version = 1;
+        mad->common.opcode = IBMVFC_PASSTHRU;
+        mad->common.length = sizeof(*mad) - sizeof(mad->fc_iu) - sizeof(mad->iu);
+
+        mad->cmd_ioba.va = (u64)evt->crq.ioba +
+                offsetof(struct ibmvfc_passthru_mad, iu);
+        mad->cmd_ioba.len = sizeof(mad->iu);
+
+        mad->iu.cmd_len = job->request_payload.payload_len;
+        mad->iu.rsp_len = job->reply_payload.payload_len;
+        mad->iu.flags = fc_flags;
+        mad->iu.cancel_key = IBMVFC_PASSTHRU_CANCEL_KEY;
+
+        mad->iu.cmd.va = sg_dma_address(job->request_payload.sg_list);
+        mad->iu.cmd.len = sg_dma_len(job->request_payload.sg_list);
+        mad->iu.rsp.va = sg_dma_address(job->reply_payload.sg_list);
+        mad->iu.rsp.len = sg_dma_len(job->reply_payload.sg_list);
+        mad->iu.scsi_id = port_id;
+        mad->iu.tag = (u64)evt;
+        rsp_len = mad->iu.rsp.len;
+
+        evt->sync_iu = &rsp_iu;
+        init_completion(&evt->comp);
+        rc = ibmvfc_send_event(evt, vhost, 0);
+        spin_unlock_irqrestore(vhost->host->host_lock, flags);
+
+        if (rc) {
+                rc = -EIO;
+                goto out;
+        }
+
+        wait_for_completion(&evt->comp);
+
+        if (rsp_iu.passthru.common.status)
+                rc = -EIO;
+        else
+                job->reply->reply_payload_rcv_len = rsp_len;
+
+        spin_lock_irqsave(vhost->host->host_lock, flags);
+        ibmvfc_free_event(evt);
+        spin_unlock_irqrestore(vhost->host->host_lock, flags);
+        job->reply->result = rc;
+        job->job_done(job);
+        rc = 0;
+out:
+        dma_unmap_sg(vhost->dev, job->request_payload.sg_list,
+                     job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        dma_unmap_sg(vhost->dev, job->reply_payload.sg_list,
+                     job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        mutex_unlock(&vhost->passthru_mutex);
+        LEAVE;
+        return rc;
+}
+
+/**
  * ibmvfc_reset_device - Reset the device with the specified reset type
  * @sdev:       scsi device to reset
  * @type:       reset type
@@ -1731,7 +2001,10 @@ static int ibmvfc_reset_device(struct scsi_device *sdev, int type, char *desc)
         sdev_printk(KERN_INFO, sdev, "Resetting %s\n", desc);
         wait_for_completion(&evt->comp);
 
-        if (rsp_iu.cmd.status) {
+        if (rsp_iu.cmd.status)
+                rsp_code = ibmvfc_get_err_result(&rsp_iu.cmd);
+
+        if (rsp_code) {
                 if (fc_rsp->flags & FCP_RSP_LEN_VALID)
                         rsp_code = fc_rsp->data.info.rsp_code;
 
@@ -1820,7 +2093,10 @@ static int ibmvfc_abort_task_set(struct scsi_device *sdev)
         sdev_printk(KERN_INFO, sdev, "Aborting outstanding commands\n");
         wait_for_completion(&evt->comp);
 
-        if (rsp_iu.cmd.status) {
+        if (rsp_iu.cmd.status)
+                rsp_code = ibmvfc_get_err_result(&rsp_iu.cmd);
+
+        if (rsp_code) {
                 if (fc_rsp->flags & FCP_RSP_LEN_VALID)
                         rsp_code = fc_rsp->data.info.rsp_code;
 
@@ -2061,12 +2337,24 @@ static int ibmvfc_eh_device_reset_handler(struct scsi_cmnd *cmd)
 }
 
 /**
- * ibmvfc_dev_cancel_all - Device iterated cancel all function
+ * ibmvfc_dev_cancel_all_abts - Device iterated cancel all function
+ * @sdev:       scsi device struct
+ * @data:       return code
+ *
+ **/
+static void ibmvfc_dev_cancel_all_abts(struct scsi_device *sdev, void *data)
+{
+        unsigned long *rc = data;
+        *rc |= ibmvfc_cancel_all(sdev, IBMVFC_TMF_ABORT_TASK_SET);
+}
+
+/**
+ * ibmvfc_dev_cancel_all_reset - Device iterated cancel all function
  * @sdev:       scsi device struct
  * @data:       return code
  *
  **/
-static void ibmvfc_dev_cancel_all(struct scsi_device *sdev, void *data)
+static void ibmvfc_dev_cancel_all_reset(struct scsi_device *sdev, void *data)
 {
         unsigned long *rc = data;
         *rc |= ibmvfc_cancel_all(sdev, IBMVFC_TMF_TGT_RESET);
@@ -2102,7 +2390,7 @@ static int ibmvfc_eh_target_reset_handler(struct scsi_cmnd *cmd)
 
         ENTER;
         ibmvfc_wait_while_resetting(vhost);
-        starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all);
+        starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all_reset);
         reset_rc = ibmvfc_reset_device(sdev, IBMVFC_TARGET_RESET, "target");
 
         if (!cancel_rc && !reset_rc)
@@ -2144,7 +2432,7 @@ static void ibmvfc_terminate_rport_io(struct fc_rport *rport)
         int rc = FAILED;
 
         ENTER;
-        starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all);
+        starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all_abts);
         starget_for_each_device(starget, &abort_rc, ibmvfc_dev_abort_all);
 
         if (!cancel_rc && !abort_rc)
@@ -2297,13 +2585,13 @@ static void ibmvfc_handle_crq(struct ibmvfc_crq *crq, struct ibmvfc_host *vhost)
                         /* Send back a response */
                         rc = ibmvfc_send_crq_init_complete(vhost);
                         if (rc == 0)
-                                ibmvfc_init_host(vhost, 0);
+                                ibmvfc_init_host(vhost);
                         else
                                 dev_err(vhost->dev, "Unable to send init rsp. rc=%ld\n", rc);
                         break;
                 case IBMVFC_CRQ_INIT_COMPLETE:
                         dev_info(vhost->dev, "Partner initialization complete\n");
-                        ibmvfc_init_host(vhost, 0);
+                        ibmvfc_init_host(vhost);
                         break;
                 default:
                         dev_err(vhost->dev, "Unknown crq message type: %d\n", crq->format);
@@ -2478,12 +2766,17 @@ static int ibmvfc_slave_configure(struct scsi_device *sdev)
  * ibmvfc_change_queue_depth - Change the device's queue depth
  * @sdev:       scsi device struct
  * @qdepth:     depth to set
+ * @reason:     calling context
  *
  * Return value:
  *      actual depth set
  **/
-static int ibmvfc_change_queue_depth(struct scsi_device *sdev, int qdepth)
+static int ibmvfc_change_queue_depth(struct scsi_device *sdev, int qdepth,
+                                     int reason)
 {
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
         if (qdepth > IBMVFC_MAX_CMDS_PER_LUN)
                 qdepth = IBMVFC_MAX_CMDS_PER_LUN;
 
@@ -3725,7 +4018,7 @@ static void ibmvfc_npiv_logout_done(struct ibmvfc_event *evt)
         case IBMVFC_MAD_SUCCESS:
                 if (list_empty(&vhost->sent) &&
                     vhost->action == IBMVFC_HOST_ACTION_LOGO_WAIT) {
-                        ibmvfc_init_host(vhost, 0);
+                        ibmvfc_init_host(vhost);
                         return;
                 }
                 break;
@@ -3903,6 +4196,8 @@ static void ibmvfc_tgt_add_rport(struct ibmvfc_target *tgt)
                         rport->supported_classes |= FC_COS_CLASS2;
                 if (tgt->service_parms.class3_parms[0] & 0x80000000)
                         rport->supported_classes |= FC_COS_CLASS3;
+                if (rport->rqst_q)
+                        blk_queue_max_segments(rport->rqst_q, 1);
         } else
                 tgt_dbg(tgt, "rport add failed\n");
         spin_unlock_irqrestore(vhost->host->host_lock, flags);
@@ -4342,6 +4637,7 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id)
         init_waitqueue_head(&vhost->work_wait_q);
         init_waitqueue_head(&vhost->init_wait_q);
         INIT_WORK(&vhost->rport_add_work_q, ibmvfc_rport_add_thread);
+        mutex_init(&vhost->passthru_mutex);
 
         if ((rc = ibmvfc_alloc_mem(vhost)))
                 goto free_scsi_host;
@@ -4374,6 +4670,8 @@ static int ibmvfc_probe(struct vio_dev *vdev, const struct vio_device_id *id)
                 goto remove_shost;
         }
 
+        if (shost_to_fc_host(shost)->rqst_q)
+                blk_queue_max_segments(shost_to_fc_host(shost)->rqst_q, 1);
         dev_set_drvdata(dev, vhost);
         spin_lock(&ibmvfc_driver_lock);
         list_add_tail(&vhost->queue, &ibmvfc_head);
@@ -4414,7 +4712,11 @@ static int ibmvfc_remove(struct vio_dev *vdev)
 
         ENTER;
         ibmvfc_remove_trace_file(&vhost->host->shost_dev.kobj, &ibmvfc_trace_attr);
+
+        spin_lock_irqsave(vhost->host->host_lock, flags);
         ibmvfc_link_down(vhost, IBMVFC_HOST_OFFLINE);
+        spin_unlock_irqrestore(vhost->host->host_lock, flags);
+
         ibmvfc_wait_while_resetting(vhost);
         ibmvfc_release_crq_queue(vhost);
         kthread_stop(vhost->work_thread);
@@ -4436,6 +4738,27 @@ static int ibmvfc_remove(struct vio_dev *vdev)
 }
 
 /**
+ * ibmvfc_resume - Resume from suspend
+ * @dev:        device struct
+ *
+ * We may have lost an interrupt across suspend/resume, so kick the
+ * interrupt handler
+ *
+ */
+static int ibmvfc_resume(struct device *dev)
+{
+        unsigned long flags;
+        struct ibmvfc_host *vhost = dev_get_drvdata(dev);
+        struct vio_dev *vdev = to_vio_dev(dev);
+
+        spin_lock_irqsave(vhost->host->host_lock, flags);
+        vio_disable_interrupts(vdev);
+        tasklet_schedule(&vhost->tasklet);
+        spin_unlock_irqrestore(vhost->host->host_lock, flags);
+        return 0;
+}
+
+/**
  * ibmvfc_get_desired_dma - Calculate DMA resources needed by the driver
  * @vdev:       vio device struct
  *
@@ -4455,6 +4778,10 @@ static struct vio_device_id ibmvfc_device_table[] __devinitdata = {
 };
 MODULE_DEVICE_TABLE(vio, ibmvfc_device_table);
 
+static struct dev_pm_ops ibmvfc_pm_ops = {
+        .resume = ibmvfc_resume
+};
+
 static struct vio_driver ibmvfc_driver = {
         .id_table = ibmvfc_device_table,
         .probe = ibmvfc_probe,
@@ -4463,6 +4790,7 @@ static struct vio_driver ibmvfc_driver = {
         .driver = {
                 .name = IBMVFC_NAME,
                 .owner = THIS_MODULE,
+                .pm = &ibmvfc_pm_ops,
         }
 };
 
@@ -4498,6 +4826,9 @@ static struct fc_function_template ibmvfc_transport_functions = {
 
         .get_starget_port_id = ibmvfc_get_starget_port_id,
         .show_starget_port_id = 1,
+
+        .bsg_request = ibmvfc_bsg_request,
+        .bsg_timeout = ibmvfc_bsg_timeout,
 };
 
 /**
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.h b/drivers/scsi/ibmvscsi/ibmvfc.h
index 007fa1c9ef14..d25106a958d7 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.h
+++ b/drivers/scsi/ibmvscsi/ibmvfc.h
@@ -29,8 +29,8 @@
 #include "viosrp.h"
 
 #define IBMVFC_NAME     "ibmvfc"
-#define IBMVFC_DRIVER_VERSION           "1.0.6"
-#define IBMVFC_DRIVER_DATE              "(May 28, 2009)"
+#define IBMVFC_DRIVER_VERSION           "1.0.7"
+#define IBMVFC_DRIVER_DATE              "(October 16, 2009)"
 
 #define IBMVFC_DEFAULT_TIMEOUT  60
 #define IBMVFC_ADISC_CANCEL_TIMEOUT     45
@@ -58,9 +58,10 @@
  * 1 for ERP
  * 1 for initialization
  * 1 for NPIV Logout
+ * 2 for BSG passthru
  * 2 for each discovery thread
  */
-#define IBMVFC_NUM_INTERNAL_REQ (1 + 1 + 1 + (disc_threads * 2))
+#define IBMVFC_NUM_INTERNAL_REQ (1 + 1 + 1 + 2 + (disc_threads * 2))
 
 #define IBMVFC_MAD_SUCCESS              0x00
 #define IBMVFC_MAD_NOT_SUPPORTED        0xF1
@@ -466,7 +467,10 @@ struct ibmvfc_passthru_iu {
         u16 error;
         u32 flags;
 #define IBMVFC_FC_ELS           0x01
+#define IBMVFC_FC_CT_IU         0x02
         u32 cancel_key;
+#define IBMVFC_PASSTHRU_CANCEL_KEY      0x80000000
+#define IBMVFC_INTERNAL_CANCEL_KEY      0x80000001
         u32 reserved;
         struct srp_direct_buf cmd;
         struct srp_direct_buf rsp;
@@ -693,6 +697,7 @@ struct ibmvfc_host {
         int disc_buf_sz;
         int log_level;
         struct ibmvfc_discover_targets_buf *disc_buf;
+        struct mutex passthru_mutex;
         int task_set;
         int init_retries;
         int discovery_threads;
@@ -702,6 +707,7 @@ struct ibmvfc_host {
         int delay_init;
         int scan_complete;
         int logged_in;
+        int aborting_passthru;
         int events_to_log;
 #define IBMVFC_AE_LINKUP        0x0001
 #define IBMVFC_AE_LINKDOWN      0x0002
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index d9b0e9d31983..88bad0e81bdd 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -40,7 +40,7 @@
  * (CRQ), which is just a buffer of 16 byte entries in the receiver's 
  * Senders cannot access the buffer directly, but send messages by
  * making a hypervisor call and passing in the 16 bytes.  The hypervisor
- * puts the message in the next 16 byte space in round-robbin fashion,
+ * puts the message in the next 16 byte space in round-robin fashion,
  * turns on the high order bit of the message (the valid bit), and 
  * generates an interrupt to the receiver (if interrupts are turned on.) 
  * The receiver just turns off the valid bit when they have copied out
@@ -70,7 +70,9 @@
 #include <linux/moduleparam.h>
 #include <linux/dma-mapping.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <linux/of.h>
+#include <linux/pm.h>
 #include <asm/firmware.h>
 #include <asm/vio.h>
 #include <scsi/scsi.h>
@@ -321,16 +323,6 @@ static void set_srp_direction(struct scsi_cmnd *cmd,
                 srp_cmd->buf_fmt = fmt;
 }
 
-static void unmap_sg_list(int num_entries,
-                struct device *dev,
-                struct srp_direct_buf *md)
-{
-        int i;
-
-        for (i = 0; i < num_entries; ++i)
-                dma_unmap_single(dev, md[i].va, md[i].len, DMA_BIDIRECTIONAL);
-}
-
 /**
  * unmap_cmd_data: - Unmap data pointed in srp_cmd based on the format
  * @cmd:        srp_cmd whose additional_data member will be unmapped
@@ -348,24 +340,9 @@ static void unmap_cmd_data(struct srp_cmd *cmd,
 
         if (out_fmt == SRP_NO_DATA_DESC && in_fmt == SRP_NO_DATA_DESC)
                 return;
-        else if (out_fmt == SRP_DATA_DESC_DIRECT ||
-                 in_fmt == SRP_DATA_DESC_DIRECT) {
-                struct srp_direct_buf *data =
-                        (struct srp_direct_buf *) cmd->add_data;
-                dma_unmap_single(dev, data->va, data->len, DMA_BIDIRECTIONAL);
-        } else {
-                struct srp_indirect_buf *indirect =
-                        (struct srp_indirect_buf *) cmd->add_data;
-                int num_mapped = indirect->table_desc.len /
-                        sizeof(struct srp_direct_buf);
 
-                if (num_mapped <= MAX_INDIRECT_BUFS) {
-                        unmap_sg_list(num_mapped, dev, &indirect->desc_list[0]);
-                        return;
-                }
-
-                unmap_sg_list(num_mapped, dev, evt_struct->ext_list);
-        }
+        if (evt_struct->cmnd)
+                scsi_dma_unmap(evt_struct->cmnd);
 }
 
 static int map_sg_list(struct scsi_cmnd *cmd, int nseg,
@@ -1637,12 +1614,17 @@ static int ibmvscsi_slave_configure(struct scsi_device *sdev)
  * ibmvscsi_change_queue_depth - Change the device's queue depth
  * @sdev:       scsi device struct
  * @qdepth:     depth to set
+ * @reason:     calling context
  *
  * Return value:
  *      actual depth set
  **/
-static int ibmvscsi_change_queue_depth(struct scsi_device *sdev, int qdepth)
+static int ibmvscsi_change_queue_depth(struct scsi_device *sdev, int qdepth,
+                                       int reason)
 {
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
         if (qdepth > IBMVSCSI_MAX_CMDS_PER_LUN)
                 qdepth = IBMVSCSI_MAX_CMDS_PER_LUN;
 
@@ -1986,6 +1968,19 @@ static int ibmvscsi_remove(struct vio_dev *vdev)
 }
 
 /**
+ * ibmvscsi_resume: Resume from suspend
+ * @dev:        device struct
+ *
+ * We may have lost an interrupt across suspend/resume, so kick the
+ * interrupt handler
+ */
+static int ibmvscsi_resume(struct device *dev)
+{
+        struct ibmvscsi_host_data *hostdata = dev_get_drvdata(dev);
+        return ibmvscsi_ops->resume(hostdata);
+}
+
+/**
  * ibmvscsi_device_table: Used by vio.c to match devices in the device tree we 
  * support.
  */
@@ -1995,6 +1990,10 @@ static struct vio_device_id ibmvscsi_device_table[] __devinitdata = {
 };
 MODULE_DEVICE_TABLE(vio, ibmvscsi_device_table);
 
+static struct dev_pm_ops ibmvscsi_pm_ops = {
+        .resume = ibmvscsi_resume
+};
+
 static struct vio_driver ibmvscsi_driver = {
         .id_table = ibmvscsi_device_table,
         .probe = ibmvscsi_probe,
@@ -2003,6 +2002,7 @@ static struct vio_driver ibmvscsi_driver = {
         .driver = {
                 .name = "ibmvscsi",
                 .owner = THIS_MODULE,
+                .pm = &ibmvscsi_pm_ops,
         }
 };
 
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.h b/drivers/scsi/ibmvscsi/ibmvscsi.h
index 76425303def0..9cb7c6a773e1 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.h
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.h
@@ -120,6 +120,7 @@ struct ibmvscsi_ops {
                                   struct ibmvscsi_host_data *hostdata);
         int (*send_crq)(struct ibmvscsi_host_data *hostdata,
                        u64 word1, u64 word2);
+        int (*resume) (struct ibmvscsi_host_data *hostdata);
 };
 
 extern struct ibmvscsi_ops iseriesvscsi_ops;
diff --git a/drivers/scsi/ibmvscsi/ibmvstgt.c b/drivers/scsi/ibmvscsi/ibmvstgt.c
index d5eaf9727109..e2056d517e99 100644
--- a/drivers/scsi/ibmvscsi/ibmvstgt.c
+++ b/drivers/scsi/ibmvscsi/ibmvstgt.c
@@ -23,6 +23,7 @@
  */
 #include <linux/interrupt.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_transport_srp.h>
diff --git a/drivers/scsi/ibmvscsi/iseries_vscsi.c b/drivers/scsi/ibmvscsi/iseries_vscsi.c
index 0775fdee5fa8..f4776451a754 100644
--- a/drivers/scsi/ibmvscsi/iseries_vscsi.c
+++ b/drivers/scsi/ibmvscsi/iseries_vscsi.c
@@ -158,10 +158,16 @@ static int iseriesvscsi_send_crq(struct ibmvscsi_host_data *hostdata,
                                              0);
 }
 
+static int iseriesvscsi_resume(struct ibmvscsi_host_data *hostdata)
+{
+        return 0;
+}
+
 struct ibmvscsi_ops iseriesvscsi_ops = {
         .init_crq_queue = iseriesvscsi_init_crq_queue,
         .release_crq_queue = iseriesvscsi_release_crq_queue,
         .reset_crq_queue = iseriesvscsi_reset_crq_queue,
         .reenable_crq_queue = iseriesvscsi_reenable_crq_queue,
         .send_crq = iseriesvscsi_send_crq,
+        .resume = iseriesvscsi_resume,
 };
diff --git a/drivers/scsi/ibmvscsi/rpa_vscsi.c b/drivers/scsi/ibmvscsi/rpa_vscsi.c
index 462a8574dad9..a864ccc0a342 100644
--- a/drivers/scsi/ibmvscsi/rpa_vscsi.c
+++ b/drivers/scsi/ibmvscsi/rpa_vscsi.c
@@ -32,6 +32,7 @@
 #include <asm/iommu.h>
 #include <asm/hvcall.h>
 #include <linux/dma-mapping.h>
+#include <linux/gfp.h>
 #include <linux/interrupt.h>
 #include "ibmvscsi.h"
 
@@ -334,10 +335,23 @@ static int rpavscsi_reenable_crq_queue(struct crq_queue *queue,
         return rc;
 }
 
+/**
+ * rpavscsi_resume: - resume after suspend
+ * @hostdata:   ibmvscsi_host_data of host
+ *
+ */
+static int rpavscsi_resume(struct ibmvscsi_host_data *hostdata)
+{
+        vio_disable_interrupts(to_vio_dev(hostdata->dev));
+        tasklet_schedule(&hostdata->srp_task);
+        return 0;
+}
+
 struct ibmvscsi_ops rpavscsi_ops = {
         .init_crq_queue = rpavscsi_init_crq_queue,
         .release_crq_queue = rpavscsi_release_crq_queue,
         .reset_crq_queue = rpavscsi_reset_crq_queue,
         .reenable_crq_queue = rpavscsi_reenable_crq_queue,
         .send_crq = rpavscsi_send_crq,
+        .resume = rpavscsi_resume,
 };
diff --git a/drivers/scsi/imm.c b/drivers/scsi/imm.c
index c2a9a13d788f..4734ab0b3ff6 100644
--- a/drivers/scsi/imm.c
+++ b/drivers/scsi/imm.c
@@ -15,6 +15,7 @@
 #include <linux/parport.h>
 #include <linux/workqueue.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <asm/io.h>
 
 #include <scsi/scsi.h>
diff --git a/drivers/scsi/initio.c b/drivers/scsi/initio.c
index 89a59484be02..a7714160fbc3 100644
--- a/drivers/scsi/initio.c
+++ b/drivers/scsi/initio.c
@@ -531,7 +531,7 @@ static void initio_read_eeprom(unsigned long base)
  *      initio_stop_bm          -       stop bus master
  *      @host: InitIO we are stopping
  *
- *      Stop any pending DMA operation, aborting the DMA if neccessary
+ *      Stop any pending DMA operation, aborting the DMA if necessary
  */
 
 static void initio_stop_bm(struct initio_host * host)
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 76d294fc7846..520461b9bc09 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -59,6 +59,7 @@
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/delay.h>
 #include <linux/pci.h>
@@ -72,6 +73,8 @@
 #include <linux/moduleparam.h>
 #include <linux/libata.h>
 #include <linux/hdreg.h>
+#include <linux/reboot.h>
+#include <linux/stringify.h>
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/processor.h>
@@ -91,8 +94,8 @@ static unsigned int ipr_max_speed = 1;
 static int ipr_testmode = 0;
 static unsigned int ipr_fastfail = 0;
 static unsigned int ipr_transop_timeout = 0;
-static unsigned int ipr_enable_cache = 1;
 static unsigned int ipr_debug = 0;
+static unsigned int ipr_max_devs = IPR_DEFAULT_SIS64_DEVS;
 static unsigned int ipr_dual_ioa_raid = 1;
 static DEFINE_SPINLOCK(ipr_driver_lock);
 
@@ -104,13 +107,20 @@ static const struct ipr_chip_cfg_t ipr_chip_cfg[] = {
                 {
                         .set_interrupt_mask_reg = 0x0022C,
                         .clr_interrupt_mask_reg = 0x00230,
+                        .clr_interrupt_mask_reg32 = 0x00230,
                         .sense_interrupt_mask_reg = 0x0022C,
+                        .sense_interrupt_mask_reg32 = 0x0022C,
                         .clr_interrupt_reg = 0x00228,
+                        .clr_interrupt_reg32 = 0x00228,
                         .sense_interrupt_reg = 0x00224,
+                        .sense_interrupt_reg32 = 0x00224,
                         .ioarrin_reg = 0x00404,
                         .sense_uproc_interrupt_reg = 0x00214,
+                        .sense_uproc_interrupt_reg32 = 0x00214,
                         .set_uproc_interrupt_reg = 0x00214,
-                        .clr_uproc_interrupt_reg = 0x00218
+                        .set_uproc_interrupt_reg32 = 0x00214,
+                        .clr_uproc_interrupt_reg = 0x00218,
+                        .clr_uproc_interrupt_reg32 = 0x00218
                 }
         },
         { /* Snipe and Scamp */
@@ -119,25 +129,59 @@ static const struct ipr_chip_cfg_t ipr_chip_cfg[] = {
                 {
                         .set_interrupt_mask_reg = 0x00288,
                         .clr_interrupt_mask_reg = 0x0028C,
+                        .clr_interrupt_mask_reg32 = 0x0028C,
                         .sense_interrupt_mask_reg = 0x00288,
+                        .sense_interrupt_mask_reg32 = 0x00288,
                         .clr_interrupt_reg = 0x00284,
+                        .clr_interrupt_reg32 = 0x00284,
                         .sense_interrupt_reg = 0x00280,
+                        .sense_interrupt_reg32 = 0x00280,
                         .ioarrin_reg = 0x00504,
                         .sense_uproc_interrupt_reg = 0x00290,
+                        .sense_uproc_interrupt_reg32 = 0x00290,
                         .set_uproc_interrupt_reg = 0x00290,
-                        .clr_uproc_interrupt_reg = 0x00294
+                        .set_uproc_interrupt_reg32 = 0x00290,
+                        .clr_uproc_interrupt_reg = 0x00294,
+                        .clr_uproc_interrupt_reg32 = 0x00294
+                }
+        },
+        { /* CRoC */
+                .mailbox = 0x00040,
+                .cache_line_size = 0x20,
+                {
+                        .set_interrupt_mask_reg = 0x00010,
+                        .clr_interrupt_mask_reg = 0x00018,
+                        .clr_interrupt_mask_reg32 = 0x0001C,
+                        .sense_interrupt_mask_reg = 0x00010,
+                        .sense_interrupt_mask_reg32 = 0x00014,
+                        .clr_interrupt_reg = 0x00008,
+                        .clr_interrupt_reg32 = 0x0000C,
+                        .sense_interrupt_reg = 0x00000,
+                        .sense_interrupt_reg32 = 0x00004,
+                        .ioarrin_reg = 0x00070,
+                        .sense_uproc_interrupt_reg = 0x00020,
+                        .sense_uproc_interrupt_reg32 = 0x00024,
+                        .set_uproc_interrupt_reg = 0x00020,
+                        .set_uproc_interrupt_reg32 = 0x00024,
+                        .clr_uproc_interrupt_reg = 0x00028,
+                        .clr_uproc_interrupt_reg32 = 0x0002C,
+                        .init_feedback_reg = 0x0005C,
+                        .dump_addr_reg = 0x00064,
+                        .dump_data_reg = 0x00068
                 }
         },
 };
 
 static const struct ipr_chip_t ipr_chip[] = {
-        { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, IPR_USE_LSI, &ipr_chip_cfg[0] },
-        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, IPR_USE_LSI, &ipr_chip_cfg[0] },
-        { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, IPR_USE_LSI, &ipr_chip_cfg[0] },
-        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, IPR_USE_LSI, &ipr_chip_cfg[0] },
-        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, IPR_USE_MSI, &ipr_chip_cfg[0] },
-        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE, IPR_USE_LSI, &ipr_chip_cfg[1] },
-        { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, IPR_USE_LSI, &ipr_chip_cfg[1] }
+        { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, IPR_USE_LSI, IPR_SIS32, &ipr_chip_cfg[0] },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, IPR_USE_LSI, IPR_SIS32, &ipr_chip_cfg[0] },
+        { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, IPR_USE_LSI, IPR_SIS32, &ipr_chip_cfg[0] },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, IPR_USE_LSI, IPR_SIS32, &ipr_chip_cfg[0] },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, IPR_USE_MSI, IPR_SIS32, &ipr_chip_cfg[0] },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE, IPR_USE_LSI, IPR_SIS32, &ipr_chip_cfg[1] },
+        { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, IPR_USE_LSI, IPR_SIS32, &ipr_chip_cfg[1] },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2, IPR_USE_MSI, IPR_SIS64, &ipr_chip_cfg[2] },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_ASIC_E2, IPR_USE_MSI, IPR_SIS64, &ipr_chip_cfg[2] }
 };
 
 static int ipr_max_bus_speeds [] = {
@@ -156,12 +200,13 @@ module_param_named(fastfail, ipr_fastfail, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(fastfail, "Reduce timeouts and retries");
 module_param_named(transop_timeout, ipr_transop_timeout, int, 0);
 MODULE_PARM_DESC(transop_timeout, "Time in seconds to wait for adapter to come operational (default: 300)");
-module_param_named(enable_cache, ipr_enable_cache, int, 0);
-MODULE_PARM_DESC(enable_cache, "Enable adapter's non-volatile write cache (default: 1)");
 module_param_named(debug, ipr_debug, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Enable device driver debugging logging. Set to 1 to enable. (default: 0)");
 module_param_named(dual_ioa_raid, ipr_dual_ioa_raid, int, 0);
 MODULE_PARM_DESC(dual_ioa_raid, "Enable dual adapter RAID support. Set to 1 to enable. (default: 1)");
+module_param_named(max_devs, ipr_max_devs, int, 0);
+MODULE_PARM_DESC(max_devs, "Specify the maximum number of physical devices. "
+                 "[Default=" __stringify(IPR_DEFAULT_SIS64_DEVS) "]");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(IPR_DRIVER_VERSION);
 
@@ -180,6 +225,20 @@ struct ipr_error_table_t ipr_error_table[] = {
         "FFFE: Soft device bus error recovered by the IOA"},
         {0x01088100, 0, IPR_DEFAULT_LOG_LEVEL,
         "4101: Soft device bus fabric error"},
+        {0x01100100, 0, IPR_DEFAULT_LOG_LEVEL,
+        "FFFC: Logical block guard error recovered by the device"},
+        {0x01100300, 0, IPR_DEFAULT_LOG_LEVEL,
+        "FFFC: Logical block reference tag error recovered by the device"},
+        {0x01108300, 0, IPR_DEFAULT_LOG_LEVEL,
+        "4171: Recovered scatter list tag / sequence number error"},
+        {0x01109000, 0, IPR_DEFAULT_LOG_LEVEL,
+        "FF3D: Recovered logical block CRC error on IOA to Host transfer"},
+        {0x01109200, 0, IPR_DEFAULT_LOG_LEVEL,
+        "4171: Recovered logical block sequence number error on IOA to Host transfer"},
+        {0x0110A000, 0, IPR_DEFAULT_LOG_LEVEL,
+        "FFFD: Recovered logical block reference tag error detected by the IOA"},
+        {0x0110A100, 0, IPR_DEFAULT_LOG_LEVEL,
+        "FFFD: Logical block guard error recovered by the IOA"},
         {0x01170600, 0, IPR_DEFAULT_LOG_LEVEL,
         "FFF9: Device sector reassign successful"},
         {0x01170900, 0, IPR_DEFAULT_LOG_LEVEL,
@@ -236,12 +295,28 @@ struct ipr_error_table_t ipr_error_table[] = {
         "3120: SCSI bus is not operational"},
         {0x04088100, 0, IPR_DEFAULT_LOG_LEVEL,
         "4100: Hard device bus fabric error"},
+        {0x04100100, 0, IPR_DEFAULT_LOG_LEVEL,
+        "310C: Logical block guard error detected by the device"},
+        {0x04100300, 0, IPR_DEFAULT_LOG_LEVEL,
+        "310C: Logical block reference tag error detected by the device"},
+        {0x04108300, 1, IPR_DEFAULT_LOG_LEVEL,
+        "4170: Scatter list tag / sequence number error"},
+        {0x04109000, 1, IPR_DEFAULT_LOG_LEVEL,
+        "8150: Logical block CRC error on IOA to Host transfer"},
+        {0x04109200, 1, IPR_DEFAULT_LOG_LEVEL,
+        "4170: Logical block sequence number error on IOA to Host transfer"},
+        {0x0410A000, 0, IPR_DEFAULT_LOG_LEVEL,
+        "310D: Logical block reference tag error detected by the IOA"},
+        {0x0410A100, 0, IPR_DEFAULT_LOG_LEVEL,
+        "310D: Logical block guard error detected by the IOA"},
         {0x04118000, 0, IPR_DEFAULT_LOG_LEVEL,
         "9000: IOA reserved area data check"},
         {0x04118100, 0, IPR_DEFAULT_LOG_LEVEL,
         "9001: IOA reserved area invalid data pattern"},
         {0x04118200, 0, IPR_DEFAULT_LOG_LEVEL,
         "9002: IOA reserved area LRC error"},
+        {0x04118300, 1, IPR_DEFAULT_LOG_LEVEL,
+        "Hardware Error, IOA metadata access error"},
         {0x04320000, 0, IPR_DEFAULT_LOG_LEVEL,
         "102E: Out of alternate sectors for disk storage"},
         {0x04330000, 1, IPR_DEFAULT_LOG_LEVEL,
@@ -306,6 +381,8 @@ struct ipr_error_table_t ipr_error_table[] = {
         "Illegal request, commands not allowed to this device"},
         {0x05258100, 0, 0,
         "Illegal request, command not allowed to a secondary adapter"},
+        {0x05258200, 0, 0,
+        "Illegal request, command not allowed to a non-optimized resource"},
         {0x05260000, 0, 0,
         "Illegal request, invalid field in parameter list"},
         {0x05260100, 0, 0,
@@ -468,7 +545,10 @@ static void ipr_trc_hook(struct ipr_cmnd *ipr_cmd,
         trace_entry->time = jiffies;
         trace_entry->op_code = ipr_cmd->ioarcb.cmd_pkt.cdb[0];
         trace_entry->type = type;
-        trace_entry->ata_op_code = ipr_cmd->ioarcb.add_data.u.regs.command;
+        if (ipr_cmd->ioa_cfg->sis64)
+                trace_entry->ata_op_code = ipr_cmd->i.ata_ioadl.regs.command;
+        else
+                trace_entry->ata_op_code = ipr_cmd->ioarcb.u.add_data.u.regs.command;
         trace_entry->cmd_index = ipr_cmd->cmd_index & 0xff;
         trace_entry->res_handle = ipr_cmd->ioarcb.res_handle;
         trace_entry->u.add_data = add_data;
@@ -488,16 +568,23 @@ static void ipr_reinit_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
         struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
-        dma_addr_t dma_addr = be32_to_cpu(ioarcb->ioarcb_host_pci_addr);
+        dma_addr_t dma_addr = ipr_cmd->dma_addr;
 
         memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
-        ioarcb->write_data_transfer_length = 0;
+        ioarcb->data_transfer_length = 0;
         ioarcb->read_data_transfer_length = 0;
-        ioarcb->write_ioadl_len = 0;
+        ioarcb->ioadl_len = 0;
         ioarcb->read_ioadl_len = 0;
-        ioarcb->write_ioadl_addr =
-                cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, ioadl));
-        ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
+
+        if (ipr_cmd->ioa_cfg->sis64)
+                ioarcb->u.sis64_addr_data.data_ioadl_addr =
+                        cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
+        else {
+                ioarcb->write_ioadl_addr =
+                        cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
+                ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
+        }
+
         ioasa->ioasc = 0;
         ioasa->residual_data_len = 0;
         ioasa->u.gata.status = 0;
@@ -562,10 +649,15 @@ static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg *ioa_cfg,
         ioa_cfg->allow_interrupts = 0;
 
         /* Set interrupt mask to stop all new interrupts */
-        writel(~0, ioa_cfg->regs.set_interrupt_mask_reg);
+        if (ioa_cfg->sis64)
+                writeq(~0, ioa_cfg->regs.set_interrupt_mask_reg);
+        else
+                writel(~0, ioa_cfg->regs.set_interrupt_mask_reg);
 
         /* Clear any pending interrupts */
-        writel(clr_ints, ioa_cfg->regs.clr_interrupt_reg);
+        if (ioa_cfg->sis64)
+                writel(~0, ioa_cfg->regs.clr_interrupt_reg);
+        writel(clr_ints, ioa_cfg->regs.clr_interrupt_reg32);
         int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
 }
 
@@ -693,6 +785,35 @@ static void ipr_fail_all_ops(struct ipr_ioa_cfg *ioa_cfg)
 }
 
 /**
+ * ipr_send_command -  Send driver initiated requests.
+ * @ipr_cmd:            ipr command struct
+ *
+ * This function sends a command to the adapter using the correct write call.
+ * In the case of sis64, calculate the ioarcb size required. Then or in the
+ * appropriate bits.
+ *
+ * Return value:
+ *      none
+ **/
+static void ipr_send_command(struct ipr_cmnd *ipr_cmd)
+{
+        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
+        dma_addr_t send_dma_addr = ipr_cmd->dma_addr;
+
+        if (ioa_cfg->sis64) {
+                /* The default size is 256 bytes */
+                send_dma_addr |= 0x1;
+
+                /* If the number of ioadls * size of ioadl > 128 bytes,
+                   then use a 512 byte ioarcb */
+                if (ipr_cmd->dma_use_sg * sizeof(struct ipr_ioadl64_desc) > 128 )
+                        send_dma_addr |= 0x4;
+                writeq(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
+        } else
+                writel(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
+}
+
+/**
  * ipr_do_req -  Send driver initiated requests.
  * @ipr_cmd:            ipr command struct
  * @done:                       done function
@@ -724,8 +845,8 @@ static void ipr_do_req(struct ipr_cmnd *ipr_cmd,
         ipr_trc_hook(ipr_cmd, IPR_TRACE_START, 0);
 
         mb();
-        writel(be32_to_cpu(ipr_cmd->ioarcb.ioarcb_host_pci_addr),
-               ioa_cfg->regs.ioarrin_reg);
+
+        ipr_send_command(ipr_cmd);
 }
 
 /**
@@ -747,6 +868,51 @@ static void ipr_internal_cmd_done(struct ipr_cmnd *ipr_cmd)
 }
 
 /**
+ * ipr_init_ioadl - initialize the ioadl for the correct SIS type
+ * @ipr_cmd:    ipr command struct
+ * @dma_addr:   dma address
+ * @len:        transfer length
+ * @flags:      ioadl flag value
+ *
+ * This function initializes an ioadl in the case where there is only a single
+ * descriptor.
+ *
+ * Return value:
+ *      nothing
+ **/
+static void ipr_init_ioadl(struct ipr_cmnd *ipr_cmd, dma_addr_t dma_addr,
+                           u32 len, int flags)
+{
+        struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
+        struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
+
+        ipr_cmd->dma_use_sg = 1;
+
+        if (ipr_cmd->ioa_cfg->sis64) {
+                ioadl64->flags = cpu_to_be32(flags);
+                ioadl64->data_len = cpu_to_be32(len);
+                ioadl64->address = cpu_to_be64(dma_addr);
+
+                ipr_cmd->ioarcb.ioadl_len =
+                        cpu_to_be32(sizeof(struct ipr_ioadl64_desc));
+                ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len);
+        } else {
+                ioadl->flags_and_data_len = cpu_to_be32(flags | len);
+                ioadl->address = cpu_to_be32(dma_addr);
+
+                if (flags == IPR_IOADL_FLAGS_READ_LAST) {
+                        ipr_cmd->ioarcb.read_ioadl_len =
+                                cpu_to_be32(sizeof(struct ipr_ioadl_desc));
+                        ipr_cmd->ioarcb.read_data_transfer_length = cpu_to_be32(len);
+                } else {
+                        ipr_cmd->ioarcb.ioadl_len =
+                                cpu_to_be32(sizeof(struct ipr_ioadl_desc));
+                        ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len);
+                }
+        }
+}
+
+/**
  * ipr_send_blocking_cmd - Send command and sleep on its completion.
  * @ipr_cmd:    ipr command struct
  * @timeout_func:       function to invoke if command times out
@@ -803,11 +969,8 @@ static void ipr_send_hcam(struct ipr_ioa_cfg *ioa_cfg, u8 type,
                 ioarcb->cmd_pkt.cdb[7] = (sizeof(hostrcb->hcam) >> 8) & 0xff;
                 ioarcb->cmd_pkt.cdb[8] = sizeof(hostrcb->hcam) & 0xff;
 
-                ioarcb->read_data_transfer_length = cpu_to_be32(sizeof(hostrcb->hcam));
-                ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
-                ipr_cmd->ioadl[0].flags_and_data_len =
-                        cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | sizeof(hostrcb->hcam));
-                ipr_cmd->ioadl[0].address = cpu_to_be32(hostrcb->hostrcb_dma);
+                ipr_init_ioadl(ipr_cmd, hostrcb->hostrcb_dma,
+                               sizeof(hostrcb->hcam), IPR_IOADL_FLAGS_READ_LAST);
 
                 if (type == IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE)
                         ipr_cmd->done = ipr_process_ccn;
@@ -817,22 +980,54 @@ static void ipr_send_hcam(struct ipr_ioa_cfg *ioa_cfg, u8 type,
                 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_IOA_RES_ADDR);
 
                 mb();
-                writel(be32_to_cpu(ipr_cmd->ioarcb.ioarcb_host_pci_addr),
-                       ioa_cfg->regs.ioarrin_reg);
+
+                ipr_send_command(ipr_cmd);
         } else {
                 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
         }
 }
 
 /**
+ * ipr_update_ata_class - Update the ata class in the resource entry
+ * @res:        resource entry struct
+ * @proto:      cfgte device bus protocol value
+ *
+ * Return value:
+ *      none
+ **/
+static void ipr_update_ata_class(struct ipr_resource_entry *res, unsigned int proto)
+{
+        switch(proto) {
+        case IPR_PROTO_SATA:
+        case IPR_PROTO_SAS_STP:
+                res->ata_class = ATA_DEV_ATA;
+                break;
+        case IPR_PROTO_SATA_ATAPI:
+        case IPR_PROTO_SAS_STP_ATAPI:
+                res->ata_class = ATA_DEV_ATAPI;
+                break;
+        default:
+                res->ata_class = ATA_DEV_UNKNOWN;
+                break;
+        };
+}
+
+/**
  * ipr_init_res_entry - Initialize a resource entry struct.
  * @res:        resource entry struct
+ * @cfgtew:     config table entry wrapper struct
  *
  * Return value:
  *      none
  **/
-static void ipr_init_res_entry(struct ipr_resource_entry *res)
+static void ipr_init_res_entry(struct ipr_resource_entry *res,
+                               struct ipr_config_table_entry_wrapper *cfgtew)
 {
+        int found = 0;
+        unsigned int proto;
+        struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
+        struct ipr_resource_entry *gscsi_res = NULL;
+
         res->needs_sync_complete = 0;
         res->in_erp = 0;
         res->add_to_ml = 0;
@@ -840,6 +1035,205 @@ static void ipr_init_res_entry(struct ipr_resource_entry *res)
         res->resetting_device = 0;
         res->sdev = NULL;
         res->sata_port = NULL;
+
+        if (ioa_cfg->sis64) {
+                proto = cfgtew->u.cfgte64->proto;
+                res->res_flags = cfgtew->u.cfgte64->res_flags;
+                res->qmodel = IPR_QUEUEING_MODEL64(res);
+                res->type = cfgtew->u.cfgte64->res_type & 0x0f;
+
+                memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
+                        sizeof(res->res_path));
+
+                res->bus = 0;
+                res->lun = scsilun_to_int(&res->dev_lun);
+
+                if (res->type == IPR_RES_TYPE_GENERIC_SCSI) {
+                        list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue) {
+                                if (gscsi_res->dev_id == cfgtew->u.cfgte64->dev_id) {
+                                        found = 1;
+                                        res->target = gscsi_res->target;
+                                        break;
+                                }
+                        }
+                        if (!found) {
+                                res->target = find_first_zero_bit(ioa_cfg->target_ids,
+                                                                  ioa_cfg->max_devs_supported);
+                                set_bit(res->target, ioa_cfg->target_ids);
+                        }
+
+                        memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
+                                sizeof(res->dev_lun.scsi_lun));
+                } else if (res->type == IPR_RES_TYPE_IOAFP) {
+                        res->bus = IPR_IOAFP_VIRTUAL_BUS;
+                        res->target = 0;
+                } else if (res->type == IPR_RES_TYPE_ARRAY) {
+                        res->bus = IPR_ARRAY_VIRTUAL_BUS;
+                        res->target = find_first_zero_bit(ioa_cfg->array_ids,
+                                                          ioa_cfg->max_devs_supported);
+                        set_bit(res->target, ioa_cfg->array_ids);
+                } else if (res->type == IPR_RES_TYPE_VOLUME_SET) {
+                        res->bus = IPR_VSET_VIRTUAL_BUS;
+                        res->target = find_first_zero_bit(ioa_cfg->vset_ids,
+                                                          ioa_cfg->max_devs_supported);
+                        set_bit(res->target, ioa_cfg->vset_ids);
+                } else {
+                        res->target = find_first_zero_bit(ioa_cfg->target_ids,
+                                                          ioa_cfg->max_devs_supported);
+                        set_bit(res->target, ioa_cfg->target_ids);
+                }
+        } else {
+                proto = cfgtew->u.cfgte->proto;
+                res->qmodel = IPR_QUEUEING_MODEL(res);
+                res->flags = cfgtew->u.cfgte->flags;
+                if (res->flags & IPR_IS_IOA_RESOURCE)
+                        res->type = IPR_RES_TYPE_IOAFP;
+                else
+                        res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
+
+                res->bus = cfgtew->u.cfgte->res_addr.bus;
+                res->target = cfgtew->u.cfgte->res_addr.target;
+                res->lun = cfgtew->u.cfgte->res_addr.lun;
+        }
+
+        ipr_update_ata_class(res, proto);
+}
+
+/**
+ * ipr_is_same_device - Determine if two devices are the same.
+ * @res:        resource entry struct
+ * @cfgtew:     config table entry wrapper struct
+ *
+ * Return value:
+ *      1 if the devices are the same / 0 otherwise
+ **/
+static int ipr_is_same_device(struct ipr_resource_entry *res,
+                              struct ipr_config_table_entry_wrapper *cfgtew)
+{
+        if (res->ioa_cfg->sis64) {
+                if (!memcmp(&res->dev_id, &cfgtew->u.cfgte64->dev_id,
+                                        sizeof(cfgtew->u.cfgte64->dev_id)) &&
+                        !memcmp(&res->lun, &cfgtew->u.cfgte64->lun,
+                                        sizeof(cfgtew->u.cfgte64->lun))) {
+                        return 1;
+                }
+        } else {
+                if (res->bus == cfgtew->u.cfgte->res_addr.bus &&
+                    res->target == cfgtew->u.cfgte->res_addr.target &&
+                    res->lun == cfgtew->u.cfgte->res_addr.lun)
+                        return 1;
+        }
+
+        return 0;
+}
+
+/**
+ * ipr_format_resource_path - Format the resource path for printing.
+ * @res_path:   resource path
+ * @buf:        buffer
+ *
+ * Return value:
+ *      pointer to buffer
+ **/
+static char *ipr_format_resource_path(u8 *res_path, char *buffer)
+{
+        int i;
+
+        sprintf(buffer, "%02X", res_path[0]);
+        for (i=1; res_path[i] != 0xff; i++)
+                sprintf(buffer, "%s-%02X", buffer, res_path[i]);
+
+        return buffer;
+}
+
+/**
+ * ipr_update_res_entry - Update the resource entry.
+ * @res:        resource entry struct
+ * @cfgtew:     config table entry wrapper struct
+ *
+ * Return value:
+ *      none
+ **/
+static void ipr_update_res_entry(struct ipr_resource_entry *res,
+                                 struct ipr_config_table_entry_wrapper *cfgtew)
+{
+        char buffer[IPR_MAX_RES_PATH_LENGTH];
+        unsigned int proto;
+        int new_path = 0;
+
+        if (res->ioa_cfg->sis64) {
+                res->flags = cfgtew->u.cfgte64->flags;
+                res->res_flags = cfgtew->u.cfgte64->res_flags;
+                res->type = cfgtew->u.cfgte64->res_type & 0x0f;
+
+                memcpy(&res->std_inq_data, &cfgtew->u.cfgte64->std_inq_data,
+                        sizeof(struct ipr_std_inq_data));
+
+                res->qmodel = IPR_QUEUEING_MODEL64(res);
+                proto = cfgtew->u.cfgte64->proto;
+                res->res_handle = cfgtew->u.cfgte64->res_handle;
+                res->dev_id = cfgtew->u.cfgte64->dev_id;
+
+                memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
+                        sizeof(res->dev_lun.scsi_lun));
+
+                if (memcmp(res->res_path, &cfgtew->u.cfgte64->res_path,
+                                        sizeof(res->res_path))) {
+                        memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
+                                sizeof(res->res_path));
+                        new_path = 1;
+                }
+
+                if (res->sdev && new_path)
+                        sdev_printk(KERN_INFO, res->sdev, "Resource path: %s\n",
+                                    ipr_format_resource_path(&res->res_path[0], &buffer[0]));
+        } else {
+                res->flags = cfgtew->u.cfgte->flags;
+                if (res->flags & IPR_IS_IOA_RESOURCE)
+                        res->type = IPR_RES_TYPE_IOAFP;
+                else
+                        res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
+
+                memcpy(&res->std_inq_data, &cfgtew->u.cfgte->std_inq_data,
+                        sizeof(struct ipr_std_inq_data));
+
+                res->qmodel = IPR_QUEUEING_MODEL(res);
+                proto = cfgtew->u.cfgte->proto;
+                res->res_handle = cfgtew->u.cfgte->res_handle;
+        }
+
+        ipr_update_ata_class(res, proto);
+}
+
+/**
+ * ipr_clear_res_target - Clear the bit in the bit map representing the target
+ *                        for the resource.
+ * @res:        resource entry struct
+ * @cfgtew:     config table entry wrapper struct
+ *
+ * Return value:
+ *      none
+ **/
+static void ipr_clear_res_target(struct ipr_resource_entry *res)
+{
+        struct ipr_resource_entry *gscsi_res = NULL;
+        struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
+
+        if (!ioa_cfg->sis64)
+                return;
+
+        if (res->bus == IPR_ARRAY_VIRTUAL_BUS)
+                clear_bit(res->target, ioa_cfg->array_ids);
+        else if (res->bus == IPR_VSET_VIRTUAL_BUS)
+                clear_bit(res->target, ioa_cfg->vset_ids);
+        else if (res->bus == 0 && res->type == IPR_RES_TYPE_GENERIC_SCSI) {
+                list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue)
+                        if (gscsi_res->dev_id == res->dev_id && gscsi_res != res)
+                                return;
+                clear_bit(res->target, ioa_cfg->target_ids);
+
+        } else if (res->bus == 0)
+                clear_bit(res->target, ioa_cfg->target_ids);
 }
 
 /**
@@ -851,17 +1245,24 @@ static void ipr_init_res_entry(struct ipr_resource_entry *res)
  *      none
  **/
 static void ipr_handle_config_change(struct ipr_ioa_cfg *ioa_cfg,
-                              struct ipr_hostrcb *hostrcb)
+                                     struct ipr_hostrcb *hostrcb)
 {
         struct ipr_resource_entry *res = NULL;
-        struct ipr_config_table_entry *cfgte;
+        struct ipr_config_table_entry_wrapper cfgtew;
+        __be32 cc_res_handle;
+
         u32 is_ndn = 1;
 
-        cfgte = &hostrcb->hcam.u.ccn.cfgte;
+        if (ioa_cfg->sis64) {
+                cfgtew.u.cfgte64 = &hostrcb->hcam.u.ccn.u.cfgte64;
+                cc_res_handle = cfgtew.u.cfgte64->res_handle;
+        } else {
+                cfgtew.u.cfgte = &hostrcb->hcam.u.ccn.u.cfgte;
+                cc_res_handle = cfgtew.u.cfgte->res_handle;
+        }
 
         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
-                if (!memcmp(&res->cfgte.res_addr, &cfgte->res_addr,
-                            sizeof(cfgte->res_addr))) {
+                if (res->res_handle == cc_res_handle) {
                         is_ndn = 0;
                         break;
                 }
@@ -879,20 +1280,22 @@ static void ipr_handle_config_change(struct ipr_ioa_cfg *ioa_cfg,
                                  struct ipr_resource_entry, queue);
 
                 list_del(&res->queue);
-                ipr_init_res_entry(res);
+                ipr_init_res_entry(res, &cfgtew);
                 list_add_tail(&res->queue, &ioa_cfg->used_res_q);
         }
 
-        memcpy(&res->cfgte, cfgte, sizeof(struct ipr_config_table_entry));
+        ipr_update_res_entry(res, &cfgtew);
 
         if (hostrcb->hcam.notify_type == IPR_HOST_RCB_NOTIF_TYPE_REM_ENTRY) {
                 if (res->sdev) {
                         res->del_from_ml = 1;
-                        res->cfgte.res_handle = IPR_INVALID_RES_HANDLE;
+                        res->res_handle = IPR_INVALID_RES_HANDLE;
                         if (ioa_cfg->allow_ml_add_del)
                                 schedule_work(&ioa_cfg->work_q);
-                } else
+                } else {
+                        ipr_clear_res_target(res);
                         list_move_tail(&res->queue, &ioa_cfg->free_res_q);
+                }
         } else if (!res->sdev) {
                 res->add_to_ml = 1;
                 if (ioa_cfg->allow_ml_add_del)
@@ -1044,8 +1447,12 @@ static void ipr_log_ext_vpd(struct ipr_ext_vpd *vpd)
 static void ipr_log_enhanced_cache_error(struct ipr_ioa_cfg *ioa_cfg,
                                          struct ipr_hostrcb *hostrcb)
 {
-        struct ipr_hostrcb_type_12_error *error =
-                &hostrcb->hcam.u.error.u.type_12_error;
+        struct ipr_hostrcb_type_12_error *error;
+
+        if (ioa_cfg->sis64)
+                error = &hostrcb->hcam.u.error64.u.type_12_error;
+        else
+                error = &hostrcb->hcam.u.error.u.type_12_error;
 
         ipr_err("-----Current Configuration-----\n");
         ipr_err("Cache Directory Card Information:\n");
@@ -1138,6 +1545,48 @@ static void ipr_log_enhanced_config_error(struct ipr_ioa_cfg *ioa_cfg,
 }
 
 /**
+ * ipr_log_sis64_config_error - Log a device error.
+ * @ioa_cfg:    ioa config struct
+ * @hostrcb:    hostrcb struct
+ *
+ * Return value:
+ *      none
+ **/
+static void ipr_log_sis64_config_error(struct ipr_ioa_cfg *ioa_cfg,
+                                       struct ipr_hostrcb *hostrcb)
+{
+        int errors_logged, i;
+        struct ipr_hostrcb64_device_data_entry_enhanced *dev_entry;
+        struct ipr_hostrcb_type_23_error *error;
+        char buffer[IPR_MAX_RES_PATH_LENGTH];
+
+        error = &hostrcb->hcam.u.error64.u.type_23_error;
+        errors_logged = be32_to_cpu(error->errors_logged);
+
+        ipr_err("Device Errors Detected/Logged: %d/%d\n",
+                be32_to_cpu(error->errors_detected), errors_logged);
+
+        dev_entry = error->dev;
+
+        for (i = 0; i < errors_logged; i++, dev_entry++) {
+                ipr_err_separator;
+
+                ipr_err("Device %d : %s", i + 1,
+                         ipr_format_resource_path(&dev_entry->res_path[0], &buffer[0]));
+                ipr_log_ext_vpd(&dev_entry->vpd);
+
+                ipr_err("-----New Device Information-----\n");
+                ipr_log_ext_vpd(&dev_entry->new_vpd);
+
+                ipr_err("Cache Directory Card Information:\n");
+                ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
+
+                ipr_err("Adapter Card Information:\n");
+                ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
+        }
+}
+
+/**
  * ipr_log_config_error - Log a configuration error.
  * @ioa_cfg:    ioa config struct
  * @hostrcb:    hostrcb struct
@@ -1331,9 +1780,13 @@ static void ipr_log_enhanced_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
 {
         struct ipr_hostrcb_type_17_error *error;
 
-        error = &hostrcb->hcam.u.error.u.type_17_error;
+        if (ioa_cfg->sis64)
+                error = &hostrcb->hcam.u.error64.u.type_17_error;
+        else
+                error = &hostrcb->hcam.u.error.u.type_17_error;
+
         error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
-        strstrip(error->failure_reason);
+        strim(error->failure_reason);
 
         ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
                      be32_to_cpu(hostrcb->hcam.u.error.prc));
@@ -1359,7 +1812,7 @@ static void ipr_log_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
 
         error = &hostrcb->hcam.u.error.u.type_07_error;
         error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
-        strstrip(error->failure_reason);
+        strim(error->failure_reason);
 
         ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
                      be32_to_cpu(hostrcb->hcam.u.error.prc));
@@ -1438,6 +1891,42 @@ static void ipr_log_fabric_path(struct ipr_hostrcb *hostrcb,
                 fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
 }
 
+/**
+ * ipr_log64_fabric_path - Log a fabric path error
+ * @hostrcb:    hostrcb struct
+ * @fabric:             fabric descriptor
+ *
+ * Return value:
+ *      none
+ **/
+static void ipr_log64_fabric_path(struct ipr_hostrcb *hostrcb,
+                                  struct ipr_hostrcb64_fabric_desc *fabric)
+{
+        int i, j;
+        u8 path_state = fabric->path_state;
+        u8 active = path_state & IPR_PATH_ACTIVE_MASK;
+        u8 state = path_state & IPR_PATH_STATE_MASK;
+        char buffer[IPR_MAX_RES_PATH_LENGTH];
+
+        for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
+                if (path_active_desc[i].active != active)
+                        continue;
+
+                for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
+                        if (path_state_desc[j].state != state)
+                                continue;
+
+                        ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s\n",
+                                     path_active_desc[i].desc, path_state_desc[j].desc,
+                                     ipr_format_resource_path(&fabric->res_path[0], &buffer[0]));
+                        return;
+                }
+        }
+
+        ipr_err("Path state=%02X Resource Path=%s\n", path_state,
+                ipr_format_resource_path(&fabric->res_path[0], &buffer[0]));
+}
+
 static const struct {
         u8 type;
         char *desc;
@@ -1547,6 +2036,49 @@ static void ipr_log_path_elem(struct ipr_hostrcb *hostrcb,
 }
 
 /**
+ * ipr_log64_path_elem - Log a fabric path element.
+ * @hostrcb:    hostrcb struct
+ * @cfg:                fabric path element struct
+ *
+ * Return value:
+ *      none
+ **/
+static void ipr_log64_path_elem(struct ipr_hostrcb *hostrcb,
+                                struct ipr_hostrcb64_config_element *cfg)
+{
+        int i, j;
+        u8 desc_id = cfg->descriptor_id & IPR_DESCRIPTOR_MASK;
+        u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
+        u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
+        char buffer[IPR_MAX_RES_PATH_LENGTH];
+
+        if (type == IPR_PATH_CFG_NOT_EXIST || desc_id != IPR_DESCRIPTOR_SIS64)
+                return;
+
+        for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
+                if (path_type_desc[i].type != type)
+                        continue;
+
+                for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
+                        if (path_status_desc[j].status != status)
+                                continue;
+
+                        ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s, Link rate=%s, WWN=%08X%08X\n",
+                                     path_status_desc[j].desc, path_type_desc[i].desc,
+                                     ipr_format_resource_path(&cfg->res_path[0], &buffer[0]),
+                                     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
+                                     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
+                        return;
+                }
+        }
+        ipr_hcam_err(hostrcb, "Path element=%02X: Resource Path=%s, Link rate=%s "
+                     "WWN=%08X%08X\n", cfg->type_status,
+                     ipr_format_resource_path(&cfg->res_path[0], &buffer[0]),
+                     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
+                     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
+}
+
+/**
  * ipr_log_fabric_error - Log a fabric error.
  * @ioa_cfg:    ioa config struct
  * @hostrcb:    hostrcb struct
@@ -1584,6 +2116,96 @@ static void ipr_log_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
 }
 
 /**
+ * ipr_log_sis64_array_error - Log a sis64 array error.
+ * @ioa_cfg:    ioa config struct
+ * @hostrcb:    hostrcb struct
+ *
+ * Return value:
+ *      none
+ **/
+static void ipr_log_sis64_array_error(struct ipr_ioa_cfg *ioa_cfg,
+                                      struct ipr_hostrcb *hostrcb)
+{
+        int i, num_entries;
+        struct ipr_hostrcb_type_24_error *error;
+        struct ipr_hostrcb64_array_data_entry *array_entry;
+        char buffer[IPR_MAX_RES_PATH_LENGTH];
+        const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
+
+        error = &hostrcb->hcam.u.error64.u.type_24_error;
+
+        ipr_err_separator;
+
+        ipr_err("RAID %s Array Configuration: %s\n",
+                error->protection_level,
+                ipr_format_resource_path(&error->last_res_path[0], &buffer[0]));
+
+        ipr_err_separator;
+
+        array_entry = error->array_member;
+        num_entries = min_t(u32, be32_to_cpu(error->num_entries),
+                            sizeof(error->array_member));
+
+        for (i = 0; i < num_entries; i++, array_entry++) {
+
+                if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
+                        continue;
+
+                if (error->exposed_mode_adn == i)
+                        ipr_err("Exposed Array Member %d:\n", i);
+                else
+                        ipr_err("Array Member %d:\n", i);
+
+                ipr_err("Array Member %d:\n", i);
+                ipr_log_ext_vpd(&array_entry->vpd);
+                ipr_err("Current Location: %s",
+                         ipr_format_resource_path(&array_entry->res_path[0], &buffer[0]));
+                ipr_err("Expected Location: %s",
+                         ipr_format_resource_path(&array_entry->expected_res_path[0], &buffer[0]));
+
+                ipr_err_separator;
+        }
+}
+
+/**
+ * ipr_log_sis64_fabric_error - Log a sis64 fabric error.
+ * @ioa_cfg:    ioa config struct
+ * @hostrcb:    hostrcb struct
+ *
+ * Return value:
+ *      none
+ **/
+static void ipr_log_sis64_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
+                                       struct ipr_hostrcb *hostrcb)
+{
+        struct ipr_hostrcb_type_30_error *error;
+        struct ipr_hostrcb64_fabric_desc *fabric;
+        struct ipr_hostrcb64_config_element *cfg;
+        int i, add_len;
+
+        error = &hostrcb->hcam.u.error64.u.type_30_error;
+
+        error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
+        ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
+
+        add_len = be32_to_cpu(hostrcb->hcam.length) -
+                (offsetof(struct ipr_hostrcb64_error, u) +
+                 offsetof(struct ipr_hostrcb_type_30_error, desc));
+
+        for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
+                ipr_log64_fabric_path(hostrcb, fabric);
+                for_each_fabric_cfg(fabric, cfg)
+                        ipr_log64_path_elem(hostrcb, cfg);
+
+                add_len -= be16_to_cpu(fabric->length);
+                fabric = (struct ipr_hostrcb64_fabric_desc *)
+                        ((unsigned long)fabric + be16_to_cpu(fabric->length));
+        }
+
+        ipr_log_hex_data(ioa_cfg, (u32 *)fabric, add_len);
+}
+
+/**
  * ipr_log_generic_error - Log an adapter error.
  * @ioa_cfg:    ioa config struct
  * @hostrcb:    hostrcb struct
@@ -1642,13 +2264,16 @@ static void ipr_handle_log_data(struct ipr_ioa_cfg *ioa_cfg,
         if (hostrcb->hcam.notifications_lost == IPR_HOST_RCB_NOTIFICATIONS_LOST)
                 dev_err(&ioa_cfg->pdev->dev, "Error notifications lost\n");
 
-        ioasc = be32_to_cpu(hostrcb->hcam.u.error.failing_dev_ioasc);
+        if (ioa_cfg->sis64)
+                ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
+        else
+                ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
 
-        if (ioasc == IPR_IOASC_BUS_WAS_RESET ||
-            ioasc == IPR_IOASC_BUS_WAS_RESET_BY_OTHER) {
+        if (!ioa_cfg->sis64 && (ioasc == IPR_IOASC_BUS_WAS_RESET ||
+            ioasc == IPR_IOASC_BUS_WAS_RESET_BY_OTHER)) {
                 /* Tell the midlayer we had a bus reset so it will handle the UA properly */
                 scsi_report_bus_reset(ioa_cfg->host,
-                                      hostrcb->hcam.u.error.failing_dev_res_addr.bus);
+                                      hostrcb->hcam.u.error.fd_res_addr.bus);
         }
 
         error_index = ipr_get_error(ioasc);
@@ -1696,6 +2321,16 @@ static void ipr_handle_log_data(struct ipr_ioa_cfg *ioa_cfg,
         case IPR_HOST_RCB_OVERLAY_ID_20:
                 ipr_log_fabric_error(ioa_cfg, hostrcb);
                 break;
+        case IPR_HOST_RCB_OVERLAY_ID_23:
+                ipr_log_sis64_config_error(ioa_cfg, hostrcb);
+                break;
+        case IPR_HOST_RCB_OVERLAY_ID_24:
+        case IPR_HOST_RCB_OVERLAY_ID_26:
+                ipr_log_sis64_array_error(ioa_cfg, hostrcb);
+                break;
+        case IPR_HOST_RCB_OVERLAY_ID_30:
+                ipr_log_sis64_fabric_error(ioa_cfg, hostrcb);
+                break;
         case IPR_HOST_RCB_OVERLAY_ID_1:
         case IPR_HOST_RCB_OVERLAY_ID_DEFAULT:
         default:
@@ -1720,7 +2355,12 @@ static void ipr_process_error(struct ipr_cmnd *ipr_cmd)
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
         struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
         u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
-        u32 fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error.failing_dev_ioasc);
+        u32 fd_ioasc;
+
+        if (ioa_cfg->sis64)
+                fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
+        else
+                fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
 
         list_del(&hostrcb->queue);
         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
@@ -1845,12 +2485,14 @@ static const struct ipr_ses_table_entry *
 ipr_find_ses_entry(struct ipr_resource_entry *res)
 {
         int i, j, matches;
+        struct ipr_std_inq_vpids *vpids;
         const struct ipr_ses_table_entry *ste = ipr_ses_table;
 
         for (i = 0; i < ARRAY_SIZE(ipr_ses_table); i++, ste++) {
                 for (j = 0, matches = 0; j < IPR_PROD_ID_LEN; j++) {
                         if (ste->compare_product_id_byte[j] == 'X') {
-                                if (res->cfgte.std_inq_data.vpids.product_id[j] == ste->product_id[j])
+                                vpids = &res->std_inq_data.vpids;
+                                if (vpids->product_id[j] == ste->product_id[j])
                                         matches++;
                                 else
                                         break;
@@ -1885,10 +2527,10 @@ static u32 ipr_get_max_scsi_speed(struct ipr_ioa_cfg *ioa_cfg, u8 bus, u8 bus_wi
 
         /* Loop through each config table entry in the config table buffer */
         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
-                if (!(IPR_IS_SES_DEVICE(res->cfgte.std_inq_data)))
+                if (!(IPR_IS_SES_DEVICE(res->std_inq_data)))
                         continue;
 
-                if (bus != res->cfgte.res_addr.bus)
+                if (bus != res->bus)
                         continue;
 
                 if (!(ste = ipr_find_ses_entry(res)))
@@ -1934,6 +2576,31 @@ static int ipr_wait_iodbg_ack(struct ipr_ioa_cfg *ioa_cfg, int max_delay)
 }
 
 /**
+ * ipr_get_sis64_dump_data_section - Dump IOA memory
+ * @ioa_cfg:                    ioa config struct
+ * @start_addr:                 adapter address to dump
+ * @dest:                       destination kernel buffer
+ * @length_in_words:            length to dump in 4 byte words
+ *
+ * Return value:
+ *      0 on success
+ **/
+static int ipr_get_sis64_dump_data_section(struct ipr_ioa_cfg *ioa_cfg,
+                                           u32 start_addr,
+                                           __be32 *dest, u32 length_in_words)
+{
+        int i;
+
+        for (i = 0; i < length_in_words; i++) {
+                writel(start_addr+(i*4), ioa_cfg->regs.dump_addr_reg);
+                *dest = cpu_to_be32(readl(ioa_cfg->regs.dump_data_reg));
+                dest++;
+        }
+
+        return 0;
+}
+
+/**
  * ipr_get_ldump_data_section - Dump IOA memory
  * @ioa_cfg:                    ioa config struct
  * @start_addr:                 adapter address to dump
@@ -1950,9 +2617,13 @@ static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
         volatile u32 temp_pcii_reg;
         int i, delay = 0;
 
+        if (ioa_cfg->sis64)
+                return ipr_get_sis64_dump_data_section(ioa_cfg, start_addr,
+                                                       dest, length_in_words);
+
         /* Write IOA interrupt reg starting LDUMP state  */
         writel((IPR_UPROCI_RESET_ALERT | IPR_UPROCI_IO_DEBUG_ALERT),
-               ioa_cfg->regs.set_uproc_interrupt_reg);
+               ioa_cfg->regs.set_uproc_interrupt_reg32);
 
         /* Wait for IO debug acknowledge */
         if (ipr_wait_iodbg_ack(ioa_cfg,
@@ -1971,7 +2642,7 @@ static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
 
         /* Signal address valid - clear IOA Reset alert */
         writel(IPR_UPROCI_RESET_ALERT,
-               ioa_cfg->regs.clr_uproc_interrupt_reg);
+               ioa_cfg->regs.clr_uproc_interrupt_reg32);
 
         for (i = 0; i < length_in_words; i++) {
                 /* Wait for IO debug acknowledge */
@@ -1996,10 +2667,10 @@ static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
 
         /* Signal end of block transfer. Set reset alert then clear IO debug ack */
         writel(IPR_UPROCI_RESET_ALERT,
-               ioa_cfg->regs.set_uproc_interrupt_reg);
+               ioa_cfg->regs.set_uproc_interrupt_reg32);
 
         writel(IPR_UPROCI_IO_DEBUG_ALERT,
-               ioa_cfg->regs.clr_uproc_interrupt_reg);
+               ioa_cfg->regs.clr_uproc_interrupt_reg32);
 
         /* Signal dump data received - Clear IO debug Ack */
         writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
@@ -2008,7 +2679,7 @@ static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
         /* Wait for IOA to signal LDUMP exit - IOA reset alert will be cleared */
         while (delay < IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC) {
                 temp_pcii_reg =
-                    readl(ioa_cfg->regs.sense_uproc_interrupt_reg);
+                    readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
 
                 if (!(temp_pcii_reg & IPR_UPROCI_RESET_ALERT))
                         return 0;
@@ -2207,6 +2878,7 @@ static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
         u32 num_entries, start_off, end_off;
         u32 bytes_to_copy, bytes_copied, rc;
         struct ipr_sdt *sdt;
+        int valid = 1;
         int i;
 
         ENTER;
@@ -2220,7 +2892,7 @@ static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
 
         start_addr = readl(ioa_cfg->ioa_mailbox);
 
-        if (!ipr_sdt_is_fmt2(start_addr)) {
+        if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(start_addr)) {
                 dev_err(&ioa_cfg->pdev->dev,
                         "Invalid dump table format: %lx\n", start_addr);
                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
@@ -2249,7 +2921,6 @@ static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
 
         /* IOA Dump entry */
         ipr_init_dump_entry_hdr(&ioa_dump->hdr);
-        ioa_dump->format = IPR_SDT_FMT2;
         ioa_dump->hdr.len = 0;
         ioa_dump->hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
         ioa_dump->hdr.id = IPR_DUMP_IOA_DUMP_ID;
@@ -2264,7 +2935,8 @@ static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
                                         sizeof(struct ipr_sdt) / sizeof(__be32));
 
         /* Smart Dump table is ready to use and the first entry is valid */
-        if (rc || (be32_to_cpu(sdt->hdr.state) != IPR_FMT2_SDT_READY_TO_USE)) {
+        if (rc || ((be32_to_cpu(sdt->hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
+            (be32_to_cpu(sdt->hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
                 dev_err(&ioa_cfg->pdev->dev,
                         "Dump of IOA failed. Dump table not valid: %d, %X.\n",
                         rc, be32_to_cpu(sdt->hdr.state));
@@ -2288,12 +2960,19 @@ static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
                 }
 
                 if (sdt->entry[i].flags & IPR_SDT_VALID_ENTRY) {
-                        sdt_word = be32_to_cpu(sdt->entry[i].bar_str_offset);
-                        start_off = sdt_word & IPR_FMT2_MBX_ADDR_MASK;
-                        end_off = be32_to_cpu(sdt->entry[i].end_offset);
-
-                        if (ipr_sdt_is_fmt2(sdt_word) && sdt_word) {
-                                bytes_to_copy = end_off - start_off;
+                        sdt_word = be32_to_cpu(sdt->entry[i].start_token);
+                        if (ioa_cfg->sis64)
+                                bytes_to_copy = be32_to_cpu(sdt->entry[i].end_token);
+                        else {
+                                start_off = sdt_word & IPR_FMT2_MBX_ADDR_MASK;
+                                end_off = be32_to_cpu(sdt->entry[i].end_token);
+
+                                if (ipr_sdt_is_fmt2(sdt_word) && sdt_word)
+                                        bytes_to_copy = end_off - start_off;
+                                else
+                                        valid = 0;
+                        }
+                        if (valid) {
                                 if (bytes_to_copy > IPR_MAX_IOA_DUMP_SIZE) {
                                         sdt->entry[i].flags &= ~IPR_SDT_VALID_ENTRY;
                                         continue;
@@ -2422,9 +3101,9 @@ restart:
 
         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
                 if (res->add_to_ml) {
-                        bus = res->cfgte.res_addr.bus;
-                        target = res->cfgte.res_addr.target;
-                        lun = res->cfgte.res_addr.lun;
+                        bus = res->bus;
+                        target = res->target;
+                        lun = res->lun;
                         res->add_to_ml = 0;
                         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
                         scsi_add_device(ioa_cfg->host, bus, target, lun);
@@ -2478,105 +3157,6 @@ static struct bin_attribute ipr_trace_attr = {
 };
 #endif
 
-static const struct {
-        enum ipr_cache_state state;
-        char *name;
-} cache_state [] = {
-        { CACHE_NONE, "none" },
-        { CACHE_DISABLED, "disabled" },
-        { CACHE_ENABLED, "enabled" }
-};
-
-/**
- * ipr_show_write_caching - Show the write caching attribute
- * @dev:        device struct
- * @buf:        buffer
- *
- * Return value:
- *      number of bytes printed to buffer
- **/
-static ssize_t ipr_show_write_caching(struct device *dev,
-                                      struct device_attribute *attr, char *buf)
-{
-        struct Scsi_Host *shost = class_to_shost(dev);
-        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
-        unsigned long lock_flags = 0;
-        int i, len = 0;
-
-        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
-        for (i = 0; i < ARRAY_SIZE(cache_state); i++) {
-                if (cache_state[i].state == ioa_cfg->cache_state) {
-                        len = snprintf(buf, PAGE_SIZE, "%s\n", cache_state[i].name);
-                        break;
-                }
-        }
-        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-        return len;
-}
-
-
-/**
- * ipr_store_write_caching - Enable/disable adapter write cache
- * @dev:        device struct
- * @buf:        buffer
- * @count:      buffer size
- *
- * This function will enable/disable adapter write cache.
- *
- * Return value:
- *      count on success / other on failure
- **/
-static ssize_t ipr_store_write_caching(struct device *dev,
-                                       struct device_attribute *attr,
-                                       const char *buf, size_t count)
-{
-        struct Scsi_Host *shost = class_to_shost(dev);
-        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
-        unsigned long lock_flags = 0;
-        enum ipr_cache_state new_state = CACHE_INVALID;
-        int i;
-
-        if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
-        if (ioa_cfg->cache_state == CACHE_NONE)
-                return -EINVAL;
-
-        for (i = 0; i < ARRAY_SIZE(cache_state); i++) {
-                if (!strncmp(cache_state[i].name, buf, strlen(cache_state[i].name))) {
-                        new_state = cache_state[i].state;
-                        break;
-                }
-        }
-
-        if (new_state != CACHE_DISABLED && new_state != CACHE_ENABLED)
-                return -EINVAL;
-
-        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
-        if (ioa_cfg->cache_state == new_state) {
-                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-                return count;
-        }
-
-        ioa_cfg->cache_state = new_state;
-        dev_info(&ioa_cfg->pdev->dev, "%s adapter write cache.\n",
-                 new_state == CACHE_ENABLED ? "Enabling" : "Disabling");
-        if (!ioa_cfg->in_reset_reload)
-                ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
-        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-        wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
-
-        return count;
-}
-
-static struct device_attribute ipr_ioa_cache_attr = {
-        .attr = {
-                .name =         "write_cache",
-                .mode =         S_IRUGO | S_IWUSR,
-        },
-        .show = ipr_show_write_caching,
-        .store = ipr_store_write_caching
-};
-
 /**
  * ipr_show_fw_version - Show the firmware version
  * @dev:        class device struct
@@ -2976,6 +3556,37 @@ static int ipr_copy_ucode_buffer(struct ipr_sglist *sglist,
 }
 
 /**
+ * ipr_build_ucode_ioadl64 - Build a microcode download IOADL
+ * @ipr_cmd:            ipr command struct
+ * @sglist:             scatter/gather list
+ *
+ * Builds a microcode download IOA data list (IOADL).
+ *
+ **/
+static void ipr_build_ucode_ioadl64(struct ipr_cmnd *ipr_cmd,
+                                    struct ipr_sglist *sglist)
+{
+        struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
+        struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
+        struct scatterlist *scatterlist = sglist->scatterlist;
+        int i;
+
+        ipr_cmd->dma_use_sg = sglist->num_dma_sg;
+        ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
+        ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
+
+        ioarcb->ioadl_len =
+                cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
+        for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
+                ioadl64[i].flags = cpu_to_be32(IPR_IOADL_FLAGS_WRITE);
+                ioadl64[i].data_len = cpu_to_be32(sg_dma_len(&scatterlist[i]));
+                ioadl64[i].address = cpu_to_be64(sg_dma_address(&scatterlist[i]));
+        }
+
+        ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
+}
+
+/**
  * ipr_build_ucode_ioadl - Build a microcode download IOADL
  * @ipr_cmd:    ipr command struct
  * @sglist:             scatter/gather list
@@ -2987,14 +3598,15 @@ static void ipr_build_ucode_ioadl(struct ipr_cmnd *ipr_cmd,
                                   struct ipr_sglist *sglist)
 {
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
-        struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
+        struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
         struct scatterlist *scatterlist = sglist->scatterlist;
         int i;
 
         ipr_cmd->dma_use_sg = sglist->num_dma_sg;
         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
-        ioarcb->write_data_transfer_length = cpu_to_be32(sglist->buffer_len);
-        ioarcb->write_ioadl_len =
+        ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
+
+        ioarcb->ioadl_len =
                 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
 
         for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
@@ -3146,7 +3758,6 @@ static struct device_attribute *ipr_ioa_attrs[] = {
         &ipr_ioa_state_attr,
         &ipr_ioa_reset_attr,
         &ipr_update_fw_attr,
-        &ipr_ioa_cache_attr,
         NULL,
 };
 
@@ -3367,16 +3978,21 @@ static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; };
  * ipr_change_queue_depth - Change the device's queue depth
  * @sdev:       scsi device struct
  * @qdepth:     depth to set
+ * @reason:     calling context
  *
  * Return value:
  *      actual depth set
  **/
-static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth)
+static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth,
+                                  int reason)
 {
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
         struct ipr_resource_entry *res;
         unsigned long lock_flags = 0;
 
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
         res = (struct ipr_resource_entry *)sdev->hostdata;
 
@@ -3445,7 +4061,7 @@ static ssize_t ipr_show_adapter_handle(struct device *dev, struct device_attribu
         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
         res = (struct ipr_resource_entry *)sdev->hostdata;
         if (res)
-                len = snprintf(buf, PAGE_SIZE, "%08X\n", res->cfgte.res_handle);
+                len = snprintf(buf, PAGE_SIZE, "%08X\n", res->res_handle);
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
         return len;
 }
@@ -3458,8 +4074,43 @@ static struct device_attribute ipr_adapter_handle_attr = {
         .show = ipr_show_adapter_handle
 };
 
+/**
+ * ipr_show_resource_path - Show the resource path for this device.
+ * @dev:        device struct
+ * @buf:        buffer
+ *
+ * Return value:
+ *      number of bytes printed to buffer
+ **/
+static ssize_t ipr_show_resource_path(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct scsi_device *sdev = to_scsi_device(dev);
+        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
+        struct ipr_resource_entry *res;
+        unsigned long lock_flags = 0;
+        ssize_t len = -ENXIO;
+        char buffer[IPR_MAX_RES_PATH_LENGTH];
+
+        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
+        res = (struct ipr_resource_entry *)sdev->hostdata;
+        if (res)
+                len = snprintf(buf, PAGE_SIZE, "%s\n",
+                               ipr_format_resource_path(&res->res_path[0], &buffer[0]));
+        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+        return len;
+}
+
+static struct device_attribute ipr_resource_path_attr = {
+        .attr = {
+                .name =         "resource_path",
+                .mode =         S_IRUSR,
+        },
+        .show = ipr_show_resource_path
+};
+
 static struct device_attribute *ipr_dev_attrs[] = {
         &ipr_adapter_handle_attr,
+        &ipr_resource_path_attr,
         NULL,
 };
 
@@ -3512,9 +4163,9 @@ static struct ipr_resource_entry *ipr_find_starget(struct scsi_target *starget)
         struct ipr_resource_entry *res;
 
         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
-                if ((res->cfgte.res_addr.bus == starget->channel) &&
-                    (res->cfgte.res_addr.target == starget->id) &&
-                    (res->cfgte.res_addr.lun == 0)) {
+                if ((res->bus == starget->channel) &&
+                    (res->target == starget->id) &&
+                    (res->lun == 0)) {
                         return res;
                 }
         }
@@ -3584,6 +4235,17 @@ static int ipr_target_alloc(struct scsi_target *starget)
 static void ipr_target_destroy(struct scsi_target *starget)
 {
         struct ipr_sata_port *sata_port = starget->hostdata;
+        struct Scsi_Host *shost = dev_to_shost(&starget->dev);
+        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
+
+        if (ioa_cfg->sis64) {
+                if (starget->channel == IPR_ARRAY_VIRTUAL_BUS)
+                        clear_bit(starget->id, ioa_cfg->array_ids);
+                else if (starget->channel == IPR_VSET_VIRTUAL_BUS)
+                        clear_bit(starget->id, ioa_cfg->vset_ids);
+                else if (starget->channel == 0)
+                        clear_bit(starget->id, ioa_cfg->target_ids);
+        }
 
         if (sata_port) {
                 starget->hostdata = NULL;
@@ -3605,9 +4267,9 @@ static struct ipr_resource_entry *ipr_find_sdev(struct scsi_device *sdev)
         struct ipr_resource_entry *res;
 
         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
-                if ((res->cfgte.res_addr.bus == sdev->channel) &&
-                    (res->cfgte.res_addr.target == sdev->id) &&
-                    (res->cfgte.res_addr.lun == sdev->lun))
+                if ((res->bus == sdev->channel) &&
+                    (res->target == sdev->id) &&
+                    (res->lun == sdev->lun))
                         return res;
         }
 
@@ -3656,6 +4318,7 @@ static int ipr_slave_configure(struct scsi_device *sdev)
         struct ipr_resource_entry *res;
         struct ata_port *ap = NULL;
         unsigned long lock_flags = 0;
+        char buffer[IPR_MAX_RES_PATH_LENGTH];
 
         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
         res = sdev->hostdata;
@@ -3669,7 +4332,7 @@ static int ipr_slave_configure(struct scsi_device *sdev)
                 if (ipr_is_vset_device(res)) {
                         blk_queue_rq_timeout(sdev->request_queue,
                                              IPR_VSET_RW_TIMEOUT);
-                        blk_queue_max_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
+                        blk_queue_max_hw_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
                 }
                 if (ipr_is_vset_device(res) || ipr_is_scsi_disk(res))
                         sdev->allow_restart = 1;
@@ -3682,6 +4345,9 @@ static int ipr_slave_configure(struct scsi_device *sdev)
                         ata_sas_slave_configure(sdev, ap);
                 } else
                         scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
+                if (ioa_cfg->sis64)
+                        sdev_printk(KERN_INFO, sdev, "Resource path: %s\n",
+                                    ipr_format_resource_path(&res->res_path[0], &buffer[0]));
                 return 0;
         }
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
@@ -3823,14 +4489,19 @@ static int ipr_device_reset(struct ipr_ioa_cfg *ioa_cfg,
         ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
         ioarcb = &ipr_cmd->ioarcb;
         cmd_pkt = &ioarcb->cmd_pkt;
-        regs = &ioarcb->add_data.u.regs;
 
-        ioarcb->res_handle = res->cfgte.res_handle;
+        if (ipr_cmd->ioa_cfg->sis64) {
+                regs = &ipr_cmd->i.ata_ioadl.regs;
+                ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb));
+        } else
+                regs = &ioarcb->u.add_data.u.regs;
+
+        ioarcb->res_handle = res->res_handle;
         cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
         cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
         if (ipr_is_gata(res)) {
                 cmd_pkt->cdb[2] = IPR_ATA_PHY_RESET;
-                ioarcb->add_cmd_parms_len = cpu_to_be32(sizeof(regs->flags));
+                ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(regs->flags));
                 regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
         }
 
@@ -3875,19 +4546,7 @@ static int ipr_sata_reset(struct ata_link *link, unsigned int *classes,
         res = sata_port->res;
         if (res) {
                 rc = ipr_device_reset(ioa_cfg, res);
-                switch(res->cfgte.proto) {
-                case IPR_PROTO_SATA:
-                case IPR_PROTO_SAS_STP:
-                        *classes = ATA_DEV_ATA;
-                        break;
-                case IPR_PROTO_SATA_ATAPI:
-                case IPR_PROTO_SAS_STP_ATAPI:
-                        *classes = ATA_DEV_ATAPI;
-                        break;
-                default:
-                        *classes = ATA_DEV_UNKNOWN;
-                        break;
-                };
+                *classes = res->ata_class;
         }
 
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
@@ -3932,7 +4591,7 @@ static int __ipr_eh_dev_reset(struct scsi_cmnd * scsi_cmd)
                 return FAILED;
 
         list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
-                if (ipr_cmd->ioarcb.res_handle == res->cfgte.res_handle) {
+                if (ipr_cmd->ioarcb.res_handle == res->res_handle) {
                         if (ipr_cmd->scsi_cmd)
                                 ipr_cmd->done = ipr_scsi_eh_done;
                         if (ipr_cmd->qc)
@@ -3954,7 +4613,7 @@ static int __ipr_eh_dev_reset(struct scsi_cmnd * scsi_cmd)
                 spin_lock_irq(scsi_cmd->device->host->host_lock);
 
                 list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
-                        if (ipr_cmd->ioarcb.res_handle == res->cfgte.res_handle) {
+                        if (ipr_cmd->ioarcb.res_handle == res->res_handle) {
                                 rc = -EIO;
                                 break;
                         }
@@ -3993,13 +4652,13 @@ static void ipr_bus_reset_done(struct ipr_cmnd *ipr_cmd)
         struct ipr_resource_entry *res;
 
         ENTER;
-        list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
-                if (!memcmp(&res->cfgte.res_handle, &ipr_cmd->ioarcb.res_handle,
-                            sizeof(res->cfgte.res_handle))) {
-                        scsi_report_bus_reset(ioa_cfg->host, res->cfgte.res_addr.bus);
-                        break;
+        if (!ioa_cfg->sis64)
+                list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
+                        if (res->res_handle == ipr_cmd->ioarcb.res_handle) {
+                                scsi_report_bus_reset(ioa_cfg->host, res->bus);
+                                break;
+                        }
                 }
-        }
 
         /*
          * If abort has not completed, indicate the reset has, else call the
@@ -4097,7 +4756,7 @@ static int ipr_cancel_op(struct scsi_cmnd * scsi_cmd)
                 return SUCCESS;
 
         ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
-        ipr_cmd->ioarcb.res_handle = res->cfgte.res_handle;
+        ipr_cmd->ioarcb.res_handle = res->res_handle;
         cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
         cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
         cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
@@ -4234,11 +4893,29 @@ static irqreturn_t ipr_isr(int irq, void *devp)
                 return IRQ_NONE;
         }
 
-        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
-        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
+        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 */
+        /* 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;
         }
@@ -4281,8 +4958,8 @@ static irqreturn_t ipr_isr(int irq, void *devp)
                 if (ipr_cmd != NULL) {
                         /* Clear the PCI interrupt */
                         do {
-                                writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg);
-                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
+                                writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg32);
+                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32) & ~int_mask_reg;
                         } while (int_reg & IPR_PCII_HRRQ_UPDATED &&
                                         num_hrrq++ < IPR_MAX_HRRQ_RETRIES);
 
@@ -4304,6 +4981,53 @@ static irqreturn_t ipr_isr(int irq, void *devp)
 }
 
 /**
+ * ipr_build_ioadl64 - Build a scatter/gather list and map the buffer
+ * @ioa_cfg:    ioa config struct
+ * @ipr_cmd:    ipr command struct
+ *
+ * Return value:
+ *      0 on success / -1 on failure
+ **/
+static int ipr_build_ioadl64(struct ipr_ioa_cfg *ioa_cfg,
+                             struct ipr_cmnd *ipr_cmd)
+{
+        int i, nseg;
+        struct scatterlist *sg;
+        u32 length;
+        u32 ioadl_flags = 0;
+        struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
+        struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
+        struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
+
+        length = scsi_bufflen(scsi_cmd);
+        if (!length)
+                return 0;
+
+        nseg = scsi_dma_map(scsi_cmd);
+        if (nseg < 0) {
+                dev_err(&ioa_cfg->pdev->dev, "pci_map_sg failed!\n");
+                return -1;
+        }
+
+        ipr_cmd->dma_use_sg = nseg;
+
+        if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
+                ioadl_flags = IPR_IOADL_FLAGS_WRITE;
+                ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
+        } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE)
+                ioadl_flags = IPR_IOADL_FLAGS_READ;
+
+        scsi_for_each_sg(scsi_cmd, sg, ipr_cmd->dma_use_sg, i) {
+                ioadl64[i].flags = cpu_to_be32(ioadl_flags);
+                ioadl64[i].data_len = cpu_to_be32(sg_dma_len(sg));
+                ioadl64[i].address = cpu_to_be64(sg_dma_address(sg));
+        }
+
+        ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
+        return 0;
+}
+
+/**
  * ipr_build_ioadl - Build a scatter/gather list and map the buffer
  * @ioa_cfg:    ioa config struct
  * @ipr_cmd:    ipr command struct
@@ -4320,7 +5044,7 @@ static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg,
         u32 ioadl_flags = 0;
         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
-        struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
+        struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
 
         length = scsi_bufflen(scsi_cmd);
         if (!length)
@@ -4337,8 +5061,8 @@ static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg,
         if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
                 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
-                ioarcb->write_data_transfer_length = cpu_to_be32(length);
-                ioarcb->write_ioadl_len =
+                ioarcb->data_transfer_length = cpu_to_be32(length);
+                ioarcb->ioadl_len =
                         cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
         } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE) {
                 ioadl_flags = IPR_IOADL_FLAGS_READ;
@@ -4347,11 +5071,10 @@ static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg,
                         cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
         }
 
-        if (ipr_cmd->dma_use_sg <= ARRAY_SIZE(ioarcb->add_data.u.ioadl)) {
-                ioadl = ioarcb->add_data.u.ioadl;
-                ioarcb->write_ioadl_addr =
-                        cpu_to_be32(be32_to_cpu(ioarcb->ioarcb_host_pci_addr) +
-                                    offsetof(struct ipr_ioarcb, add_data));
+        if (ipr_cmd->dma_use_sg <= ARRAY_SIZE(ioarcb->u.add_data.u.ioadl)) {
+                ioadl = ioarcb->u.add_data.u.ioadl;
+                ioarcb->write_ioadl_addr = cpu_to_be32((ipr_cmd->dma_addr) +
+                                    offsetof(struct ipr_ioarcb, u.add_data));
                 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
         }
 
@@ -4441,18 +5164,24 @@ static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
         struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
-        dma_addr_t dma_addr = be32_to_cpu(ioarcb->ioarcb_host_pci_addr);
+        dma_addr_t dma_addr = ipr_cmd->dma_addr;
 
         memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
-        ioarcb->write_data_transfer_length = 0;
+        ioarcb->data_transfer_length = 0;
         ioarcb->read_data_transfer_length = 0;
-        ioarcb->write_ioadl_len = 0;
+        ioarcb->ioadl_len = 0;
         ioarcb->read_ioadl_len = 0;
         ioasa->ioasc = 0;
         ioasa->residual_data_len = 0;
-        ioarcb->write_ioadl_addr =
-                cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, ioadl));
-        ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
+
+        if (ipr_cmd->ioa_cfg->sis64)
+                ioarcb->u.sis64_addr_data.data_ioadl_addr =
+                        cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
+        else {
+                ioarcb->write_ioadl_addr =
+                        cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
+                ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
+        }
 }
 
 /**
@@ -4484,15 +5213,8 @@ static void ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
         cmd_pkt->flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
         cmd_pkt->timeout = cpu_to_be16(IPR_REQUEST_SENSE_TIMEOUT / HZ);
 
-        ipr_cmd->ioadl[0].flags_and_data_len =
-                cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | SCSI_SENSE_BUFFERSIZE);
-        ipr_cmd->ioadl[0].address =
-                cpu_to_be32(ipr_cmd->sense_buffer_dma);
-
-        ipr_cmd->ioarcb.read_ioadl_len =
-                cpu_to_be32(sizeof(struct ipr_ioadl_desc));
-        ipr_cmd->ioarcb.read_data_transfer_length =
-                cpu_to_be32(SCSI_SENSE_BUFFERSIZE);
+        ipr_init_ioadl(ipr_cmd, ipr_cmd->sense_buffer_dma,
+                       SCSI_SENSE_BUFFERSIZE, IPR_IOADL_FLAGS_READ_LAST);
 
         ipr_do_req(ipr_cmd, ipr_erp_done, ipr_timeout,
                    IPR_REQUEST_SENSE_TIMEOUT * 2);
@@ -4888,9 +5610,9 @@ static int ipr_queuecommand(struct scsi_cmnd *scsi_cmd,
 
         memcpy(ioarcb->cmd_pkt.cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len);
         ipr_cmd->scsi_cmd = scsi_cmd;
-        ioarcb->res_handle = res->cfgte.res_handle;
+        ioarcb->res_handle = res->res_handle;
         ipr_cmd->done = ipr_scsi_done;
-        ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_PHYS_LOC(res->cfgte.res_addr));
+        ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_RES_PHYS_LOC(res));
 
         if (ipr_is_gscsi(res) || ipr_is_vset_device(res)) {
                 if (scsi_cmd->underflow == 0)
@@ -4911,13 +5633,16 @@ static int ipr_queuecommand(struct scsi_cmnd *scsi_cmd,
             (!ipr_is_gscsi(res) || scsi_cmd->cmnd[0] == IPR_QUERY_RSRC_STATE))
                 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
 
-        if (likely(rc == 0))
-                rc = ipr_build_ioadl(ioa_cfg, ipr_cmd);
+        if (likely(rc == 0)) {
+                if (ioa_cfg->sis64)
+                        rc = ipr_build_ioadl64(ioa_cfg, ipr_cmd);
+                else
+                        rc = ipr_build_ioadl(ioa_cfg, ipr_cmd);
+        }
 
         if (likely(rc == 0)) {
                 mb();
-                writel(be32_to_cpu(ipr_cmd->ioarcb.ioarcb_host_pci_addr),
-                       ioa_cfg->regs.ioarrin_reg);
+                ipr_send_command(ipr_cmd);
         } else {
                  list_move_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
                  return SCSI_MLQUEUE_HOST_BUSY;
@@ -5030,20 +5755,9 @@ static void ipr_ata_phy_reset(struct ata_port *ap)
                 goto out_unlock;
         }
 
-        switch(res->cfgte.proto) {
-        case IPR_PROTO_SATA:
-        case IPR_PROTO_SAS_STP:
-                ap->link.device[0].class = ATA_DEV_ATA;
-                break;
-        case IPR_PROTO_SATA_ATAPI:
-        case IPR_PROTO_SAS_STP_ATAPI:
-                ap->link.device[0].class = ATA_DEV_ATAPI;
-                break;
-        default:
-                ap->link.device[0].class = ATA_DEV_UNKNOWN;
+        ap->link.device[0].class = res->ata_class;
+        if (ap->link.device[0].class == ATA_DEV_UNKNOWN)
                 ata_port_disable(ap);
-                break;
-        };
 
 out_unlock:
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
@@ -5129,8 +5843,7 @@ static void ipr_sata_done(struct ipr_cmnd *ipr_cmd)
         ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
 
         if (be32_to_cpu(ipr_cmd->ioasa.ioasc_specific) & IPR_ATA_DEVICE_WAS_RESET)
-                scsi_report_device_reset(ioa_cfg->host, res->cfgte.res_addr.bus,
-                                         res->cfgte.res_addr.target);
+                scsi_report_device_reset(ioa_cfg->host, res->bus, res->target);
 
         if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
                 qc->err_mask |= __ac_err_mask(ipr_cmd->ioasa.u.gata.status);
@@ -5141,6 +5854,52 @@ static void ipr_sata_done(struct ipr_cmnd *ipr_cmd)
 }
 
 /**
+ * ipr_build_ata_ioadl64 - Build an ATA scatter/gather list
+ * @ipr_cmd:    ipr command struct
+ * @qc:         ATA queued command
+ *
+ **/
+static void ipr_build_ata_ioadl64(struct ipr_cmnd *ipr_cmd,
+                                  struct ata_queued_cmd *qc)
+{
+        u32 ioadl_flags = 0;
+        struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
+        struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
+        struct ipr_ioadl64_desc *last_ioadl64 = NULL;
+        int len = qc->nbytes;
+        struct scatterlist *sg;
+        unsigned int si;
+        dma_addr_t dma_addr = ipr_cmd->dma_addr;
+
+        if (len == 0)
+                return;
+
+        if (qc->dma_dir == DMA_TO_DEVICE) {
+                ioadl_flags = IPR_IOADL_FLAGS_WRITE;
+                ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
+        } else if (qc->dma_dir == DMA_FROM_DEVICE)
+                ioadl_flags = IPR_IOADL_FLAGS_READ;
+
+        ioarcb->data_transfer_length = cpu_to_be32(len);
+        ioarcb->ioadl_len =
+                cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
+        ioarcb->u.sis64_addr_data.data_ioadl_addr =
+                cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ata_ioadl));
+
+        for_each_sg(qc->sg, sg, qc->n_elem, si) {
+                ioadl64->flags = cpu_to_be32(ioadl_flags);
+                ioadl64->data_len = cpu_to_be32(sg_dma_len(sg));
+                ioadl64->address = cpu_to_be64(sg_dma_address(sg));
+
+                last_ioadl64 = ioadl64;
+                ioadl64++;
+        }
+
+        if (likely(last_ioadl64))
+                last_ioadl64->flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
+}
+
+/**
  * ipr_build_ata_ioadl - Build an ATA scatter/gather list
  * @ipr_cmd:    ipr command struct
  * @qc:         ATA queued command
@@ -5151,7 +5910,7 @@ static void ipr_build_ata_ioadl(struct ipr_cmnd *ipr_cmd,
 {
         u32 ioadl_flags = 0;
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
-        struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
+        struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
         struct ipr_ioadl_desc *last_ioadl = NULL;
         int len = qc->nbytes;
         struct scatterlist *sg;
@@ -5163,8 +5922,8 @@ static void ipr_build_ata_ioadl(struct ipr_cmnd *ipr_cmd,
         if (qc->dma_dir == DMA_TO_DEVICE) {
                 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
-                ioarcb->write_data_transfer_length = cpu_to_be32(len);
-                ioarcb->write_ioadl_len =
+                ioarcb->data_transfer_length = cpu_to_be32(len);
+                ioarcb->ioadl_len =
                         cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
         } else if (qc->dma_dir == DMA_FROM_DEVICE) {
                 ioadl_flags = IPR_IOADL_FLAGS_READ;
@@ -5207,25 +5966,34 @@ static unsigned int ipr_qc_issue(struct ata_queued_cmd *qc)
 
         ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
         ioarcb = &ipr_cmd->ioarcb;
-        regs = &ioarcb->add_data.u.regs;
 
-        memset(&ioarcb->add_data, 0, sizeof(ioarcb->add_data));
-        ioarcb->add_cmd_parms_len = cpu_to_be32(sizeof(ioarcb->add_data.u.regs));
+        if (ioa_cfg->sis64) {
+                regs = &ipr_cmd->i.ata_ioadl.regs;
+                ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb));
+        } else
+                regs = &ioarcb->u.add_data.u.regs;
+
+        memset(regs, 0, sizeof(*regs));
+        ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(*regs));
 
         list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
         ipr_cmd->qc = qc;
         ipr_cmd->done = ipr_sata_done;
-        ipr_cmd->ioarcb.res_handle = res->cfgte.res_handle;
+        ipr_cmd->ioarcb.res_handle = res->res_handle;
         ioarcb->cmd_pkt.request_type = IPR_RQTYPE_ATA_PASSTHRU;
         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
         ipr_cmd->dma_use_sg = qc->n_elem;
 
-        ipr_build_ata_ioadl(ipr_cmd, qc);
+        if (ioa_cfg->sis64)
+                ipr_build_ata_ioadl64(ipr_cmd, qc);
+        else
+                ipr_build_ata_ioadl(ipr_cmd, qc);
+
         regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
         ipr_copy_sata_tf(regs, &qc->tf);
         memcpy(ioarcb->cmd_pkt.cdb, qc->cdb, IPR_MAX_CDB_LEN);
-        ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_PHYS_LOC(res->cfgte.res_addr));
+        ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_RES_PHYS_LOC(res));
 
         switch (qc->tf.protocol) {
         case ATA_PROT_NODATA:
@@ -5252,8 +6020,9 @@ static unsigned int ipr_qc_issue(struct ata_queued_cmd *qc)
         }
 
         mb();
-        writel(be32_to_cpu(ioarcb->ioarcb_host_pci_addr),
-               ioa_cfg->regs.ioarrin_reg);
+
+        ipr_send_command(ipr_cmd);
+
         return 0;
 }
 
@@ -5454,7 +6223,7 @@ static void ipr_set_sup_dev_dflt(struct ipr_supported_device *supported_dev,
  * ipr_set_supported_devs - Send Set Supported Devices for a device
  * @ipr_cmd:    ipr command struct
  *
- * This function send a Set Supported Devices to the adapter
+ * This function sends a Set Supported Devices to the adapter
  *
  * Return value:
  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
@@ -5463,7 +6232,6 @@ static int ipr_set_supported_devs(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
         struct ipr_supported_device *supp_dev = &ioa_cfg->vpd_cbs->supp_dev;
-        struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
         struct ipr_resource_entry *res = ipr_cmd->u.res;
 
@@ -5474,28 +6242,28 @@ static int ipr_set_supported_devs(struct ipr_cmnd *ipr_cmd)
                         continue;
 
                 ipr_cmd->u.res = res;
-                ipr_set_sup_dev_dflt(supp_dev, &res->cfgte.std_inq_data.vpids);
+                ipr_set_sup_dev_dflt(supp_dev, &res->std_inq_data.vpids);
 
                 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
                 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
 
                 ioarcb->cmd_pkt.cdb[0] = IPR_SET_SUPPORTED_DEVICES;
+                ioarcb->cmd_pkt.cdb[1] = IPR_SET_ALL_SUPPORTED_DEVICES;
                 ioarcb->cmd_pkt.cdb[7] = (sizeof(struct ipr_supported_device) >> 8) & 0xff;
                 ioarcb->cmd_pkt.cdb[8] = sizeof(struct ipr_supported_device) & 0xff;
 
-                ioadl->flags_and_data_len = cpu_to_be32(IPR_IOADL_FLAGS_WRITE_LAST |
-                                                        sizeof(struct ipr_supported_device));
-                ioadl->address = cpu_to_be32(ioa_cfg->vpd_cbs_dma +
-                                             offsetof(struct ipr_misc_cbs, supp_dev));
-                ioarcb->write_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
-                ioarcb->write_data_transfer_length =
-                        cpu_to_be32(sizeof(struct ipr_supported_device));
+                ipr_init_ioadl(ipr_cmd,
+                               ioa_cfg->vpd_cbs_dma +
+                                 offsetof(struct ipr_misc_cbs, supp_dev),
+                               sizeof(struct ipr_supported_device),
+                               IPR_IOADL_FLAGS_WRITE_LAST);
 
                 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
                            IPR_SET_SUP_DEVICE_TIMEOUT);
 
-                ipr_cmd->job_step = ipr_set_supported_devs;
+                if (!ioa_cfg->sis64)
+                        ipr_cmd->job_step = ipr_set_supported_devs;
                 return IPR_RC_JOB_RETURN;
         }
 
@@ -5503,36 +6271,6 @@ static int ipr_set_supported_devs(struct ipr_cmnd *ipr_cmd)
 }
 
 /**
- * ipr_setup_write_cache - Disable write cache if needed
- * @ipr_cmd:    ipr command struct
- *
- * This function sets up adapters write cache to desired setting
- *
- * Return value:
- *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
- **/
-static int ipr_setup_write_cache(struct ipr_cmnd *ipr_cmd)
-{
-        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
-
-        ipr_cmd->job_step = ipr_set_supported_devs;
-        ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
-                                    struct ipr_resource_entry, queue);
-
-        if (ioa_cfg->cache_state != CACHE_DISABLED)
-                return IPR_RC_JOB_CONTINUE;
-
-        ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
-        ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
-        ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
-        ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_SHUTDOWN_PREPARE_FOR_NORMAL;
-
-        ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
-
-        return IPR_RC_JOB_RETURN;
-}
-
-/**
  * ipr_get_mode_page - Locate specified mode page
  * @mode_pages: mode page buffer
  * @page_code:  page code to find
@@ -5690,10 +6428,9 @@ static void ipr_modify_ioafp_mode_page_28(struct ipr_ioa_cfg *ioa_cfg,
  *      none
  **/
 static void ipr_build_mode_select(struct ipr_cmnd *ipr_cmd,
-                                  __be32 res_handle, u8 parm, u32 dma_addr,
-                                  u8 xfer_len)
+                                  __be32 res_handle, u8 parm,
+                                  dma_addr_t dma_addr, u8 xfer_len)
 {
-        struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
 
         ioarcb->res_handle = res_handle;
@@ -5703,11 +6440,7 @@ static void ipr_build_mode_select(struct ipr_cmnd *ipr_cmd,
         ioarcb->cmd_pkt.cdb[1] = parm;
         ioarcb->cmd_pkt.cdb[4] = xfer_len;
 
-        ioadl->flags_and_data_len =
-                cpu_to_be32(IPR_IOADL_FLAGS_WRITE_LAST | xfer_len);
-        ioadl->address = cpu_to_be32(dma_addr);
-        ioarcb->write_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
-        ioarcb->write_data_transfer_length = cpu_to_be32(xfer_len);
+        ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_WRITE_LAST);
 }
 
 /**
@@ -5737,7 +6470,9 @@ static int ipr_ioafp_mode_select_page28(struct ipr_cmnd *ipr_cmd)
                               ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
                               length);
 
-        ipr_cmd->job_step = ipr_setup_write_cache;
+        ipr_cmd->job_step = ipr_set_supported_devs;
+        ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
+                                    struct ipr_resource_entry, queue);
         ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
 
         LEAVE;
@@ -5757,9 +6492,8 @@ static int ipr_ioafp_mode_select_page28(struct ipr_cmnd *ipr_cmd)
  **/
 static void ipr_build_mode_sense(struct ipr_cmnd *ipr_cmd,
                                  __be32 res_handle,
-                                 u8 parm, u32 dma_addr, u8 xfer_len)
+                                 u8 parm, dma_addr_t dma_addr, u8 xfer_len)
 {
-        struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
 
         ioarcb->res_handle = res_handle;
@@ -5768,11 +6502,7 @@ static void ipr_build_mode_sense(struct ipr_cmnd *ipr_cmd,
         ioarcb->cmd_pkt.cdb[4] = xfer_len;
         ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
 
-        ioadl->flags_and_data_len =
-                cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | xfer_len);
-        ioadl->address = cpu_to_be32(dma_addr);
-        ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
-        ioarcb->read_data_transfer_length = cpu_to_be32(xfer_len);
+        ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_READ_LAST);
 }
 
 /**
@@ -5810,10 +6540,13 @@ static int ipr_reset_cmd_failed(struct ipr_cmnd *ipr_cmd)
  **/
 static int ipr_reset_mode_sense_failed(struct ipr_cmnd *ipr_cmd)
 {
+        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
         u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
 
         if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
-                ipr_cmd->job_step = ipr_setup_write_cache;
+                ipr_cmd->job_step = ipr_set_supported_devs;
+                ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
+                                            struct ipr_resource_entry, queue);
                 return IPR_RC_JOB_CONTINUE;
         }
 
@@ -5953,24 +6686,36 @@ static int ipr_init_res_table(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
         struct ipr_resource_entry *res, *temp;
-        struct ipr_config_table_entry *cfgte;
-        int found, i;
+        struct ipr_config_table_entry_wrapper cfgtew;
+        int entries, found, flag, i;
         LIST_HEAD(old_res);
 
         ENTER;
-        if (ioa_cfg->cfg_table->hdr.flags & IPR_UCODE_DOWNLOAD_REQ)
+        if (ioa_cfg->sis64)
+                flag = ioa_cfg->u.cfg_table64->hdr64.flags;
+        else
+                flag = ioa_cfg->u.cfg_table->hdr.flags;
+
+        if (flag & IPR_UCODE_DOWNLOAD_REQ)
                 dev_err(&ioa_cfg->pdev->dev, "Microcode download required\n");
 
         list_for_each_entry_safe(res, temp, &ioa_cfg->used_res_q, queue)
                 list_move_tail(&res->queue, &old_res);
 
-        for (i = 0; i < ioa_cfg->cfg_table->hdr.num_entries; i++) {
-                cfgte = &ioa_cfg->cfg_table->dev[i];
+        if (ioa_cfg->sis64)
+                entries = ioa_cfg->u.cfg_table64->hdr64.num_entries;
+        else
+                entries = ioa_cfg->u.cfg_table->hdr.num_entries;
+
+        for (i = 0; i < entries; i++) {
+                if (ioa_cfg->sis64)
+                        cfgtew.u.cfgte64 = &ioa_cfg->u.cfg_table64->dev[i];
+                else
+                        cfgtew.u.cfgte = &ioa_cfg->u.cfg_table->dev[i];
                 found = 0;
 
                 list_for_each_entry_safe(res, temp, &old_res, queue) {
-                        if (!memcmp(&res->cfgte.res_addr,
-                                    &cfgte->res_addr, sizeof(cfgte->res_addr))) {
+                        if (ipr_is_same_device(res, &cfgtew)) {
                                 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
                                 found = 1;
                                 break;
@@ -5987,24 +6732,27 @@ static int ipr_init_res_table(struct ipr_cmnd *ipr_cmd)
                         res = list_entry(ioa_cfg->free_res_q.next,
                                          struct ipr_resource_entry, queue);
                         list_move_tail(&res->queue, &ioa_cfg->used_res_q);
-                        ipr_init_res_entry(res);
+                        ipr_init_res_entry(res, &cfgtew);
                         res->add_to_ml = 1;
                 }
 
                 if (found)
-                        memcpy(&res->cfgte, cfgte, sizeof(struct ipr_config_table_entry));
+                        ipr_update_res_entry(res, &cfgtew);
         }
 
         list_for_each_entry_safe(res, temp, &old_res, queue) {
                 if (res->sdev) {
                         res->del_from_ml = 1;
-                        res->cfgte.res_handle = IPR_INVALID_RES_HANDLE;
+                        res->res_handle = IPR_INVALID_RES_HANDLE;
                         list_move_tail(&res->queue, &ioa_cfg->used_res_q);
-                } else {
-                        list_move_tail(&res->queue, &ioa_cfg->free_res_q);
                 }
         }
 
+        list_for_each_entry_safe(res, temp, &old_res, queue) {
+                ipr_clear_res_target(res);
+                list_move_tail(&res->queue, &ioa_cfg->free_res_q);
+        }
+
         if (ioa_cfg->dual_raid && ipr_dual_ioa_raid)
                 ipr_cmd->job_step = ipr_ioafp_mode_sense_page24;
         else
@@ -6028,7 +6776,6 @@ static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
-        struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
         struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
         struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap;
 
@@ -6042,16 +6789,11 @@ static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd *ipr_cmd)
         ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
 
         ioarcb->cmd_pkt.cdb[0] = IPR_QUERY_IOA_CONFIG;
-        ioarcb->cmd_pkt.cdb[7] = (sizeof(struct ipr_config_table) >> 8) & 0xff;
-        ioarcb->cmd_pkt.cdb[8] = sizeof(struct ipr_config_table) & 0xff;
+        ioarcb->cmd_pkt.cdb[7] = (ioa_cfg->cfg_table_size >> 8) & 0xff;
+        ioarcb->cmd_pkt.cdb[8] = ioa_cfg->cfg_table_size & 0xff;
 
-        ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
-        ioarcb->read_data_transfer_length =
-                cpu_to_be32(sizeof(struct ipr_config_table));
-
-        ioadl->address = cpu_to_be32(ioa_cfg->cfg_table_dma);
-        ioadl->flags_and_data_len =
-                cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | sizeof(struct ipr_config_table));
+        ipr_init_ioadl(ipr_cmd, ioa_cfg->cfg_table_dma, ioa_cfg->cfg_table_size,
+                       IPR_IOADL_FLAGS_READ_LAST);
 
         ipr_cmd->job_step = ipr_init_res_table;
 
@@ -6071,10 +6813,9 @@ static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd *ipr_cmd)
  *      none
  **/
 static void ipr_ioafp_inquiry(struct ipr_cmnd *ipr_cmd, u8 flags, u8 page,
-                              u32 dma_addr, u8 xfer_len)
+                              dma_addr_t dma_addr, u8 xfer_len)
 {
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
-        struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
 
         ENTER;
         ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
@@ -6085,12 +6826,7 @@ static void ipr_ioafp_inquiry(struct ipr_cmnd *ipr_cmd, u8 flags, u8 page,
         ioarcb->cmd_pkt.cdb[2] = page;
         ioarcb->cmd_pkt.cdb[4] = xfer_len;
 
-        ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
-        ioarcb->read_data_transfer_length = cpu_to_be32(xfer_len);
-
-        ioadl->address = cpu_to_be32(dma_addr);
-        ioadl->flags_and_data_len =
-                cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | xfer_len);
+        ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_READ_LAST);
 
         ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
         LEAVE;
@@ -6161,13 +6897,9 @@ static int ipr_ioafp_cap_inquiry(struct ipr_cmnd *ipr_cmd)
 static int ipr_ioafp_page3_inquiry(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
-        struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data;
 
         ENTER;
 
-        if (!ipr_inquiry_page_supported(page0, 1))
-                ioa_cfg->cache_state = CACHE_NONE;
-
         ipr_cmd->job_step = ipr_ioafp_cap_inquiry;
 
         ipr_ioafp_inquiry(ipr_cmd, 1, 3,
@@ -6235,7 +6967,7 @@ static int ipr_ioafp_std_inquiry(struct ipr_cmnd *ipr_cmd)
 }
 
 /**
- * ipr_ioafp_indentify_hrrq - Send Identify Host RRQ.
+ * ipr_ioafp_identify_hrrq - Send Identify Host RRQ.
  * @ipr_cmd:    ipr command struct
  *
  * This function send an Identify Host Request Response Queue
@@ -6244,7 +6976,7 @@ static int ipr_ioafp_std_inquiry(struct ipr_cmnd *ipr_cmd)
  * Return value:
  *      IPR_RC_JOB_RETURN
  **/
-static int ipr_ioafp_indentify_hrrq(struct ipr_cmnd *ipr_cmd)
+static int ipr_ioafp_identify_hrrq(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
@@ -6256,19 +6988,32 @@ static int ipr_ioafp_indentify_hrrq(struct ipr_cmnd *ipr_cmd)
         ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
 
         ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
+        if (ioa_cfg->sis64)
+                ioarcb->cmd_pkt.cdb[1] = 0x1;
         ioarcb->cmd_pkt.cdb[2] =
-                ((u32) ioa_cfg->host_rrq_dma >> 24) & 0xff;
+                ((u64) ioa_cfg->host_rrq_dma >> 24) & 0xff;
         ioarcb->cmd_pkt.cdb[3] =
-                ((u32) ioa_cfg->host_rrq_dma >> 16) & 0xff;
+                ((u64) ioa_cfg->host_rrq_dma >> 16) & 0xff;
         ioarcb->cmd_pkt.cdb[4] =
-                ((u32) ioa_cfg->host_rrq_dma >> 8) & 0xff;
+                ((u64) ioa_cfg->host_rrq_dma >> 8) & 0xff;
         ioarcb->cmd_pkt.cdb[5] =
-                ((u32) ioa_cfg->host_rrq_dma) & 0xff;
+                ((u64) ioa_cfg->host_rrq_dma) & 0xff;
         ioarcb->cmd_pkt.cdb[7] =
                 ((sizeof(u32) * IPR_NUM_CMD_BLKS) >> 8) & 0xff;
         ioarcb->cmd_pkt.cdb[8] =
                 (sizeof(u32) * IPR_NUM_CMD_BLKS) & 0xff;
 
+        if (ioa_cfg->sis64) {
+                ioarcb->cmd_pkt.cdb[10] =
+                        ((u64) ioa_cfg->host_rrq_dma >> 56) & 0xff;
+                ioarcb->cmd_pkt.cdb[11] =
+                        ((u64) ioa_cfg->host_rrq_dma >> 48) & 0xff;
+                ioarcb->cmd_pkt.cdb[12] =
+                        ((u64) ioa_cfg->host_rrq_dma >> 40) & 0xff;
+                ioarcb->cmd_pkt.cdb[13] =
+                        ((u64) ioa_cfg->host_rrq_dma >> 32) & 0xff;
+        }
+
         ipr_cmd->job_step = ipr_ioafp_std_inquiry;
 
         ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
@@ -6349,7 +7094,58 @@ static void ipr_init_ioa_mem(struct ipr_ioa_cfg *ioa_cfg)
         ioa_cfg->toggle_bit = 1;
 
         /* Zero out config table */
-        memset(ioa_cfg->cfg_table, 0, sizeof(struct ipr_config_table));
+        memset(ioa_cfg->u.cfg_table, 0, ioa_cfg->cfg_table_size);
+}
+
+/**
+ * ipr_reset_next_stage - Process IPL stage change based on feedback register.
+ * @ipr_cmd:    ipr command struct
+ *
+ * Return value:
+ *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
+ **/
+static int ipr_reset_next_stage(struct ipr_cmnd *ipr_cmd)
+{
+        unsigned long stage, stage_time;
+        u32 feedback;
+        volatile u32 int_reg;
+        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
+        u64 maskval = 0;
+
+        feedback = readl(ioa_cfg->regs.init_feedback_reg);
+        stage = feedback & IPR_IPL_INIT_STAGE_MASK;
+        stage_time = feedback & IPR_IPL_INIT_STAGE_TIME_MASK;
+
+        ipr_dbg("IPL stage = 0x%lx, IPL stage time = %ld\n", stage, stage_time);
+
+        /* sanity check the stage_time value */
+        if (stage_time < IPR_IPL_INIT_MIN_STAGE_TIME)
+                stage_time = IPR_IPL_INIT_MIN_STAGE_TIME;
+        else if (stage_time > IPR_LONG_OPERATIONAL_TIMEOUT)
+                stage_time = IPR_LONG_OPERATIONAL_TIMEOUT;
+
+        if (stage == IPR_IPL_INIT_STAGE_UNKNOWN) {
+                writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.set_interrupt_mask_reg);
+                int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
+                stage_time = ioa_cfg->transop_timeout;
+                ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
+        } else if (stage == IPR_IPL_INIT_STAGE_TRANSOP) {
+                ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
+                maskval = IPR_PCII_IPL_STAGE_CHANGE;
+                maskval = (maskval << 32) | IPR_PCII_IOA_TRANS_TO_OPER;
+                writeq(maskval, ioa_cfg->regs.set_interrupt_mask_reg);
+                int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
+                return IPR_RC_JOB_CONTINUE;
+        }
+
+        ipr_cmd->timer.data = (unsigned long) ipr_cmd;
+        ipr_cmd->timer.expires = jiffies + stage_time * HZ;
+        ipr_cmd->timer.function = (void (*)(unsigned long))ipr_oper_timeout;
+        ipr_cmd->done = ipr_reset_ioa_job;
+        add_timer(&ipr_cmd->timer);
+        list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
+
+        return IPR_RC_JOB_RETURN;
 }
 
 /**
@@ -6368,7 +7164,7 @@ static int ipr_reset_enable_ioa(struct ipr_cmnd *ipr_cmd)
         volatile u32 int_reg;
 
         ENTER;
-        ipr_cmd->job_step = ipr_ioafp_indentify_hrrq;
+        ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
         ipr_init_ioa_mem(ioa_cfg);
 
         ioa_cfg->allow_interrupts = 1;
@@ -6376,19 +7172,27 @@ static int ipr_reset_enable_ioa(struct ipr_cmnd *ipr_cmd)
 
         if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
                 writel((IPR_PCII_ERROR_INTERRUPTS | IPR_PCII_HRRQ_UPDATED),
-                       ioa_cfg->regs.clr_interrupt_mask_reg);
+                       ioa_cfg->regs.clr_interrupt_mask_reg32);
                 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
                 return IPR_RC_JOB_CONTINUE;
         }
 
         /* Enable destructive diagnostics on IOA */
-        writel(ioa_cfg->doorbell, ioa_cfg->regs.set_uproc_interrupt_reg);
+        writel(ioa_cfg->doorbell, ioa_cfg->regs.set_uproc_interrupt_reg32);
+
+        writel(IPR_PCII_OPER_INTERRUPTS, ioa_cfg->regs.clr_interrupt_mask_reg32);
+        if (ioa_cfg->sis64)
+                writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_mask_reg);
 
-        writel(IPR_PCII_OPER_INTERRUPTS, ioa_cfg->regs.clr_interrupt_mask_reg);
         int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
 
         dev_info(&ioa_cfg->pdev->dev, "Initializing IOA.\n");
 
+        if (ioa_cfg->sis64) {
+                ipr_cmd->job_step = ipr_reset_next_stage;
+                return IPR_RC_JOB_CONTINUE;
+        }
+
         ipr_cmd->timer.data = (unsigned long) ipr_cmd;
         ipr_cmd->timer.expires = jiffies + (ioa_cfg->transop_timeout * HZ);
         ipr_cmd->timer.function = (void (*)(unsigned long))ipr_oper_timeout;
@@ -6458,7 +7262,7 @@ static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg)
 
         mailbox = readl(ioa_cfg->ioa_mailbox);
 
-        if (!ipr_sdt_is_fmt2(mailbox)) {
+        if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(mailbox)) {
                 ipr_unit_check_no_data(ioa_cfg);
                 return;
         }
@@ -6467,15 +7271,20 @@ static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg)
         rc = ipr_get_ldump_data_section(ioa_cfg, mailbox, (__be32 *) &sdt,
                                         (sizeof(struct ipr_uc_sdt)) / sizeof(__be32));
 
-        if (rc || (be32_to_cpu(sdt.hdr.state) != IPR_FMT2_SDT_READY_TO_USE) ||
-            !(sdt.entry[0].flags & IPR_SDT_VALID_ENTRY)) {
+        if (rc || !(sdt.entry[0].flags & IPR_SDT_VALID_ENTRY) ||
+            ((be32_to_cpu(sdt.hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
+            (be32_to_cpu(sdt.hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
                 ipr_unit_check_no_data(ioa_cfg);
                 return;
         }
 
         /* Find length of the first sdt entry (UC buffer) */
-        length = (be32_to_cpu(sdt.entry[0].end_offset) -
-                  be32_to_cpu(sdt.entry[0].bar_str_offset)) & IPR_FMT2_MBX_ADDR_MASK;
+        if (be32_to_cpu(sdt.hdr.state) == IPR_FMT3_SDT_READY_TO_USE)
+                length = be32_to_cpu(sdt.entry[0].end_token);
+        else
+                length = (be32_to_cpu(sdt.entry[0].end_token) -
+                          be32_to_cpu(sdt.entry[0].start_token)) &
+                          IPR_FMT2_MBX_ADDR_MASK;
 
         hostrcb = list_entry(ioa_cfg->hostrcb_free_q.next,
                              struct ipr_hostrcb, queue);
@@ -6483,13 +7292,13 @@ static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg)
         memset(&hostrcb->hcam, 0, sizeof(hostrcb->hcam));
 
         rc = ipr_get_ldump_data_section(ioa_cfg,
-                                        be32_to_cpu(sdt.entry[0].bar_str_offset),
+                                        be32_to_cpu(sdt.entry[0].start_token),
                                         (__be32 *)&hostrcb->hcam,
                                         min(length, (int)sizeof(hostrcb->hcam)) / sizeof(__be32));
 
         if (!rc) {
                 ipr_handle_log_data(ioa_cfg, hostrcb);
-                ioasc = be32_to_cpu(hostrcb->hcam.u.error.failing_dev_ioasc);
+                ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
                 if (ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED &&
                     ioa_cfg->sdt_state == GET_DUMP)
                         ioa_cfg->sdt_state = WAIT_FOR_DUMP;
@@ -6516,6 +7325,7 @@ static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
         int rc;
 
         ENTER;
+        ioa_cfg->pdev->state_saved = true;
         rc = pci_restore_state(ioa_cfg->pdev);
 
         if (rc != PCIBIOS_SUCCESSFUL) {
@@ -6716,7 +7526,7 @@ static int ipr_reset_alert(struct ipr_cmnd *ipr_cmd)
 
         if ((rc == PCIBIOS_SUCCESSFUL) && (cmd_reg & PCI_COMMAND_MEMORY)) {
                 ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
-                writel(IPR_UPROCI_RESET_ALERT, ioa_cfg->regs.set_uproc_interrupt_reg);
+                writel(IPR_UPROCI_RESET_ALERT, ioa_cfg->regs.set_uproc_interrupt_reg32);
                 ipr_cmd->job_step = ipr_reset_wait_to_start_bist;
         } else {
                 ipr_cmd->job_step = ioa_cfg->reset;
@@ -6779,7 +7589,10 @@ static int ipr_reset_ucode_download(struct ipr_cmnd *ipr_cmd)
         ipr_cmd->ioarcb.cmd_pkt.cdb[7] = (sglist->buffer_len & 0x00ff00) >> 8;
         ipr_cmd->ioarcb.cmd_pkt.cdb[8] = sglist->buffer_len & 0x0000ff;
 
-        ipr_build_ucode_ioadl(ipr_cmd, sglist);
+        if (ioa_cfg->sis64)
+                ipr_build_ucode_ioadl64(ipr_cmd, sglist);
+        else
+                ipr_build_ucode_ioadl(ipr_cmd, sglist);
         ipr_cmd->job_step = ipr_reset_ucode_download_done;
 
         ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
@@ -7148,8 +7961,8 @@ static void ipr_free_mem(struct ipr_ioa_cfg *ioa_cfg)
         ipr_free_cmd_blks(ioa_cfg);
         pci_free_consistent(ioa_cfg->pdev, sizeof(u32) * IPR_NUM_CMD_BLKS,
                             ioa_cfg->host_rrq, ioa_cfg->host_rrq_dma);
-        pci_free_consistent(ioa_cfg->pdev, sizeof(struct ipr_config_table),
-                            ioa_cfg->cfg_table,
+        pci_free_consistent(ioa_cfg->pdev, ioa_cfg->cfg_table_size,
+                            ioa_cfg->u.cfg_table,
                             ioa_cfg->cfg_table_dma);
 
         for (i = 0; i < IPR_NUM_HCAMS; i++) {
@@ -7203,7 +8016,7 @@ static int __devinit ipr_alloc_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
         int i;
 
         ioa_cfg->ipr_cmd_pool = pci_pool_create (IPR_NAME, ioa_cfg->pdev,
-                                                 sizeof(struct ipr_cmnd), 8, 0);
+                                                 sizeof(struct ipr_cmnd), 16, 0);
 
         if (!ioa_cfg->ipr_cmd_pool)
                 return -ENOMEM;
@@ -7221,13 +8034,25 @@ static int __devinit ipr_alloc_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
                 ioa_cfg->ipr_cmnd_list_dma[i] = dma_addr;
 
                 ioarcb = &ipr_cmd->ioarcb;
-                ioarcb->ioarcb_host_pci_addr = cpu_to_be32(dma_addr);
+                ipr_cmd->dma_addr = dma_addr;
+                if (ioa_cfg->sis64)
+                        ioarcb->a.ioarcb_host_pci_addr64 = cpu_to_be64(dma_addr);
+                else
+                        ioarcb->a.ioarcb_host_pci_addr = cpu_to_be32(dma_addr);
+
                 ioarcb->host_response_handle = cpu_to_be32(i << 2);
-                ioarcb->write_ioadl_addr =
-                        cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, ioadl));
-                ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
-                ioarcb->ioasa_host_pci_addr =
-                        cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, ioasa));
+                if (ioa_cfg->sis64) {
+                        ioarcb->u.sis64_addr_data.data_ioadl_addr =
+                                cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
+                        ioarcb->u.sis64_addr_data.ioasa_host_pci_addr =
+                                cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, ioasa));
+                } else {
+                        ioarcb->write_ioadl_addr =
+                                cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
+                        ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
+                        ioarcb->ioasa_host_pci_addr =
+                                cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, ioasa));
+                }
                 ioarcb->ioasa_len = cpu_to_be16(sizeof(struct ipr_ioasa));
                 ipr_cmd->cmd_index = i;
                 ipr_cmd->ioa_cfg = ioa_cfg;
@@ -7254,13 +8079,24 @@ static int __devinit ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg)
 
         ENTER;
         ioa_cfg->res_entries = kzalloc(sizeof(struct ipr_resource_entry) *
-                                       IPR_MAX_PHYSICAL_DEVS, GFP_KERNEL);
+                                       ioa_cfg->max_devs_supported, GFP_KERNEL);
 
         if (!ioa_cfg->res_entries)
                 goto out;
 
-        for (i = 0; i < IPR_MAX_PHYSICAL_DEVS; i++)
+        if (ioa_cfg->sis64) {
+                ioa_cfg->target_ids = kzalloc(sizeof(unsigned long) *
+                                              BITS_TO_LONGS(ioa_cfg->max_devs_supported), GFP_KERNEL);
+                ioa_cfg->array_ids = kzalloc(sizeof(unsigned long) *
+                                             BITS_TO_LONGS(ioa_cfg->max_devs_supported), GFP_KERNEL);
+                ioa_cfg->vset_ids = kzalloc(sizeof(unsigned long) *
+                                            BITS_TO_LONGS(ioa_cfg->max_devs_supported), GFP_KERNEL);
+        }
+
+        for (i = 0; i < ioa_cfg->max_devs_supported; i++) {
                 list_add_tail(&ioa_cfg->res_entries[i].queue, &ioa_cfg->free_res_q);
+                ioa_cfg->res_entries[i].ioa_cfg = ioa_cfg;
+        }
 
         ioa_cfg->vpd_cbs = pci_alloc_consistent(ioa_cfg->pdev,
                                                 sizeof(struct ipr_misc_cbs),
@@ -7279,11 +8115,11 @@ static int __devinit ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg)
         if (!ioa_cfg->host_rrq)
                 goto out_ipr_free_cmd_blocks;
 
-        ioa_cfg->cfg_table = pci_alloc_consistent(ioa_cfg->pdev,
-                                                  sizeof(struct ipr_config_table),
-                                                  &ioa_cfg->cfg_table_dma);
+        ioa_cfg->u.cfg_table = pci_alloc_consistent(ioa_cfg->pdev,
+                                                    ioa_cfg->cfg_table_size,
+                                                    &ioa_cfg->cfg_table_dma);
 
-        if (!ioa_cfg->cfg_table)
+        if (!ioa_cfg->u.cfg_table)
                 goto out_free_host_rrq;
 
         for (i = 0; i < IPR_NUM_HCAMS; i++) {
@@ -7317,8 +8153,9 @@ out_free_hostrcb_dma:
                                     ioa_cfg->hostrcb[i],
                                     ioa_cfg->hostrcb_dma[i]);
         }
-        pci_free_consistent(pdev, sizeof(struct ipr_config_table),
-                            ioa_cfg->cfg_table, ioa_cfg->cfg_table_dma);
+        pci_free_consistent(pdev, ioa_cfg->cfg_table_size,
+                            ioa_cfg->u.cfg_table,
+                            ioa_cfg->cfg_table_dma);
 out_free_host_rrq:
         pci_free_consistent(pdev, sizeof(u32) * IPR_NUM_CMD_BLKS,
                             ioa_cfg->host_rrq, ioa_cfg->host_rrq_dma);
@@ -7393,15 +8230,21 @@ static void __devinit ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg,
         init_waitqueue_head(&ioa_cfg->reset_wait_q);
         init_waitqueue_head(&ioa_cfg->msi_wait_q);
         ioa_cfg->sdt_state = INACTIVE;
-        if (ipr_enable_cache)
-                ioa_cfg->cache_state = CACHE_ENABLED;
-        else
-                ioa_cfg->cache_state = CACHE_DISABLED;
 
         ipr_initialize_bus_attr(ioa_cfg);
+        ioa_cfg->max_devs_supported = ipr_max_devs;
 
-        host->max_id = IPR_MAX_NUM_TARGETS_PER_BUS;
-        host->max_lun = IPR_MAX_NUM_LUNS_PER_TARGET;
+        if (ioa_cfg->sis64) {
+                host->max_id = IPR_MAX_SIS64_TARGETS_PER_BUS;
+                host->max_lun = IPR_MAX_SIS64_LUNS_PER_TARGET;
+                if (ipr_max_devs > IPR_MAX_SIS64_DEVS)
+                        ioa_cfg->max_devs_supported = IPR_MAX_SIS64_DEVS;
+        } else {
+                host->max_id = IPR_MAX_NUM_TARGETS_PER_BUS;
+                host->max_lun = IPR_MAX_NUM_LUNS_PER_TARGET;
+                if (ipr_max_devs > IPR_MAX_PHYSICAL_DEVS)
+                        ioa_cfg->max_devs_supported = IPR_MAX_PHYSICAL_DEVS;
+        }
         host->max_channel = IPR_MAX_BUS_TO_SCAN;
         host->unique_id = host->host_no;
         host->max_cmd_len = IPR_MAX_CDB_LEN;
@@ -7413,13 +8256,26 @@ static void __devinit ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg,
 
         t->set_interrupt_mask_reg = base + p->set_interrupt_mask_reg;
         t->clr_interrupt_mask_reg = base + p->clr_interrupt_mask_reg;
+        t->clr_interrupt_mask_reg32 = base + p->clr_interrupt_mask_reg32;
         t->sense_interrupt_mask_reg = base + p->sense_interrupt_mask_reg;
+        t->sense_interrupt_mask_reg32 = base + p->sense_interrupt_mask_reg32;
         t->clr_interrupt_reg = base + p->clr_interrupt_reg;
+        t->clr_interrupt_reg32 = base + p->clr_interrupt_reg32;
         t->sense_interrupt_reg = base + p->sense_interrupt_reg;
+        t->sense_interrupt_reg32 = base + p->sense_interrupt_reg32;
         t->ioarrin_reg = base + p->ioarrin_reg;
         t->sense_uproc_interrupt_reg = base + p->sense_uproc_interrupt_reg;
+        t->sense_uproc_interrupt_reg32 = base + p->sense_uproc_interrupt_reg32;
         t->set_uproc_interrupt_reg = base + p->set_uproc_interrupt_reg;
+        t->set_uproc_interrupt_reg32 = base + p->set_uproc_interrupt_reg32;
         t->clr_uproc_interrupt_reg = base + p->clr_uproc_interrupt_reg;
+        t->clr_uproc_interrupt_reg32 = base + p->clr_uproc_interrupt_reg32;
+
+        if (ioa_cfg->sis64) {
+                t->init_feedback_reg = base + p->init_feedback_reg;
+                t->dump_addr_reg = base + p->dump_addr_reg;
+                t->dump_data_reg = base + p->dump_data_reg;
+        }
 }
 
 /**
@@ -7491,7 +8347,7 @@ static int __devinit ipr_test_msi(struct ipr_ioa_cfg *ioa_cfg,
         init_waitqueue_head(&ioa_cfg->msi_wait_q);
         ioa_cfg->msi_received = 0;
         ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
-        writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.clr_interrupt_mask_reg);
+        writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.clr_interrupt_mask_reg32);
         int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
 
@@ -7502,7 +8358,7 @@ static int __devinit ipr_test_msi(struct ipr_ioa_cfg *ioa_cfg,
         } else if (ipr_debug)
                 dev_info(&pdev->dev, "IRQ assigned: %d\n", pdev->irq);
 
-        writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.sense_interrupt_reg);
+        writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.sense_interrupt_reg32);
         int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
         wait_event_timeout(ioa_cfg->msi_wait_q, ioa_cfg->msi_received, HZ);
         ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
@@ -7572,6 +8428,8 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
                 goto out_scsi_host_put;
         }
 
+        /* set SIS 32 or SIS 64 */
+        ioa_cfg->sis64 = ioa_cfg->ipr_chip->sis_type == IPR_SIS64 ? 1 : 0;
         ioa_cfg->chip_cfg = ioa_cfg->ipr_chip->cfg;
 
         if (ipr_transop_timeout)
@@ -7609,7 +8467,16 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
 
         pci_set_master(pdev);
 
-        rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+        if (ioa_cfg->sis64) {
+                rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
+                if (rc < 0) {
+                        dev_dbg(&pdev->dev, "Failed to set 64 bit PCI DMA mask\n");
+                        rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+                }
+
+        } else
+                rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+
         if (rc < 0) {
                 dev_err(&pdev->dev, "Failed to set PCI DMA mask\n");
                 goto cleanup_nomem;
@@ -7651,6 +8518,15 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
         if ((rc = ipr_set_pcix_cmd_reg(ioa_cfg)))
                 goto cleanup_nomem;
 
+        if (ioa_cfg->sis64)
+                ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr64)
+                                + ((sizeof(struct ipr_config_table_entry64)
+                                * ioa_cfg->max_devs_supported)));
+        else
+                ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr)
+                                + ((sizeof(struct ipr_config_table_entry)
+                                * ioa_cfg->max_devs_supported)));
+
         rc = ipr_alloc_mem(ioa_cfg);
         if (rc < 0) {
                 dev_err(&pdev->dev,
@@ -7662,9 +8538,9 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
          * If HRRQ updated interrupt is not masked, or reset alert is set,
          * the card is in an unknown state and needs a hard reset
          */
-        mask = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
-        interrupts = readl(ioa_cfg->regs.sense_interrupt_reg);
-        uproc = readl(ioa_cfg->regs.sense_uproc_interrupt_reg);
+        mask = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
+        interrupts = readl(ioa_cfg->regs.sense_interrupt_reg32);
+        uproc = readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
         if ((mask & IPR_PCII_HRRQ_UPDATED) == 0 || (uproc & IPR_UPROCI_RESET_ALERT))
                 ioa_cfg->needs_hard_reset = 1;
         if (interrupts & IPR_PCII_ERROR_INTERRUPTS)
@@ -7952,9 +8828,6 @@ static struct pci_device_id ipr_pci_table[] __devinitdata = {
               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574E, 0, 0,
               IPR_USE_LONG_TRANSOP_TIMEOUT },
         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
-              PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575D, 0, 0,
-              IPR_USE_LONG_TRANSOP_TIMEOUT },
-        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B3, 0, 0, 0 },
         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B7, 0, 0,
@@ -7969,9 +8842,22 @@ static struct pci_device_id ipr_pci_table[] __devinitdata = {
         { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572F, 0, 0,
                 IPR_USE_LONG_TRANSOP_TIMEOUT },
-        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SCAMP_E,
-                PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574D, 0, 0,
-                IPR_USE_LONG_TRANSOP_TIMEOUT },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
+                PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B5, 0, 0, 0 },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
+                PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574D, 0, 0, 0 },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
+                PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B2, 0, 0, 0 },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_ASIC_E2,
+                PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B4, 0, 0, 0 },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_ASIC_E2,
+                PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B1, 0, 0, 0 },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_ASIC_E2,
+                PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C6, 0, 0, 0 },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_ASIC_E2,
+                PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575D, 0, 0, 0 },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_ASIC_E2,
+                PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57CE, 0, 0, 0 },
         { }
 };
 MODULE_DEVICE_TABLE(pci, ipr_pci_table);
@@ -7991,6 +8877,61 @@ static struct pci_driver ipr_driver = {
 };
 
 /**
+ * ipr_halt_done - Shutdown prepare completion
+ *
+ * Return value:
+ *      none
+ **/
+static void ipr_halt_done(struct ipr_cmnd *ipr_cmd)
+{
+        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
+
+        list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
+}
+
+/**
+ * ipr_halt - Issue shutdown prepare to all adapters
+ *
+ * Return value:
+ *      NOTIFY_OK on success / NOTIFY_DONE on failure
+ **/
+static int ipr_halt(struct notifier_block *nb, ulong event, void *buf)
+{
+        struct ipr_cmnd *ipr_cmd;
+        struct ipr_ioa_cfg *ioa_cfg;
+        unsigned long flags = 0;
+
+        if (event != SYS_RESTART && event != SYS_HALT && event != SYS_POWER_OFF)
+                return NOTIFY_DONE;
+
+        spin_lock(&ipr_driver_lock);
+
+        list_for_each_entry(ioa_cfg, &ipr_ioa_head, queue) {
+                spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
+                if (!ioa_cfg->allow_cmds) {
+                        spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+                        continue;
+                }
+
+                ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
+                ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
+                ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
+                ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
+                ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_SHUTDOWN_PREPARE_FOR_NORMAL;
+
+                ipr_do_req(ipr_cmd, ipr_halt_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
+                spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
+        }
+        spin_unlock(&ipr_driver_lock);
+
+        return NOTIFY_OK;
+}
+
+static struct notifier_block ipr_notifier = {
+        ipr_halt, NULL, 0
+};
+
+/**
  * ipr_init - Module entry point
  *
  * Return value:
@@ -8001,6 +8942,7 @@ static int __init ipr_init(void)
         ipr_info("IBM Power RAID SCSI Device Driver version: %s %s\n",
                  IPR_DRIVER_VERSION, IPR_DRIVER_DATE);
 
+        register_reboot_notifier(&ipr_notifier);
         return pci_register_driver(&ipr_driver);
 }
 
@@ -8014,6 +8956,7 @@ static int __init ipr_init(void)
  **/
 static void __exit ipr_exit(void)
 {
+        unregister_reboot_notifier(&ipr_notifier);
         pci_unregister_driver(&ipr_driver);
 }
 
diff --git a/drivers/scsi/ipr.h b/drivers/scsi/ipr.h
index 19bbcf39f0c9..4c267b5e0b96 100644
--- a/drivers/scsi/ipr.h
+++ b/drivers/scsi/ipr.h
@@ -37,8 +37,8 @@
 /*
  * Literals
  */
-#define IPR_DRIVER_VERSION "2.4.3"
-#define IPR_DRIVER_DATE "(June 10, 2009)"
+#define IPR_DRIVER_VERSION "2.5.0"
+#define IPR_DRIVER_DATE "(February 11, 2010)"
 
 /*
  * IPR_MAX_CMD_PER_LUN: This defines the maximum number of outstanding
@@ -55,7 +55,9 @@
 #define IPR_NUM_BASE_CMD_BLKS                           100
 
 #define PCI_DEVICE_ID_IBM_OBSIDIAN_E    0x0339
-#define PCI_DEVICE_ID_IBM_SCAMP_E               0x034A
+
+#define PCI_DEVICE_ID_IBM_CROC_FPGA_E2          0x033D
+#define PCI_DEVICE_ID_IBM_CROC_ASIC_E2          0x034A
 
 #define IPR_SUBS_DEV_ID_2780    0x0264
 #define IPR_SUBS_DEV_ID_5702    0x0266
@@ -70,15 +72,24 @@
 #define IPR_SUBS_DEV_ID_572A    0x02C1
 #define IPR_SUBS_DEV_ID_572B    0x02C2
 #define IPR_SUBS_DEV_ID_572F    0x02C3
-#define IPR_SUBS_DEV_ID_574D    0x030B
 #define IPR_SUBS_DEV_ID_574E    0x030A
 #define IPR_SUBS_DEV_ID_575B    0x030D
 #define IPR_SUBS_DEV_ID_575C    0x0338
-#define IPR_SUBS_DEV_ID_575D    0x033E
 #define IPR_SUBS_DEV_ID_57B3    0x033A
 #define IPR_SUBS_DEV_ID_57B7    0x0360
 #define IPR_SUBS_DEV_ID_57B8    0x02C2
 
+#define IPR_SUBS_DEV_ID_57B4    0x033B
+#define IPR_SUBS_DEV_ID_57B2    0x035F
+#define IPR_SUBS_DEV_ID_57C6    0x0357
+
+#define IPR_SUBS_DEV_ID_57B5    0x033C
+#define IPR_SUBS_DEV_ID_57CE    0x035E
+#define IPR_SUBS_DEV_ID_57B1    0x0355
+
+#define IPR_SUBS_DEV_ID_574D    0x0356
+#define IPR_SUBS_DEV_ID_575D    0x035D
+
 #define IPR_NAME                                "ipr"
 
 /*
@@ -118,6 +129,10 @@
 #define IPR_NUM_LOG_HCAMS                               2
 #define IPR_NUM_CFG_CHG_HCAMS                           2
 #define IPR_NUM_HCAMS   (IPR_NUM_LOG_HCAMS + IPR_NUM_CFG_CHG_HCAMS)
+
+#define IPR_MAX_SIS64_TARGETS_PER_BUS                   1024
+#define IPR_MAX_SIS64_LUNS_PER_TARGET                   0xffffffff
+
 #define IPR_MAX_NUM_TARGETS_PER_BUS                     256
 #define IPR_MAX_NUM_LUNS_PER_TARGET                     256
 #define IPR_MAX_NUM_VSET_LUNS_PER_TARGET        8
@@ -132,13 +147,15 @@
 
 /* We need resources for HCAMS, IOA reset, IOA bringdown, and ERP */
 #define IPR_NUM_INTERNAL_CMD_BLKS       (IPR_NUM_HCAMS + \
-                                     ((IPR_NUM_RESET_RELOAD_RETRIES + 1) * 2) + 3)
+                                     ((IPR_NUM_RESET_RELOAD_RETRIES + 1) * 2) + 4)
 
 #define IPR_MAX_COMMANDS                IPR_NUM_BASE_CMD_BLKS
 #define IPR_NUM_CMD_BLKS                (IPR_NUM_BASE_CMD_BLKS + \
                                                 IPR_NUM_INTERNAL_CMD_BLKS)
 
 #define IPR_MAX_PHYSICAL_DEVS                           192
+#define IPR_DEFAULT_SIS64_DEVS                          1024
+#define IPR_MAX_SIS64_DEVS                              4096
 
 #define IPR_MAX_SGLIST                                  64
 #define IPR_IOA_MAX_SECTORS                             32767
@@ -173,6 +190,7 @@
 #define IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE      0x01
 #define IPR_HCAM_CDB_OP_CODE_LOG_DATA           0x02
 #define IPR_SET_SUPPORTED_DEVICES                       0xFB
+#define IPR_SET_ALL_SUPPORTED_DEVICES                   0x80
 #define IPR_IOA_SHUTDOWN                                0xF7
 #define IPR_WR_BUF_DOWNLOAD_AND_SAVE                    0x05
 
@@ -221,9 +239,17 @@
 #define IPR_SDT_FMT2_BAR5_SEL                           0x5
 #define IPR_SDT_FMT2_EXP_ROM_SEL                        0x8
 #define IPR_FMT2_SDT_READY_TO_USE                       0xC4D4E3F2
+#define IPR_FMT3_SDT_READY_TO_USE                       0xC4D4E3F3
 #define IPR_DOORBELL                                    0x82800000
 #define IPR_RUNTIME_RESET                               0x40000000
 
+#define IPR_IPL_INIT_MIN_STAGE_TIME                     5
+#define IPR_IPL_INIT_STAGE_UNKNOWN                      0x0
+#define IPR_IPL_INIT_STAGE_TRANSOP                      0xB0000000
+#define IPR_IPL_INIT_STAGE_MASK                         0xff000000
+#define IPR_IPL_INIT_STAGE_TIME_MASK                    0x0000ffff
+#define IPR_PCII_IPL_STAGE_CHANGE                       (0x80000000 >> 0)
+
 #define IPR_PCII_IOA_TRANS_TO_OPER                      (0x80000000 >> 0)
 #define IPR_PCII_IOARCB_XFER_FAILED                     (0x80000000 >> 3)
 #define IPR_PCII_IOA_UNIT_CHECKED                       (0x80000000 >> 4)
@@ -318,27 +344,27 @@ struct ipr_std_inq_data {
         u8 serial_num[IPR_SERIAL_NUM_LEN];
 }__attribute__ ((packed));
 
+#define IPR_RES_TYPE_AF_DASD            0x00
+#define IPR_RES_TYPE_GENERIC_SCSI       0x01
+#define IPR_RES_TYPE_VOLUME_SET         0x02
+#define IPR_RES_TYPE_REMOTE_AF_DASD     0x03
+#define IPR_RES_TYPE_GENERIC_ATA        0x04
+#define IPR_RES_TYPE_ARRAY              0x05
+#define IPR_RES_TYPE_IOAFP              0xff
+
 struct ipr_config_table_entry {
         u8 proto;
 #define IPR_PROTO_SATA                  0x02
 #define IPR_PROTO_SATA_ATAPI            0x03
 #define IPR_PROTO_SAS_STP               0x06
-#define IPR_PROTO_SAS_STP_ATAPI 0x07
+#define IPR_PROTO_SAS_STP_ATAPI         0x07
         u8 array_id;
         u8 flags;
-#define IPR_IS_IOA_RESOURCE     0x80
-#define IPR_IS_ARRAY_MEMBER 0x20
-#define IPR_IS_HOT_SPARE        0x10
-
+#define IPR_IS_IOA_RESOURCE             0x80
         u8 rsvd_subtype;
-#define IPR_RES_SUBTYPE(res) (((res)->cfgte.rsvd_subtype) & 0x0f)
-#define IPR_SUBTYPE_AF_DASD                     0
-#define IPR_SUBTYPE_GENERIC_SCSI        1
-#define IPR_SUBTYPE_VOLUME_SET          2
-#define IPR_SUBTYPE_GENERIC_ATA 4
-
-#define IPR_QUEUEING_MODEL(res) ((((res)->cfgte.flags) & 0x70) >> 4)
-#define IPR_QUEUE_FROZEN_MODEL  0
+
+#define IPR_QUEUEING_MODEL(res) ((((res)->flags) & 0x70) >> 4)
+#define IPR_QUEUE_FROZEN_MODEL          0
 #define IPR_QUEUE_NACA_MODEL            1
 
         struct ipr_res_addr res_addr;
@@ -347,6 +373,28 @@ struct ipr_config_table_entry {
         struct ipr_std_inq_data std_inq_data;
 }__attribute__ ((packed, aligned (4)));
 
+struct ipr_config_table_entry64 {
+        u8 res_type;
+        u8 proto;
+        u8 vset_num;
+        u8 array_id;
+        __be16 flags;
+        __be16 res_flags;
+#define IPR_QUEUEING_MODEL64(res) ((((res)->res_flags) & 0x7000) >> 12)
+        __be32 res_handle;
+        u8 dev_id_type;
+        u8 reserved[3];
+        __be64 dev_id;
+        __be64 lun;
+        __be64 lun_wwn[2];
+#define IPR_MAX_RES_PATH_LENGTH         24
+        __be64 res_path;
+        struct ipr_std_inq_data std_inq_data;
+        u8 reserved2[4];
+        __be64 reserved3[2]; // description text
+        u8 reserved4[8];
+}__attribute__ ((packed, aligned (8)));
+
 struct ipr_config_table_hdr {
         u8 num_entries;
         u8 flags;
@@ -354,13 +402,35 @@ struct ipr_config_table_hdr {
         __be16 reserved;
 }__attribute__((packed, aligned (4)));
 
+struct ipr_config_table_hdr64 {
+        __be16 num_entries;
+        __be16 reserved;
+        u8 flags;
+        u8 reserved2[11];
+}__attribute__((packed, aligned (4)));
+
 struct ipr_config_table {
         struct ipr_config_table_hdr hdr;
-        struct ipr_config_table_entry dev[IPR_MAX_PHYSICAL_DEVS];
+        struct ipr_config_table_entry dev[0];
 }__attribute__((packed, aligned (4)));
 
+struct ipr_config_table64 {
+        struct ipr_config_table_hdr64 hdr64;
+        struct ipr_config_table_entry64 dev[0];
+}__attribute__((packed, aligned (8)));
+
+struct ipr_config_table_entry_wrapper {
+        union {
+                struct ipr_config_table_entry *cfgte;
+                struct ipr_config_table_entry64 *cfgte64;
+        } u;
+};
+
 struct ipr_hostrcb_cfg_ch_not {
-        struct ipr_config_table_entry cfgte;
+        union {
+                struct ipr_config_table_entry cfgte;
+                struct ipr_config_table_entry64 cfgte64;
+        } u;
         u8 reserved[936];
 }__attribute__((packed, aligned (4)));
 
@@ -381,7 +451,7 @@ struct ipr_cmd_pkt {
 #define IPR_RQTYPE_HCAM                 0x02
 #define IPR_RQTYPE_ATA_PASSTHRU 0x04
 
-        u8 luntar_luntrn;
+        u8 reserved2;
 
         u8 flags_hi;
 #define IPR_FLAGS_HI_WRITE_NOT_READ             0x80
@@ -403,7 +473,7 @@ struct ipr_cmd_pkt {
         __be16 timeout;
 }__attribute__ ((packed, aligned(4)));
 
-struct ipr_ioarcb_ata_regs {
+struct ipr_ioarcb_ata_regs {    /* 22 bytes */
         u8 flags;
 #define IPR_ATA_FLAG_PACKET_CMD                 0x80
 #define IPR_ATA_FLAG_XFER_TYPE_DMA                      0x40
@@ -442,28 +512,49 @@ struct ipr_ioadl_desc {
         __be32 address;
 }__attribute__((packed, aligned (8)));
 
+struct ipr_ioadl64_desc {
+        __be32 flags;
+        __be32 data_len;
+        __be64 address;
+}__attribute__((packed, aligned (16)));
+
+struct ipr_ata64_ioadl {
+        struct ipr_ioarcb_ata_regs regs;
+        u16 reserved[5];
+        struct ipr_ioadl64_desc ioadl64[IPR_NUM_IOADL_ENTRIES];
+}__attribute__((packed, aligned (16)));
+
 struct ipr_ioarcb_add_data {
         union {
                 struct ipr_ioarcb_ata_regs regs;
                 struct ipr_ioadl_desc ioadl[5];
                 __be32 add_cmd_parms[10];
-        }u;
-}__attribute__ ((packed, aligned(4)));
+        } u;
+}__attribute__ ((packed, aligned (4)));
+
+struct ipr_ioarcb_sis64_add_addr_ecb {
+        __be64 ioasa_host_pci_addr;
+        __be64 data_ioadl_addr;
+        __be64 reserved;
+        __be32 ext_control_buf[4];
+}__attribute__((packed, aligned (8)));
 
 /* IOA Request Control Block    128 bytes  */
 struct ipr_ioarcb {
-        __be32 ioarcb_host_pci_addr;
-        __be32 reserved;
+        union {
+                __be32 ioarcb_host_pci_addr;
+                __be64 ioarcb_host_pci_addr64;
+        } a;
         __be32 res_handle;
         __be32 host_response_handle;
         __be32 reserved1;
         __be32 reserved2;
         __be32 reserved3;
 
-        __be32 write_data_transfer_length;
+        __be32 data_transfer_length;
         __be32 read_data_transfer_length;
         __be32 write_ioadl_addr;
-        __be32 write_ioadl_len;
+        __be32 ioadl_len;
         __be32 read_ioadl_addr;
         __be32 read_ioadl_len;
 
@@ -473,8 +564,14 @@ struct ipr_ioarcb {
 
         struct ipr_cmd_pkt cmd_pkt;
 
-        __be32 add_cmd_parms_len;
-        struct ipr_ioarcb_add_data add_data;
+        __be16 add_cmd_parms_offset;
+        __be16 add_cmd_parms_len;
+
+        union {
+                struct ipr_ioarcb_add_data add_data;
+                struct ipr_ioarcb_sis64_add_addr_ecb sis64_addr_data;
+        } u;
+
 }__attribute__((packed, aligned (4)));
 
 struct ipr_ioasa_vset {
@@ -676,12 +773,29 @@ struct ipr_hostrcb_device_data_entry_enhanced {
         struct ipr_ext_vpd cfc_last_with_dev_vpd;
 }__attribute__((packed, aligned (4)));
 
+struct ipr_hostrcb64_device_data_entry_enhanced {
+        struct ipr_ext_vpd vpd;
+        u8 ccin[4];
+        u8 res_path[8];
+        struct ipr_ext_vpd new_vpd;
+        u8 new_ccin[4];
+        struct ipr_ext_vpd ioa_last_with_dev_vpd;
+        struct ipr_ext_vpd cfc_last_with_dev_vpd;
+}__attribute__((packed, aligned (4)));
+
 struct ipr_hostrcb_array_data_entry {
         struct ipr_vpd vpd;
         struct ipr_res_addr expected_dev_res_addr;
         struct ipr_res_addr dev_res_addr;
 }__attribute__((packed, aligned (4)));
 
+struct ipr_hostrcb64_array_data_entry {
+        struct ipr_ext_vpd vpd;
+        u8 ccin[4];
+        u8 expected_res_path[8];
+        u8 res_path[8];
+}__attribute__((packed, aligned (4)));
+
 struct ipr_hostrcb_array_data_entry_enhanced {
         struct ipr_ext_vpd vpd;
         u8 ccin[4];
@@ -733,6 +847,14 @@ struct ipr_hostrcb_type_13_error {
         struct ipr_hostrcb_device_data_entry_enhanced dev[3];
 }__attribute__((packed, aligned (4)));
 
+struct ipr_hostrcb_type_23_error {
+        struct ipr_ext_vpd ioa_vpd;
+        struct ipr_ext_vpd cfc_vpd;
+        __be32 errors_detected;
+        __be32 errors_logged;
+        struct ipr_hostrcb64_device_data_entry_enhanced dev[3];
+}__attribute__((packed, aligned (4)));
+
 struct ipr_hostrcb_type_04_error {
         struct ipr_vpd ioa_vpd;
         struct ipr_vpd cfc_vpd;
@@ -760,6 +882,22 @@ struct ipr_hostrcb_type_14_error {
         struct ipr_hostrcb_array_data_entry_enhanced array_member[18];
 }__attribute__((packed, aligned (4)));
 
+struct ipr_hostrcb_type_24_error {
+        struct ipr_ext_vpd ioa_vpd;
+        struct ipr_ext_vpd cfc_vpd;
+        u8 reserved[2];
+        u8 exposed_mode_adn;
+#define IPR_INVALID_ARRAY_DEV_NUM               0xff
+        u8 array_id;
+        u8 last_res_path[8];
+        u8 protection_level[8];
+        struct ipr_ext_vpd array_vpd;
+        u8 description[16];
+        u8 reserved2[3];
+        u8 num_entries;
+        struct ipr_hostrcb64_array_data_entry array_member[32];
+}__attribute__((packed, aligned (4)));
+
 struct ipr_hostrcb_type_07_error {
         u8 failure_reason[64];
         struct ipr_vpd vpd;
@@ -797,6 +935,22 @@ struct ipr_hostrcb_config_element {
         __be32 wwid[2];
 }__attribute__((packed, aligned (4)));
 
+struct ipr_hostrcb64_config_element {
+        __be16 length;
+        u8 descriptor_id;
+#define IPR_DESCRIPTOR_MASK             0xC0
+#define IPR_DESCRIPTOR_SIS64            0x00
+
+        u8 reserved;
+        u8 type_status;
+
+        u8 reserved2[2];
+        u8 link_rate;
+
+        u8 res_path[8];
+        __be32 wwid[2];
+}__attribute__((packed, aligned (8)));
+
 struct ipr_hostrcb_fabric_desc {
         __be16 length;
         u8 ioa_port;
@@ -818,6 +972,20 @@ struct ipr_hostrcb_fabric_desc {
         struct ipr_hostrcb_config_element elem[1];
 }__attribute__((packed, aligned (4)));
 
+struct ipr_hostrcb64_fabric_desc {
+        __be16 length;
+        u8 descriptor_id;
+
+        u8 reserved;
+        u8 path_state;
+
+        u8 reserved2[2];
+        u8 res_path[8];
+        u8 reserved3[6];
+        __be16 num_entries;
+        struct ipr_hostrcb64_config_element elem[1];
+}__attribute__((packed, aligned (8)));
+
 #define for_each_fabric_cfg(fabric, cfg) \
                 for (cfg = (fabric)->elem; \
                         cfg < ((fabric)->elem + be16_to_cpu((fabric)->num_entries)); \
@@ -830,10 +998,17 @@ struct ipr_hostrcb_type_20_error {
         struct ipr_hostrcb_fabric_desc desc[1];
 }__attribute__((packed, aligned (4)));
 
+struct ipr_hostrcb_type_30_error {
+        u8 failure_reason[64];
+        u8 reserved[3];
+        u8 num_entries;
+        struct ipr_hostrcb64_fabric_desc desc[1];
+}__attribute__((packed, aligned (4)));
+
 struct ipr_hostrcb_error {
-        __be32 failing_dev_ioasc;
-        struct ipr_res_addr failing_dev_res_addr;
-        __be32 failing_dev_res_handle;
+        __be32 fd_ioasc;
+        struct ipr_res_addr fd_res_addr;
+        __be32 fd_res_handle;
         __be32 prc;
         union {
                 struct ipr_hostrcb_type_ff_error type_ff_error;
@@ -850,6 +1025,26 @@ struct ipr_hostrcb_error {
         } u;
 }__attribute__((packed, aligned (4)));
 
+struct ipr_hostrcb64_error {
+        __be32 fd_ioasc;
+        __be32 ioa_fw_level;
+        __be32 fd_res_handle;
+        __be32 prc;
+        __be64 fd_dev_id;
+        __be64 fd_lun;
+        u8 fd_res_path[8];
+        __be64 time_stamp;
+        u8 reserved[2];
+        union {
+                struct ipr_hostrcb_type_ff_error type_ff_error;
+                struct ipr_hostrcb_type_12_error type_12_error;
+                struct ipr_hostrcb_type_17_error type_17_error;
+                struct ipr_hostrcb_type_23_error type_23_error;
+                struct ipr_hostrcb_type_24_error type_24_error;
+                struct ipr_hostrcb_type_30_error type_30_error;
+        } u;
+}__attribute__((packed, aligned (8)));
+
 struct ipr_hostrcb_raw {
         __be32 data[sizeof(struct ipr_hostrcb_error)/sizeof(__be32)];
 }__attribute__((packed, aligned (4)));
@@ -887,7 +1082,11 @@ struct ipr_hcam {
 #define IPR_HOST_RCB_OVERLAY_ID_16                              0x16
 #define IPR_HOST_RCB_OVERLAY_ID_17                              0x17
 #define IPR_HOST_RCB_OVERLAY_ID_20                              0x20
-#define IPR_HOST_RCB_OVERLAY_ID_DEFAULT                 0xFF
+#define IPR_HOST_RCB_OVERLAY_ID_23                              0x23
+#define IPR_HOST_RCB_OVERLAY_ID_24                              0x24
+#define IPR_HOST_RCB_OVERLAY_ID_26                              0x26
+#define IPR_HOST_RCB_OVERLAY_ID_30                              0x30
+#define IPR_HOST_RCB_OVERLAY_ID_DEFAULT                         0xFF
 
         u8 reserved1[3];
         __be32 ilid;
@@ -897,6 +1096,7 @@ struct ipr_hcam {
 
         union {
                 struct ipr_hostrcb_error error;
+                struct ipr_hostrcb64_error error64;
                 struct ipr_hostrcb_cfg_ch_not ccn;
                 struct ipr_hostrcb_raw raw;
         } u;
@@ -907,14 +1107,14 @@ struct ipr_hostrcb {
         dma_addr_t hostrcb_dma;
         struct list_head queue;
         struct ipr_ioa_cfg *ioa_cfg;
+        char rp_buffer[IPR_MAX_RES_PATH_LENGTH];
 };
 
 /* IPR smart dump table structures */
 struct ipr_sdt_entry {
-        __be32 bar_str_offset;
-        __be32 end_offset;
-        u8 entry_byte;
-        u8 reserved[3];
+        __be32 start_token;
+        __be32 end_token;
+        u8 reserved[4];
 
         u8 flags;
 #define IPR_SDT_ENDIAN          0x80
@@ -960,28 +1160,48 @@ struct ipr_sata_port {
 };
 
 struct ipr_resource_entry {
-        struct ipr_config_table_entry cfgte;
         u8 needs_sync_complete:1;
         u8 in_erp:1;
         u8 add_to_ml:1;
         u8 del_from_ml:1;
         u8 resetting_device:1;
 
+        u32 bus;                /* AKA channel */
+        u32 target;             /* AKA id */
+        u32 lun;
+#define IPR_ARRAY_VIRTUAL_BUS                   0x1
+#define IPR_VSET_VIRTUAL_BUS                    0x2
+#define IPR_IOAFP_VIRTUAL_BUS                   0x3
+
+#define IPR_GET_RES_PHYS_LOC(res) \
+        (((res)->bus << 24) | ((res)->target << 8) | (res)->lun)
+
+        u8 ata_class;
+
+        u8 flags;
+        __be16 res_flags;
+
+        __be32 type;
+
+        u8 qmodel;
+        struct ipr_std_inq_data std_inq_data;
+
+        __be32 res_handle;
+        __be64 dev_id;
+        struct scsi_lun dev_lun;
+        u8 res_path[8];
+
+        struct ipr_ioa_cfg *ioa_cfg;
         struct scsi_device *sdev;
         struct ipr_sata_port *sata_port;
         struct list_head queue;
-};
+}; /* struct ipr_resource_entry */
 
 struct ipr_resource_hdr {
         u16 num_entries;
         u16 reserved;
 };
 
-struct ipr_resource_table {
-        struct ipr_resource_hdr hdr;
-        struct ipr_resource_entry dev[IPR_MAX_PHYSICAL_DEVS];
-};
-
 struct ipr_misc_cbs {
         struct ipr_ioa_vpd ioa_vpd;
         struct ipr_inquiry_page0 page0_data;
@@ -994,27 +1214,51 @@ struct ipr_misc_cbs {
 struct ipr_interrupt_offsets {
         unsigned long set_interrupt_mask_reg;
         unsigned long clr_interrupt_mask_reg;
+        unsigned long clr_interrupt_mask_reg32;
         unsigned long sense_interrupt_mask_reg;
+        unsigned long sense_interrupt_mask_reg32;
         unsigned long clr_interrupt_reg;
+        unsigned long clr_interrupt_reg32;
 
         unsigned long sense_interrupt_reg;
+        unsigned long sense_interrupt_reg32;
         unsigned long ioarrin_reg;
         unsigned long sense_uproc_interrupt_reg;
+        unsigned long sense_uproc_interrupt_reg32;
         unsigned long set_uproc_interrupt_reg;
+        unsigned long set_uproc_interrupt_reg32;
         unsigned long clr_uproc_interrupt_reg;
+        unsigned long clr_uproc_interrupt_reg32;
+
+        unsigned long init_feedback_reg;
+
+        unsigned long dump_addr_reg;
+        unsigned long dump_data_reg;
 };
 
 struct ipr_interrupts {
         void __iomem *set_interrupt_mask_reg;
         void __iomem *clr_interrupt_mask_reg;
+        void __iomem *clr_interrupt_mask_reg32;
         void __iomem *sense_interrupt_mask_reg;
+        void __iomem *sense_interrupt_mask_reg32;
         void __iomem *clr_interrupt_reg;
+        void __iomem *clr_interrupt_reg32;
 
         void __iomem *sense_interrupt_reg;
+        void __iomem *sense_interrupt_reg32;
         void __iomem *ioarrin_reg;
         void __iomem *sense_uproc_interrupt_reg;
+        void __iomem *sense_uproc_interrupt_reg32;
         void __iomem *set_uproc_interrupt_reg;
+        void __iomem *set_uproc_interrupt_reg32;
         void __iomem *clr_uproc_interrupt_reg;
+        void __iomem *clr_uproc_interrupt_reg32;
+
+        void __iomem *init_feedback_reg;
+
+        void __iomem *dump_addr_reg;
+        void __iomem *dump_data_reg;
 };
 
 struct ipr_chip_cfg_t {
@@ -1029,6 +1273,9 @@ struct ipr_chip_t {
         u16 intr_type;
 #define IPR_USE_LSI                     0x00
 #define IPR_USE_MSI                     0x01
+        u16 sis_type;
+#define IPR_SIS32                       0x00
+#define IPR_SIS64                       0x01
         const struct ipr_chip_cfg_t *cfg;
 };
 
@@ -1073,13 +1320,6 @@ enum ipr_sdt_state {
         DUMP_OBTAINED
 };
 
-enum ipr_cache_state {
-        CACHE_NONE,
-        CACHE_DISABLED,
-        CACHE_ENABLED,
-        CACHE_INVALID
-};
-
 /* Per-controller data */
 struct ipr_ioa_cfg {
         char eye_catcher[8];
@@ -1099,10 +1339,17 @@ struct ipr_ioa_cfg {
         u8 dual_raid:1;
         u8 needs_warm_reset:1;
         u8 msi_received:1;
+        u8 sis64:1;
 
         u8 revid;
 
-        enum ipr_cache_state cache_state;
+        /*
+         * Bitmaps for SIS64 generated target values
+         */
+        unsigned long *target_ids;
+        unsigned long *array_ids;
+        unsigned long *vset_ids;
+
         u16 type; /* CCIN of the card */
 
         u8 log_level;
@@ -1133,8 +1380,13 @@ struct ipr_ioa_cfg {
 
         char cfg_table_start[8];
 #define IPR_CFG_TBL_START               "cfg"
-        struct ipr_config_table *cfg_table;
+        union {
+                struct ipr_config_table *cfg_table;
+                struct ipr_config_table64 *cfg_table64;
+        } u;
         dma_addr_t cfg_table_dma;
+        u32 cfg_table_size;
+        u32 max_devs_supported;
 
         char resource_table_label[8];
 #define IPR_RES_TABLE_LABEL             "res_tbl"
@@ -1202,13 +1454,17 @@ struct ipr_ioa_cfg {
         char ipr_cmd_label[8];
 #define IPR_CMD_LABEL           "ipr_cmd"
         struct ipr_cmnd *ipr_cmnd_list[IPR_NUM_CMD_BLKS];
-        u32 ipr_cmnd_list_dma[IPR_NUM_CMD_BLKS];
-};
+        dma_addr_t ipr_cmnd_list_dma[IPR_NUM_CMD_BLKS];
+}; /* struct ipr_ioa_cfg */
 
 struct ipr_cmnd {
         struct ipr_ioarcb ioarcb;
+        union {
+                struct ipr_ioadl_desc ioadl[IPR_NUM_IOADL_ENTRIES];
+                struct ipr_ioadl64_desc ioadl64[IPR_NUM_IOADL_ENTRIES];
+                struct ipr_ata64_ioadl ata_ioadl;
+        } i;
         struct ipr_ioasa ioasa;
-        struct ipr_ioadl_desc ioadl[IPR_NUM_IOADL_ENTRIES];
         struct list_head queue;
         struct scsi_cmnd *scsi_cmd;
         struct ata_queued_cmd *qc;
@@ -1221,7 +1477,7 @@ struct ipr_cmnd {
         u8 sense_buffer[SCSI_SENSE_BUFFERSIZE];
         dma_addr_t sense_buffer_dma;
         unsigned short dma_use_sg;
-        dma_addr_t dma_handle;
+        dma_addr_t dma_addr;
         struct ipr_cmnd *sibling;
         union {
                 enum ipr_shutdown_type shutdown_type;
@@ -1314,8 +1570,6 @@ struct ipr_ioa_dump {
         u32 next_page_index;
         u32 page_offset;
         u32 format;
-#define IPR_SDT_FMT2            2
-#define IPR_SDT_UNKNOWN         3
 }__attribute__((packed, aligned (4)));
 
 struct ipr_dump {
@@ -1377,6 +1631,13 @@ struct ipr_ucode_image_header {
 #define ipr_info(...) printk(KERN_INFO IPR_NAME ": "__VA_ARGS__)
 #define ipr_dbg(...) IPR_DBG_CMD(printk(KERN_INFO IPR_NAME ": "__VA_ARGS__))
 
+#define ipr_res_printk(level, ioa_cfg, bus, target, lun, fmt, ...) \
+        printk(level IPR_NAME ": %d:%d:%d:%d: " fmt, (ioa_cfg)->host->host_no, \
+                bus, target, lun, ##__VA_ARGS__)
+
+#define ipr_res_err(ioa_cfg, res, fmt, ...) \
+        ipr_res_printk(KERN_ERR, ioa_cfg, (res)->bus, (res)->target, (res)->lun, fmt, ##__VA_ARGS__)
+
 #define ipr_ra_printk(level, ioa_cfg, ra, fmt, ...) \
         printk(level IPR_NAME ": %d:%d:%d:%d: " fmt, (ioa_cfg)->host->host_no, \
                 (ra).bus, (ra).target, (ra).lun, ##__VA_ARGS__)
@@ -1384,9 +1645,6 @@ struct ipr_ucode_image_header {
 #define ipr_ra_err(ioa_cfg, ra, fmt, ...) \
         ipr_ra_printk(KERN_ERR, ioa_cfg, ra, fmt, ##__VA_ARGS__)
 
-#define ipr_res_err(ioa_cfg, res, fmt, ...) \
-        ipr_ra_err(ioa_cfg, (res)->cfgte.res_addr, fmt, ##__VA_ARGS__)
-
 #define ipr_phys_res_err(ioa_cfg, res, fmt, ...)                        \
 {                                                                       \
         if ((res).bus >= IPR_MAX_NUM_BUSES) {                           \
@@ -1399,14 +1657,21 @@ struct ipr_ucode_image_header {
 }
 
 #define ipr_hcam_err(hostrcb, fmt, ...)                                 \
-{                                                                                                       \
-        if (ipr_is_device(&(hostrcb)->hcam.u.error.failing_dev_res_addr)) {             \
-                ipr_ra_err((hostrcb)->ioa_cfg,                                                  \
-                                (hostrcb)->hcam.u.error.failing_dev_res_addr,                   \
-                                fmt, ##__VA_ARGS__);                                                    \
-        } else {                                                                                        \
-                dev_err(&(hostrcb)->ioa_cfg->pdev->dev, fmt, ##__VA_ARGS__);            \
-        }                                                                                               \
+{                                                                       \
+        if (ipr_is_device(hostrcb)) {                                   \
+                if ((hostrcb)->ioa_cfg->sis64) {                        \
+                        printk(KERN_ERR IPR_NAME ": %s: " fmt,          \
+                                ipr_format_resource_path(&hostrcb->hcam.u.error64.fd_res_path[0], \
+                                        &hostrcb->rp_buffer[0]),        \
+                                __VA_ARGS__);                           \
+                } else {                                                \
+                        ipr_ra_err((hostrcb)->ioa_cfg,                  \
+                                (hostrcb)->hcam.u.error.fd_res_addr,    \
+                                fmt, __VA_ARGS__);                      \
+                }                                                       \
+        } else {                                                        \
+                dev_err(&(hostrcb)->ioa_cfg->pdev->dev, fmt, __VA_ARGS__); \
+        }                                                               \
 }
 
 #define ipr_trace ipr_dbg("%s: %s: Line: %d\n",\
@@ -1432,7 +1697,7 @@ ipr_err("----------------------------------------------------------\n")
  **/
 static inline int ipr_is_ioa_resource(struct ipr_resource_entry *res)
 {
-        return (res->cfgte.flags & IPR_IS_IOA_RESOURCE) ? 1 : 0;
+        return res->type == IPR_RES_TYPE_IOAFP;
 }
 
 /**
@@ -1444,12 +1709,8 @@ static inline int ipr_is_ioa_resource(struct ipr_resource_entry *res)
  **/
 static inline int ipr_is_af_dasd_device(struct ipr_resource_entry *res)
 {
-        if (IPR_IS_DASD_DEVICE(res->cfgte.std_inq_data) &&
-            !ipr_is_ioa_resource(res) &&
-            IPR_RES_SUBTYPE(res) == IPR_SUBTYPE_AF_DASD)
-                return 1;
-        else
-                return 0;
+        return res->type == IPR_RES_TYPE_AF_DASD ||
+                res->type == IPR_RES_TYPE_REMOTE_AF_DASD;
 }
 
 /**
@@ -1461,12 +1722,7 @@ static inline int ipr_is_af_dasd_device(struct ipr_resource_entry *res)
  **/
 static inline int ipr_is_vset_device(struct ipr_resource_entry *res)
 {
-        if (IPR_IS_DASD_DEVICE(res->cfgte.std_inq_data) &&
-            !ipr_is_ioa_resource(res) &&
-            IPR_RES_SUBTYPE(res) == IPR_SUBTYPE_VOLUME_SET)
-                return 1;
-        else
-                return 0;
+        return res->type == IPR_RES_TYPE_VOLUME_SET;
 }
 
 /**
@@ -1478,11 +1734,7 @@ static inline int ipr_is_vset_device(struct ipr_resource_entry *res)
  **/
 static inline int ipr_is_gscsi(struct ipr_resource_entry *res)
 {
-        if (!ipr_is_ioa_resource(res) &&
-            IPR_RES_SUBTYPE(res) == IPR_SUBTYPE_GENERIC_SCSI)
-                return 1;
-        else
-                return 0;
+        return res->type == IPR_RES_TYPE_GENERIC_SCSI;
 }
 
 /**
@@ -1495,7 +1747,7 @@ static inline int ipr_is_gscsi(struct ipr_resource_entry *res)
 static inline int ipr_is_scsi_disk(struct ipr_resource_entry *res)
 {
         if (ipr_is_af_dasd_device(res) ||
-            (ipr_is_gscsi(res) && IPR_IS_DASD_DEVICE(res->cfgte.std_inq_data)))
+            (ipr_is_gscsi(res) && IPR_IS_DASD_DEVICE(res->std_inq_data)))
                 return 1;
         else
                 return 0;
@@ -1510,11 +1762,7 @@ static inline int ipr_is_scsi_disk(struct ipr_resource_entry *res)
  **/
 static inline int ipr_is_gata(struct ipr_resource_entry *res)
 {
-        if (!ipr_is_ioa_resource(res) &&
-            IPR_RES_SUBTYPE(res) == IPR_SUBTYPE_GENERIC_ATA)
-                return 1;
-        else
-                return 0;
+        return res->type == IPR_RES_TYPE_GENERIC_ATA;
 }
 
 /**
@@ -1526,24 +1774,35 @@ static inline int ipr_is_gata(struct ipr_resource_entry *res)
  **/
 static inline int ipr_is_naca_model(struct ipr_resource_entry *res)
 {
-        if (ipr_is_gscsi(res) && IPR_QUEUEING_MODEL(res) == IPR_QUEUE_NACA_MODEL)
+        if (ipr_is_gscsi(res) && res->qmodel == IPR_QUEUE_NACA_MODEL)
                 return 1;
         return 0;
 }
 
 /**
- * ipr_is_device - Determine if resource address is that of a device
- * @res_addr:   resource address struct
+ * ipr_is_device - Determine if the hostrcb structure is related to a device
+ * @hostrcb:    host resource control blocks struct
  *
  * Return value:
  *      1 if AF / 0 if not AF
  **/
-static inline int ipr_is_device(struct ipr_res_addr *res_addr)
+static inline int ipr_is_device(struct ipr_hostrcb *hostrcb)
 {
-        if ((res_addr->bus < IPR_MAX_NUM_BUSES) &&
-            (res_addr->target < (IPR_MAX_NUM_TARGETS_PER_BUS - 1)))
-                return 1;
-
+        struct ipr_res_addr *res_addr;
+        u8 *res_path;
+
+        if (hostrcb->ioa_cfg->sis64) {
+                res_path = &hostrcb->hcam.u.error64.fd_res_path[0];
+                if ((res_path[0] == 0x00 || res_path[0] == 0x80 ||
+                    res_path[0] == 0x81) && res_path[2] != 0xFF)
+                        return 1;
+        } else {
+                res_addr = &hostrcb->hcam.u.error.fd_res_addr;
+
+                if ((res_addr->bus < IPR_MAX_NUM_BUSES) &&
+                    (res_addr->target < (IPR_MAX_NUM_TARGETS_PER_BUS - 1)))
+                        return 1;
+        }
         return 0;
 }
 
diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
index edc49ca49cea..02143af7c1af 100644
--- a/drivers/scsi/iscsi_tcp.c
+++ b/drivers/scsi/iscsi_tcp.c
@@ -28,6 +28,7 @@
 
 #include <linux/types.h>
 #include <linux/inet.h>
+#include <linux/slab.h>
 #include <linux/file.h>
 #include <linux/blkdev.h>
 #include <linux/crypto.h>
@@ -584,9 +585,10 @@ static void iscsi_sw_tcp_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
         struct iscsi_conn *conn = cls_conn->dd_data;
         struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
         struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;
+        struct socket *sock = tcp_sw_conn->sock;
 
         /* userspace may have goofed up and not bound us */
-        if (!tcp_sw_conn->sock)
+        if (!sock)
                 return;
         /*
          * Make sure our recv side is stopped.
@@ -597,6 +599,11 @@ static void iscsi_sw_tcp_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
         set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
         write_unlock_bh(&tcp_sw_conn->sock->sk->sk_callback_lock);
 
+        if (sock->sk->sk_sleep) {
+                sock->sk->sk_err = EIO;
+                wake_up_interruptible(sock->sk->sk_sleep);
+        }
+
         iscsi_conn_stop(cls_conn, flag);
         iscsi_sw_tcp_release_conn(conn);
 }
@@ -868,7 +875,7 @@ static struct scsi_host_template iscsi_sw_tcp_sht = {
         .cmd_per_lun            = ISCSI_DEF_CMD_PER_LUN,
         .eh_abort_handler       = iscsi_eh_abort,
         .eh_device_reset_handler= iscsi_eh_device_reset,
-        .eh_target_reset_handler= iscsi_eh_target_reset,
+        .eh_target_reset_handler = iscsi_eh_recover_target,
         .use_clustering         = DISABLE_CLUSTERING,
         .slave_alloc            = iscsi_sw_tcp_slave_alloc,
         .slave_configure        = iscsi_sw_tcp_slave_configure,
@@ -903,7 +910,7 @@ static struct iscsi_transport iscsi_sw_tcp_transport = {
                                   ISCSI_USERNAME | ISCSI_PASSWORD |
                                   ISCSI_USERNAME_IN | ISCSI_PASSWORD_IN |
                                   ISCSI_FAST_ABORT | ISCSI_ABORT_TMO |
-                                  ISCSI_LU_RESET_TMO |
+                                  ISCSI_LU_RESET_TMO | ISCSI_TGT_RESET_TMO |
                                   ISCSI_PING_TMO | ISCSI_RECV_TMO |
                                   ISCSI_IFACE_NAME | ISCSI_INITIATOR_NAME,
         .host_param_mask        = ISCSI_HOST_HWADDRESS | ISCSI_HOST_IPADDRESS |
diff --git a/drivers/scsi/jazz_esp.c b/drivers/scsi/jazz_esp.c
index b2d481dd3750..08e26d4e3731 100644
--- a/drivers/scsi/jazz_esp.c
+++ b/drivers/scsi/jazz_esp.c
@@ -4,6 +4,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <linux/types.h>
 #include <linux/module.h>
 #include <linux/init.h>
diff --git a/drivers/scsi/lasi700.c b/drivers/scsi/lasi700.c
index b3d31315ac32..23880f8fe7e4 100644
--- a/drivers/scsi/lasi700.c
+++ b/drivers/scsi/lasi700.c
@@ -40,6 +40,7 @@
 #include <linux/blkdev.h>
 #include <linux/ioport.h>
 #include <linux/dma-mapping.h>
+#include <linux/slab.h>
 
 #include <asm/page.h>
 #include <asm/pgtable.h>
diff --git a/drivers/scsi/libfc/Makefile b/drivers/scsi/libfc/Makefile
index 55f982de3a9a..4bb23ac86a5c 100644
--- a/drivers/scsi/libfc/Makefile
+++ b/drivers/scsi/libfc/Makefile
@@ -3,10 +3,12 @@
 obj-$(CONFIG_LIBFC) += libfc.o
 
 libfc-objs := \
+        fc_libfc.o \
         fc_disc.o \
         fc_exch.o \
         fc_elsct.o \
         fc_frame.o \
         fc_lport.o \
         fc_rport.o \
-        fc_fcp.o
+        fc_fcp.o \
+        fc_npiv.o
diff --git a/drivers/scsi/libfc/fc_disc.c b/drivers/scsi/libfc/fc_disc.c
index c48799e9dd8e..1087a7f18e84 100644
--- a/drivers/scsi/libfc/fc_disc.c
+++ b/drivers/scsi/libfc/fc_disc.c
@@ -33,6 +33,7 @@
  */
 
 #include <linux/timer.h>
+#include <linux/slab.h>
 #include <linux/err.h>
 #include <asm/unaligned.h>
 
@@ -40,6 +41,8 @@
 
 #include <scsi/libfc.h>
 
+#include "fc_libfc.h"
+
 #define FC_DISC_RETRY_LIMIT     3       /* max retries */
 #define FC_DISC_RETRY_DELAY     500UL   /* (msecs) delay */
 
@@ -51,8 +54,8 @@ static int fc_disc_single(struct fc_lport *, struct fc_disc_port *);
 static void fc_disc_restart(struct fc_disc *);
 
 /**
- * fc_disc_stop_rports() - delete all the remote ports associated with the lport
- * @disc: The discovery job to stop rports on
+ * fc_disc_stop_rports() - Delete all the remote ports associated with the lport
+ * @disc: The discovery job to stop remote ports on
  *
  * Locking Note: This function expects that the lport mutex is locked before
  * calling it.
@@ -72,9 +75,9 @@ void fc_disc_stop_rports(struct fc_disc *disc)
 
 /**
  * fc_disc_recv_rscn_req() - Handle Registered State Change Notification (RSCN)
- * @sp: Current sequence of the RSCN exchange
- * @fp: RSCN Frame
- * @lport: Fibre Channel host port instance
+ * @sp:    The sequence of the RSCN exchange
+ * @fp:    The RSCN frame
+ * @lport: The local port that the request will be sent on
  *
  * Locking Note: This function expects that the disc_mutex is locked
  *               before it is called.
@@ -183,9 +186,9 @@ reject:
 
 /**
  * fc_disc_recv_req() - Handle incoming requests
- * @sp: Current sequence of the request exchange
- * @fp: The frame
- * @lport: The FC local port
+ * @sp:    The sequence of the request exchange
+ * @fp:    The request frame
+ * @lport: The local port receiving the request
  *
  * Locking Note: This function is called from the EM and will lock
  *               the disc_mutex before calling the handler for the
@@ -213,7 +216,7 @@ static void fc_disc_recv_req(struct fc_seq *sp, struct fc_frame *fp,
 
 /**
  * fc_disc_restart() - Restart discovery
- * @lport: FC discovery context
+ * @disc: The discovery object to be restarted
  *
  * Locking Note: This function expects that the disc mutex
  *               is already locked.
@@ -240,9 +243,9 @@ static void fc_disc_restart(struct fc_disc *disc)
 }
 
 /**
- * fc_disc_start() - Fibre Channel Target discovery
- * @lport: FC local port
- * @disc_callback: function to be called when discovery is complete
+ * fc_disc_start() - Start discovery on a local port
+ * @lport:         The local port to have discovery started on
+ * @disc_callback: Callback function to be called when discovery is complete
  */
 static void fc_disc_start(void (*disc_callback)(struct fc_lport *,
                                                 enum fc_disc_event),
@@ -263,8 +266,8 @@ static void fc_disc_start(void (*disc_callback)(struct fc_lport *,
 
 /**
  * fc_disc_done() - Discovery has been completed
- * @disc: FC discovery context
- * @event: discovery completion status
+ * @disc:  The discovery context
+ * @event: The discovery completion status
  *
  * Locking Note: This function expects that the disc mutex is locked before
  * it is called. The discovery callback is then made with the lock released,
@@ -284,8 +287,8 @@ static void fc_disc_done(struct fc_disc *disc, enum fc_disc_event event)
         }
 
         /*
-         * Go through all remote ports.  If they were found in the latest
-         * discovery, reverify or log them in.  Otherwise, log them out.
+         * Go through all remote ports.  If they were found in the latest
+         * discovery, reverify or log them in.  Otherwise, log them out.
          * Skip ports which were never discovered.  These are the dNS port
          * and ports which were created by PLOGI.
          */
@@ -305,8 +308,8 @@ static void fc_disc_done(struct fc_disc *disc, enum fc_disc_event event)
 
 /**
  * fc_disc_error() - Handle error on dNS request
- * @disc: FC discovery context
- * @fp: The frame pointer
+ * @disc: The discovery context
+ * @fp:   The error code encoded as a frame pointer
  */
 static void fc_disc_error(struct fc_disc *disc, struct fc_frame *fp)
 {
@@ -342,7 +345,7 @@ static void fc_disc_error(struct fc_disc *disc, struct fc_frame *fp)
 
 /**
  * fc_disc_gpn_ft_req() - Send Get Port Names by FC-4 type (GPN_FT) request
- * @lport: FC discovery context
+ * @lport: The discovery context
  *
  * Locking Note: This function expects that the disc_mutex is locked
  *               before it is called.
@@ -368,17 +371,17 @@ static void fc_disc_gpn_ft_req(struct fc_disc *disc)
         if (lport->tt.elsct_send(lport, 0, fp,
                                  FC_NS_GPN_FT,
                                  fc_disc_gpn_ft_resp,
-                                 disc, lport->e_d_tov))
+                                 disc, 3 * lport->r_a_tov))
                 return;
 err:
-        fc_disc_error(disc, fp);
+        fc_disc_error(disc, NULL);
 }
 
 /**
  * fc_disc_gpn_ft_parse() - Parse the body of the dNS GPN_FT response.
- * @lport: Fibre Channel host port instance
- * @buf: GPN_FT response buffer
- * @len: size of response buffer
+ * @lport: The local port the GPN_FT was received on
+ * @buf:   The GPN_FT response buffer
+ * @len:   The size of response buffer
  *
  * Goes through the list of IDs and names resulting from a request.
  */
@@ -477,10 +480,8 @@ static int fc_disc_gpn_ft_parse(struct fc_disc *disc, void *buf, size_t len)
 }
 
 /**
- * fc_disc_timeout() - Retry handler for the disc component
- * @work: Structure holding disc obj that needs retry discovery
- *
- * Handle retry of memory allocation for remote ports.
+ * fc_disc_timeout() - Handler for discovery timeouts
+ * @work: Structure holding discovery context that needs to retry discovery
  */
 static void fc_disc_timeout(struct work_struct *work)
 {
@@ -494,9 +495,9 @@ static void fc_disc_timeout(struct work_struct *work)
 
 /**
  * fc_disc_gpn_ft_resp() - Handle a response frame from Get Port Names (GPN_FT)
- * @sp: Current sequence of GPN_FT exchange
- * @fp: response frame
- * @lp_arg: Fibre Channel host port instance
+ * @sp:     The sequence that the GPN_FT response was received on
+ * @fp:     The GPN_FT response frame
+ * @lp_arg: The discovery context
  *
  * Locking Note: This function is called without disc mutex held, and
  *               should do all its processing with the mutex held
@@ -567,9 +568,9 @@ static void fc_disc_gpn_ft_resp(struct fc_seq *sp, struct fc_frame *fp,
 
 /**
  * fc_disc_gpn_id_resp() - Handle a response frame from Get Port Names (GPN_ID)
- * @sp: exchange sequence
- * @fp: response frame
- * @rdata_arg: remote port private data
+ * @sp:        The sequence the GPN_ID is on
+ * @fp:        The response frame
+ * @rdata_arg: The remote port that sent the GPN_ID response
  *
  * Locking Note: This function is called without disc mutex held.
  */
@@ -637,7 +638,7 @@ out:
 
 /**
  * fc_disc_gpn_id_req() - Send Get Port Names by ID (GPN_ID) request
- * @lport: local port
+ * @lport: The local port to initiate discovery on
  * @rdata: remote port private data
  *
  * Locking Note: This function expects that the disc_mutex is locked
@@ -654,7 +655,8 @@ static int fc_disc_gpn_id_req(struct fc_lport *lport,
         if (!fp)
                 return -ENOMEM;
         if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, FC_NS_GPN_ID,
-                                 fc_disc_gpn_id_resp, rdata, lport->e_d_tov))
+                                  fc_disc_gpn_id_resp, rdata,
+                                  3 * lport->r_a_tov))
                 return -ENOMEM;
         kref_get(&rdata->kref);
         return 0;
@@ -662,8 +664,8 @@ static int fc_disc_gpn_id_req(struct fc_lport *lport,
 
 /**
  * fc_disc_single() - Discover the directory information for a single target
- * @lport: local port
- * @dp: The port to rediscover
+ * @lport: The local port the remote port is associated with
+ * @dp:    The port to rediscover
  *
  * Locking Note: This function expects that the disc_mutex is locked
  *               before it is called.
@@ -681,7 +683,7 @@ static int fc_disc_single(struct fc_lport *lport, struct fc_disc_port *dp)
 
 /**
  * fc_disc_stop() - Stop discovery for a given lport
- * @lport: The lport that discovery should stop for
+ * @lport: The local port that discovery should stop on
  */
 void fc_disc_stop(struct fc_lport *lport)
 {
@@ -695,7 +697,7 @@ void fc_disc_stop(struct fc_lport *lport)
 
 /**
  * fc_disc_stop_final() - Stop discovery for a given lport
- * @lport: The lport that discovery should stop for
+ * @lport: The lport that discovery should stop on
  *
  * This function will block until discovery has been
  * completely stopped and all rports have been deleted.
@@ -707,8 +709,8 @@ void fc_disc_stop_final(struct fc_lport *lport)
 }
 
 /**
- * fc_disc_init() - Initialize the discovery block
- * @lport: FC local port
+ * fc_disc_init() - Initialize the discovery layer for a local port
+ * @lport: The local port that needs the discovery layer to be initialized
  */
 int fc_disc_init(struct fc_lport *lport)
 {
diff --git a/drivers/scsi/libfc/fc_elsct.c b/drivers/scsi/libfc/fc_elsct.c
index 5cfa68732e9d..53748724f2c5 100644
--- a/drivers/scsi/libfc/fc_elsct.c
+++ b/drivers/scsi/libfc/fc_elsct.c
@@ -28,17 +28,22 @@
 #include <scsi/libfc.h>
 #include <scsi/fc_encode.h>
 
-/*
- * fc_elsct_send - sends ELS/CT frame
+/**
+ * fc_elsct_send() - Send an ELS or CT frame
+ * @lport:      The local port to send the frame on
+ * @did:        The destination ID for the frame
+ * @fp:         The frame to be sent
+ * @op:         The operational code
+ * @resp:       The callback routine when the response is received
+ * @arg:        The argument to pass to the response callback routine
+ * @timer_msec: The timeout period for the frame (in msecs)
  */
-static struct fc_seq *fc_elsct_send(struct fc_lport *lport,
-                                    u32 did,
-                                    struct fc_frame *fp,
-                                    unsigned int op,
-                                    void (*resp)(struct fc_seq *,
-                                                 struct fc_frame *fp,
-                                                 void *arg),
-                                    void *arg, u32 timer_msec)
+struct fc_seq *fc_elsct_send(struct fc_lport *lport, u32 did,
+                             struct fc_frame *fp, unsigned int op,
+                             void (*resp)(struct fc_seq *,
+                                          struct fc_frame *,
+                                          void *),
+                             void *arg, u32 timer_msec)
 {
         enum fc_rctl r_ctl;
         enum fc_fh_type fh_type;
@@ -53,15 +58,22 @@ static struct fc_seq *fc_elsct_send(struct fc_lport *lport,
                 did = FC_FID_DIR_SERV;
         }
 
-        if (rc)
+        if (rc) {
+                fc_frame_free(fp);
                 return NULL;
+        }
 
         fc_fill_fc_hdr(fp, r_ctl, did, fc_host_port_id(lport->host), fh_type,
                        FC_FC_FIRST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
 
         return lport->tt.exch_seq_send(lport, fp, resp, NULL, arg, timer_msec);
 }
+EXPORT_SYMBOL(fc_elsct_send);
 
+/**
+ * fc_elsct_init() - Initialize the ELS/CT layer
+ * @lport: The local port to initialize the ELS/CT layer for
+ */
 int fc_elsct_init(struct fc_lport *lport)
 {
         if (!lport->tt.elsct_send)
@@ -72,12 +84,15 @@ int fc_elsct_init(struct fc_lport *lport)
 EXPORT_SYMBOL(fc_elsct_init);
 
 /**
- * fc_els_resp_type() - return string describing ELS response for debug.
- * @fp: frame pointer with possible error code.
+ * fc_els_resp_type() - Return a string describing the ELS response
+ * @fp: The frame pointer or possible error code
  */
 const char *fc_els_resp_type(struct fc_frame *fp)
 {
         const char *msg;
+        struct fc_frame_header *fh;
+        struct fc_ct_hdr *ct;
+
         if (IS_ERR(fp)) {
                 switch (-PTR_ERR(fp)) {
                 case FC_NO_ERR:
@@ -94,15 +109,41 @@ const char *fc_els_resp_type(struct fc_frame *fp)
                         break;
                 }
         } else {
-                switch (fc_frame_payload_op(fp)) {
-                case ELS_LS_ACC:
-                        msg = "accept";
+                fh = fc_frame_header_get(fp);
+                switch (fh->fh_type) {
+                case FC_TYPE_ELS:
+                        switch (fc_frame_payload_op(fp)) {
+                        case ELS_LS_ACC:
+                                msg = "accept";
+                                break;
+                        case ELS_LS_RJT:
+                                msg = "reject";
+                                break;
+                        default:
+                                msg = "response unknown ELS";
+                                break;
+                        }
                         break;
-                case ELS_LS_RJT:
-                        msg = "reject";
+                case FC_TYPE_CT:
+                        ct = fc_frame_payload_get(fp, sizeof(*ct));
+                        if (ct) {
+                                switch (ntohs(ct->ct_cmd)) {
+                                case FC_FS_ACC:
+                                        msg = "CT accept";
+                                        break;
+                                case FC_FS_RJT:
+                                        msg = "CT reject";
+                                        break;
+                                default:
+                                        msg = "response unknown CT";
+                                        break;
+                                }
+                        } else {
+                                msg = "short CT response";
+                        }
                         break;
                 default:
-                        msg = "response unknown ELS";
+                        msg = "response not ELS or CT";
                         break;
                 }
         }
diff --git a/drivers/scsi/libfc/fc_exch.c b/drivers/scsi/libfc/fc_exch.c
index c1c15748220c..e5df0d4db67e 100644
--- a/drivers/scsi/libfc/fc_exch.c
+++ b/drivers/scsi/libfc/fc_exch.c
@@ -24,7 +24,7 @@
  */
 
 #include <linux/timer.h>
-#include <linux/gfp.h>
+#include <linux/slab.h>
 #include <linux/err.h>
 
 #include <scsi/fc/fc_fc2.h>
@@ -32,10 +32,13 @@
 #include <scsi/libfc.h>
 #include <scsi/fc_encode.h>
 
+#include "fc_libfc.h"
+
 u16     fc_cpu_mask;            /* cpu mask for possible cpus */
 EXPORT_SYMBOL(fc_cpu_mask);
 static u16      fc_cpu_order;   /* 2's power to represent total possible cpus */
-static struct kmem_cache *fc_em_cachep;        /* cache for exchanges */
+static struct kmem_cache *fc_em_cachep;        /* cache for exchanges */
+struct workqueue_struct *fc_exch_workqueue;
 
 /*
  * Structure and function definitions for managing Fibre Channel Exchanges
@@ -50,35 +53,46 @@ static struct kmem_cache *fc_em_cachep;        /* cache for exchanges */
  * fc_seq holds the state for an individual sequence.
  */
 
-/*
- * Per cpu exchange pool
+/**
+ * struct fc_exch_pool - Per cpu exchange pool
+ * @next_index:   Next possible free exchange index
+ * @total_exches: Total allocated exchanges
+ * @lock:         Exch pool lock
+ * @ex_list:      List of exchanges
  *
  * This structure manages per cpu exchanges in array of exchange pointers.
  * This array is allocated followed by struct fc_exch_pool memory for
  * assigned range of exchanges to per cpu pool.
  */
 struct fc_exch_pool {
-        u16             next_index;     /* next possible free exchange index */
-        u16             total_exches;   /* total allocated exchanges */
-        spinlock_t      lock;           /* exch pool lock */
-        struct list_head        ex_list;        /* allocated exchanges list */
+        u16              next_index;
+        u16              total_exches;
+        spinlock_t       lock;
+        struct list_head ex_list;
 };
 
-/*
- * Exchange manager.
+/**
+ * struct fc_exch_mgr - The Exchange Manager (EM).
+ * @class:          Default class for new sequences
+ * @kref:           Reference counter
+ * @min_xid:        Minimum exchange ID
+ * @max_xid:        Maximum exchange ID
+ * @ep_pool:        Reserved exchange pointers
+ * @pool_max_index: Max exch array index in exch pool
+ * @pool:           Per cpu exch pool
+ * @stats:          Statistics structure
  *
  * This structure is the center for creating exchanges and sequences.
  * It manages the allocation of exchange IDs.
  */
 struct fc_exch_mgr {
-        enum fc_class   class;          /* default class for sequences */
-        struct kref     kref;           /* exchange mgr reference count */
-        u16             min_xid;        /* min exchange ID */
-        u16             max_xid;        /* max exchange ID */
-        struct list_head        ex_list;        /* allocated exchanges list */
-        mempool_t       *ep_pool;       /* reserve ep's */
-        u16             pool_max_index; /* max exch array index in exch pool */
-        struct fc_exch_pool *pool;      /* per cpu exch pool */
+        enum fc_class   class;
+        struct kref     kref;
+        u16             min_xid;
+        u16             max_xid;
+        mempool_t       *ep_pool;
+        u16             pool_max_index;
+        struct fc_exch_pool *pool;
 
         /*
          * currently exchange mgr stats are updated but not used.
@@ -96,6 +110,18 @@ struct fc_exch_mgr {
 };
 #define fc_seq_exch(sp) container_of(sp, struct fc_exch, seq)
 
+/**
+ * struct fc_exch_mgr_anchor - primary structure for list of EMs
+ * @ema_list: Exchange Manager Anchor list
+ * @mp:       Exchange Manager associated with this anchor
+ * @match:    Routine to determine if this anchor's EM should be used
+ *
+ * When walking the list of anchors the match routine will be called
+ * for each anchor to determine if that EM should be used. The last
+ * anchor in the list will always match to handle any exchanges not
+ * handled by other EMs. The non-default EMs would be added to the
+ * anchor list by HW that provides FCoE offloads.
+ */
 struct fc_exch_mgr_anchor {
         struct list_head ema_list;
         struct fc_exch_mgr *mp;
@@ -108,7 +134,6 @@ static void fc_seq_ls_rjt(struct fc_seq *, enum fc_els_rjt_reason,
                           enum fc_els_rjt_explan);
 static void fc_exch_els_rec(struct fc_seq *, struct fc_frame *);
 static void fc_exch_els_rrq(struct fc_seq *, struct fc_frame *);
-static struct fc_seq *fc_seq_start_next_locked(struct fc_seq *sp);
 
 /*
  * Internal implementation notes.
@@ -196,6 +221,15 @@ static char *fc_exch_rctl_names[] = FC_RCTL_NAMES_INIT;
 
 #define FC_TABLE_SIZE(x)   (sizeof(x) / sizeof(x[0]))
 
+/**
+ * fc_exch_name_lookup() - Lookup name by opcode
+ * @op:        Opcode to be looked up
+ * @table:     Opcode/name table
+ * @max_index: Index not to be exceeded
+ *
+ * This routine is used to determine a human-readable string identifying
+ * a R_CTL opcode.
+ */
 static inline const char *fc_exch_name_lookup(unsigned int op, char **table,
                                               unsigned int max_index)
 {
@@ -208,25 +242,34 @@ static inline const char *fc_exch_name_lookup(unsigned int op, char **table,
         return name;
 }
 
+/**
+ * fc_exch_rctl_name() - Wrapper routine for fc_exch_name_lookup()
+ * @op: The opcode to be looked up
+ */
 static const char *fc_exch_rctl_name(unsigned int op)
 {
         return fc_exch_name_lookup(op, fc_exch_rctl_names,
                                    FC_TABLE_SIZE(fc_exch_rctl_names));
 }
 
-/*
- * Hold an exchange - keep it from being freed.
+/**
+ * fc_exch_hold() - Increment an exchange's reference count
+ * @ep: Echange to be held
  */
-static void fc_exch_hold(struct fc_exch *ep)
+static inline void fc_exch_hold(struct fc_exch *ep)
 {
         atomic_inc(&ep->ex_refcnt);
 }
 
-/*
- * setup fc hdr by initializing few more FC header fields and sof/eof.
- * Initialized fields by this func:
- *      - fh_ox_id, fh_rx_id, fh_seq_id, fh_seq_cnt
- *      - sof and eof
+/**
+ * fc_exch_setup_hdr() - Initialize a FC header by initializing some fields
+ *                       and determine SOF and EOF.
+ * @ep:    The exchange to that will use the header
+ * @fp:    The frame whose header is to be modified
+ * @f_ctl: F_CTL bits that will be used for the frame header
+ *
+ * The fields initialized by this routine are: fh_ox_id, fh_rx_id,
+ * fh_seq_id, fh_seq_cnt and the SOF and EOF.
  */
 static void fc_exch_setup_hdr(struct fc_exch *ep, struct fc_frame *fp,
                               u32 f_ctl)
@@ -243,7 +286,7 @@ static void fc_exch_setup_hdr(struct fc_exch *ep, struct fc_frame *fp,
                 if (fc_sof_needs_ack(ep->class))
                         fr_eof(fp) = FC_EOF_N;
                 /*
-                 * Form f_ctl.
+                 * From F_CTL.
                  * The number of fill bytes to make the length a 4-byte
                  * multiple is the low order 2-bits of the f_ctl.
                  * The fill itself will have been cleared by the frame
@@ -273,10 +316,12 @@ static void fc_exch_setup_hdr(struct fc_exch *ep, struct fc_frame *fp,
         fh->fh_seq_cnt = htons(ep->seq.cnt);
 }
 
-
-/*
- * Release a reference to an exchange.
- * If the refcnt goes to zero and the exchange is complete, it is freed.
+/**
+ * fc_exch_release() - Decrement an exchange's reference count
+ * @ep: Exchange to be released
+ *
+ * If the reference count reaches zero and the exchange is complete,
+ * it is freed.
  */
 static void fc_exch_release(struct fc_exch *ep)
 {
@@ -291,6 +336,10 @@ static void fc_exch_release(struct fc_exch *ep)
         }
 }
 
+/**
+ * fc_exch_done_locked() - Complete an exchange with the exchange lock held
+ * @ep: The exchange that is complete
+ */
 static int fc_exch_done_locked(struct fc_exch *ep)
 {
         int rc = 1;
@@ -315,6 +364,15 @@ static int fc_exch_done_locked(struct fc_exch *ep)
         return rc;
 }
 
+/**
+ * fc_exch_ptr_get() - Return an exchange from an exchange pool
+ * @pool:  Exchange Pool to get an exchange from
+ * @index: Index of the exchange within the pool
+ *
+ * Use the index to get an exchange from within an exchange pool. exches
+ * will point to an array of exchange pointers. The index will select
+ * the exchange within the array.
+ */
 static inline struct fc_exch *fc_exch_ptr_get(struct fc_exch_pool *pool,
                                               u16 index)
 {
@@ -322,12 +380,22 @@ static inline struct fc_exch *fc_exch_ptr_get(struct fc_exch_pool *pool,
         return exches[index];
 }
 
+/**
+ * fc_exch_ptr_set() - Assign an exchange to a slot in an exchange pool
+ * @pool:  The pool to assign the exchange to
+ * @index: The index in the pool where the exchange will be assigned
+ * @ep:    The exchange to assign to the pool
+ */
 static inline void fc_exch_ptr_set(struct fc_exch_pool *pool, u16 index,
                                    struct fc_exch *ep)
 {
         ((struct fc_exch **)(pool + 1))[index] = ep;
 }
 
+/**
+ * fc_exch_delete() - Delete an exchange
+ * @ep: The exchange to be deleted
+ */
 static void fc_exch_delete(struct fc_exch *ep)
 {
         struct fc_exch_pool *pool;
@@ -343,8 +411,14 @@ static void fc_exch_delete(struct fc_exch *ep)
         fc_exch_release(ep);    /* drop hold for exch in mp */
 }
 
-/*
- * Internal version of fc_exch_timer_set - used with lock held.
+/**
+ * fc_exch_timer_set_locked() - Start a timer for an exchange w/ the
+ *                              the exchange lock held
+ * @ep:         The exchange whose timer will start
+ * @timer_msec: The timeout period
+ *
+ * Used for upper level protocols to time out the exchange.
+ * The timer is cancelled when it fires or when the exchange completes.
  */
 static inline void fc_exch_timer_set_locked(struct fc_exch *ep,
                                             unsigned int timer_msec)
@@ -354,17 +428,15 @@ static inline void fc_exch_timer_set_locked(struct fc_exch *ep,
 
         FC_EXCH_DBG(ep, "Exchange timer armed\n");
 
-        if (schedule_delayed_work(&ep->timeout_work,
-                                  msecs_to_jiffies(timer_msec)))
+        if (queue_delayed_work(fc_exch_workqueue, &ep->timeout_work,
+                               msecs_to_jiffies(timer_msec)))
                 fc_exch_hold(ep);               /* hold for timer */
 }
 
-/*
- * Set timer for an exchange.
- * The time is a minimum delay in milliseconds until the timer fires.
- * Used for upper level protocols to time out the exchange.
- * The timer is cancelled when it fires or when the exchange completes.
- * Returns non-zero if a timer couldn't be allocated.
+/**
+ * fc_exch_timer_set() - Lock the exchange and set the timer
+ * @ep:         The exchange whose timer will start
+ * @timer_msec: The timeout period
  */
 static void fc_exch_timer_set(struct fc_exch *ep, unsigned int timer_msec)
 {
@@ -373,7 +445,115 @@ static void fc_exch_timer_set(struct fc_exch *ep, unsigned int timer_msec)
         spin_unlock_bh(&ep->ex_lock);
 }
 
-int fc_seq_exch_abort(const struct fc_seq *req_sp, unsigned int timer_msec)
+/**
+ * fc_seq_send() - Send a frame using existing sequence/exchange pair
+ * @lport: The local port that the exchange will be sent on
+ * @sp:    The sequence to be sent
+ * @fp:    The frame to be sent on the exchange
+ */
+static int fc_seq_send(struct fc_lport *lport, struct fc_seq *sp,
+                       struct fc_frame *fp)
+{
+        struct fc_exch *ep;
+        struct fc_frame_header *fh = fc_frame_header_get(fp);
+        int error;
+        u32 f_ctl;
+
+        ep = fc_seq_exch(sp);
+        WARN_ON((ep->esb_stat & ESB_ST_SEQ_INIT) != ESB_ST_SEQ_INIT);
+
+        f_ctl = ntoh24(fh->fh_f_ctl);
+        fc_exch_setup_hdr(ep, fp, f_ctl);
+
+        /*
+         * update sequence count if this frame is carrying
+         * multiple FC frames when sequence offload is enabled
+         * by LLD.
+         */
+        if (fr_max_payload(fp))
+                sp->cnt += DIV_ROUND_UP((fr_len(fp) - sizeof(*fh)),
+                                        fr_max_payload(fp));
+        else
+                sp->cnt++;
+
+        /*
+         * Send the frame.
+         */
+        error = lport->tt.frame_send(lport, fp);
+
+        /*
+         * Update the exchange and sequence flags,
+         * assuming all frames for the sequence have been sent.
+         * We can only be called to send once for each sequence.
+         */
+        spin_lock_bh(&ep->ex_lock);
+        ep->f_ctl = f_ctl & ~FC_FC_FIRST_SEQ;   /* not first seq */
+        if (f_ctl & (FC_FC_END_SEQ | FC_FC_SEQ_INIT))
+                ep->esb_stat &= ~ESB_ST_SEQ_INIT;
+        spin_unlock_bh(&ep->ex_lock);
+        return error;
+}
+
+/**
+ * fc_seq_alloc() - Allocate a sequence for a given exchange
+ * @ep:     The exchange to allocate a new sequence for
+ * @seq_id: The sequence ID to be used
+ *
+ * We don't support multiple originated sequences on the same exchange.
+ * By implication, any previously originated sequence on this exchange
+ * is complete, and we reallocate the same sequence.
+ */
+static struct fc_seq *fc_seq_alloc(struct fc_exch *ep, u8 seq_id)
+{
+        struct fc_seq *sp;
+
+        sp = &ep->seq;
+        sp->ssb_stat = 0;
+        sp->cnt = 0;
+        sp->id = seq_id;
+        return sp;
+}
+
+/**
+ * fc_seq_start_next_locked() - Allocate a new sequence on the same
+ *                              exchange as the supplied sequence
+ * @sp: The sequence/exchange to get a new sequence for
+ */
+static struct fc_seq *fc_seq_start_next_locked(struct fc_seq *sp)
+{
+        struct fc_exch *ep = fc_seq_exch(sp);
+
+        sp = fc_seq_alloc(ep, ep->seq_id++);
+        FC_EXCH_DBG(ep, "f_ctl %6x seq %2x\n",
+                    ep->f_ctl, sp->id);
+        return sp;
+}
+
+/**
+ * fc_seq_start_next() - Lock the exchange and get a new sequence
+ *                       for a given sequence/exchange pair
+ * @sp: The sequence/exchange to get a new exchange for
+ */
+static struct fc_seq *fc_seq_start_next(struct fc_seq *sp)
+{
+        struct fc_exch *ep = fc_seq_exch(sp);
+
+        spin_lock_bh(&ep->ex_lock);
+        sp = fc_seq_start_next_locked(sp);
+        spin_unlock_bh(&ep->ex_lock);
+
+        return sp;
+}
+
+/**
+ * fc_seq_exch_abort() - Abort an exchange and sequence
+ * @req_sp:     The sequence to be aborted
+ * @timer_msec: The period of time to wait before aborting
+ *
+ * Generally called because of a timeout or an abort from the upper layer.
+ */
+static int fc_seq_exch_abort(const struct fc_seq *req_sp,
+                             unsigned int timer_msec)
 {
         struct fc_seq *sp;
         struct fc_exch *ep;
@@ -422,11 +602,10 @@ int fc_seq_exch_abort(const struct fc_seq *req_sp, unsigned int timer_msec)
                 error = -ENOBUFS;
         return error;
 }
-EXPORT_SYMBOL(fc_seq_exch_abort);
 
-/*
- * Exchange timeout - handle exchange timer expiration.
- * The timer will have been cancelled before this is called.
+/**
+ * fc_exch_timeout() - Handle exchange timer expiration
+ * @work: The work_struct identifying the exchange that timed out
  */
 static void fc_exch_timeout(struct work_struct *work)
 {
@@ -474,28 +653,10 @@ done:
         fc_exch_release(ep);
 }
 
-/*
- * Allocate a sequence.
- *
- * We don't support multiple originated sequences on the same exchange.
- * By implication, any previously originated sequence on this exchange
- * is complete, and we reallocate the same sequence.
- */
-static struct fc_seq *fc_seq_alloc(struct fc_exch *ep, u8 seq_id)
-{
-        struct fc_seq *sp;
-
-        sp = &ep->seq;
-        sp->ssb_stat = 0;
-        sp->cnt = 0;
-        sp->id = seq_id;
-        return sp;
-}
-
 /**
- * fc_exch_em_alloc() - allocate an exchange from a specified EM.
- * @lport:      ptr to the local port
- * @mp:         ptr to the exchange manager
+ * fc_exch_em_alloc() - Allocate an exchange from a specified EM.
+ * @lport: The local port that the exchange is for
+ * @mp:    The exchange manager that will allocate the exchange
  *
  * Returns pointer to allocated fc_exch with exch lock held.
  */
@@ -563,16 +724,18 @@ err:
 }
 
 /**
- * fc_exch_alloc() - allocate an exchange.
- * @lport:      ptr to the local port
- * @fp:         ptr to the FC frame
+ * fc_exch_alloc() - Allocate an exchange from an EM on a
+ *                   local port's list of EMs.
+ * @lport: The local port that will own the exchange
+ * @fp:    The FC frame that the exchange will be for
  *
- * This function walks the list of the exchange manager(EM)
- * anchors to select a EM for new exchange allocation. The
- * EM is selected having either a NULL match function pointer
- * or call to match function returning true.
+ * This function walks the list of exchange manager(EM)
+ * anchors to select an EM for a new exchange allocation. The
+ * EM is selected when a NULL match function pointer is encountered
+ * or when a call to a match function returns true.
  */
-struct fc_exch *fc_exch_alloc(struct fc_lport *lport, struct fc_frame *fp)
+static struct fc_exch *fc_exch_alloc(struct fc_lport *lport,
+                                     struct fc_frame *fp)
 {
         struct fc_exch_mgr_anchor *ema;
         struct fc_exch *ep;
@@ -586,10 +749,11 @@ struct fc_exch *fc_exch_alloc(struct fc_lport *lport, struct fc_frame *fp)
         }
         return NULL;
 }
-EXPORT_SYMBOL(fc_exch_alloc);
 
-/*
- * Lookup and hold an exchange.
+/**
+ * fc_exch_find() - Lookup and hold an exchange
+ * @mp:  The exchange manager to lookup the exchange from
+ * @xid: The XID of the exchange to look up
  */
 static struct fc_exch *fc_exch_find(struct fc_exch_mgr *mp, u16 xid)
 {
@@ -609,7 +773,13 @@ static struct fc_exch *fc_exch_find(struct fc_exch_mgr *mp, u16 xid)
         return ep;
 }
 
-void fc_exch_done(struct fc_seq *sp)
+
+/**
+ * fc_exch_done() - Indicate that an exchange/sequence tuple is complete and
+ *                  the memory allocated for the related objects may be freed.
+ * @sp: The sequence that has completed
+ */
+static void fc_exch_done(struct fc_seq *sp)
 {
         struct fc_exch *ep = fc_seq_exch(sp);
         int rc;
@@ -620,10 +790,13 @@ void fc_exch_done(struct fc_seq *sp)
         if (!rc)
                 fc_exch_delete(ep);
 }
-EXPORT_SYMBOL(fc_exch_done);
 
-/*
- * Allocate a new exchange as responder.
+/**
+ * fc_exch_resp() - Allocate a new exchange for a response frame
+ * @lport: The local port that the exchange was for
+ * @mp:    The exchange manager to allocate the exchange from
+ * @fp:    The response frame
+ *
  * Sets the responder ID in the frame header.
  */
 static struct fc_exch *fc_exch_resp(struct fc_lport *lport,
@@ -664,8 +837,13 @@ static struct fc_exch *fc_exch_resp(struct fc_lport *lport,
         return ep;
 }
 
-/*
- * Find a sequence for receive where the other end is originating the sequence.
+/**
+ * fc_seq_lookup_recip() - Find a sequence where the other end
+ *                         originated the sequence
+ * @lport: The local port that the frame was sent to
+ * @mp:    The Exchange Manager to lookup the exchange from
+ * @fp:    The frame associated with the sequence we're looking for
+ *
  * If fc_pf_rjt_reason is FC_RJT_NONE then this function will have a hold
  * on the ep that should be released by the caller.
  */
@@ -771,10 +949,12 @@ rel:
         return reject;
 }
 
-/*
- * Find the sequence for a frame being received.
- * We originated the sequence, so it should be found.
- * We may or may not have originated the exchange.
+/**
+ * fc_seq_lookup_orig() - Find a sequence where this end
+ *                        originated the sequence
+ * @mp:    The Exchange Manager to lookup the exchange from
+ * @fp:    The frame associated with the sequence we're looking for
+ *
  * Does not hold the sequence for the caller.
  */
 static struct fc_seq *fc_seq_lookup_orig(struct fc_exch_mgr *mp,
@@ -806,8 +986,12 @@ static struct fc_seq *fc_seq_lookup_orig(struct fc_exch_mgr *mp,
         return sp;
 }
 
-/*
- * Set addresses for an exchange.
+/**
+ * fc_exch_set_addr() - Set the source and destination IDs for an exchange
+ * @ep:      The exchange to set the addresses for
+ * @orig_id: The originator's ID
+ * @resp_id: The responder's ID
+ *
  * Note this must be done before the first sequence of the exchange is sent.
  */
 static void fc_exch_set_addr(struct fc_exch *ep,
@@ -823,76 +1007,15 @@ static void fc_exch_set_addr(struct fc_exch *ep,
         }
 }
 
-static struct fc_seq *fc_seq_start_next_locked(struct fc_seq *sp)
-{
-        struct fc_exch *ep = fc_seq_exch(sp);
-
-        sp = fc_seq_alloc(ep, ep->seq_id++);
-        FC_EXCH_DBG(ep, "f_ctl %6x seq %2x\n",
-                    ep->f_ctl, sp->id);
-        return sp;
-}
-/*
- * Allocate a new sequence on the same exchange as the supplied sequence.
- * This will never return NULL.
+/**
+ * fc_seq_els_rsp_send() - Send an ELS response using infomation from
+ *                         the existing sequence/exchange.
+ * @sp:       The sequence/exchange to get information from
+ * @els_cmd:  The ELS command to be sent
+ * @els_data: The ELS data to be sent
  */
-struct fc_seq *fc_seq_start_next(struct fc_seq *sp)
-{
-        struct fc_exch *ep = fc_seq_exch(sp);
-
-        spin_lock_bh(&ep->ex_lock);
-        sp = fc_seq_start_next_locked(sp);
-        spin_unlock_bh(&ep->ex_lock);
-
-        return sp;
-}
-EXPORT_SYMBOL(fc_seq_start_next);
-
-int fc_seq_send(struct fc_lport *lp, struct fc_seq *sp, struct fc_frame *fp)
-{
-        struct fc_exch *ep;
-        struct fc_frame_header *fh = fc_frame_header_get(fp);
-        int error;
-        u32     f_ctl;
-
-        ep = fc_seq_exch(sp);
-        WARN_ON((ep->esb_stat & ESB_ST_SEQ_INIT) != ESB_ST_SEQ_INIT);
-
-        f_ctl = ntoh24(fh->fh_f_ctl);
-        fc_exch_setup_hdr(ep, fp, f_ctl);
-
-        /*
-         * update sequence count if this frame is carrying
-         * multiple FC frames when sequence offload is enabled
-         * by LLD.
-         */
-        if (fr_max_payload(fp))
-                sp->cnt += DIV_ROUND_UP((fr_len(fp) - sizeof(*fh)),
-                                        fr_max_payload(fp));
-        else
-                sp->cnt++;
-
-        /*
-         * Send the frame.
-         */
-        error = lp->tt.frame_send(lp, fp);
-
-        /*
-         * Update the exchange and sequence flags,
-         * assuming all frames for the sequence have been sent.
-         * We can only be called to send once for each sequence.
-         */
-        spin_lock_bh(&ep->ex_lock);
-        ep->f_ctl = f_ctl & ~FC_FC_FIRST_SEQ;   /* not first seq */
-        if (f_ctl & (FC_FC_END_SEQ | FC_FC_SEQ_INIT))
-                ep->esb_stat &= ~ESB_ST_SEQ_INIT;
-        spin_unlock_bh(&ep->ex_lock);
-        return error;
-}
-EXPORT_SYMBOL(fc_seq_send);
-
-void fc_seq_els_rsp_send(struct fc_seq *sp, enum fc_els_cmd els_cmd,
-                         struct fc_seq_els_data *els_data)
+static void fc_seq_els_rsp_send(struct fc_seq *sp, enum fc_els_cmd els_cmd,
+                                struct fc_seq_els_data *els_data)
 {
         switch (els_cmd) {
         case ELS_LS_RJT:
@@ -911,10 +1034,13 @@ void fc_seq_els_rsp_send(struct fc_seq *sp, enum fc_els_cmd els_cmd,
                 FC_EXCH_DBG(fc_seq_exch(sp), "Invalid ELS CMD:%x\n", els_cmd);
         }
 }
-EXPORT_SYMBOL(fc_seq_els_rsp_send);
 
-/*
- * Send a sequence, which is also the last sequence in the exchange.
+/**
+ * fc_seq_send_last() - Send a sequence that is the last in the exchange
+ * @sp:      The sequence that is to be sent
+ * @fp:      The frame that will be sent on the sequence
+ * @rctl:    The R_CTL information to be sent
+ * @fh_type: The frame header type
  */
 static void fc_seq_send_last(struct fc_seq *sp, struct fc_frame *fp,
                              enum fc_rctl rctl, enum fc_fh_type fh_type)
@@ -928,9 +1054,12 @@ static void fc_seq_send_last(struct fc_seq *sp, struct fc_frame *fp,
         fc_seq_send(ep->lp, sp, fp);
 }
 
-/*
+/**
+ * fc_seq_send_ack() - Send an acknowledgement that we've received a frame
+ * @sp:    The sequence to send the ACK on
+ * @rx_fp: The received frame that is being acknoledged
+ *
  * Send ACK_1 (or equiv.) indicating we received something.
- * The frame we're acking is supplied.
  */
 static void fc_seq_send_ack(struct fc_seq *sp, const struct fc_frame *rx_fp)
 {
@@ -938,14 +1067,14 @@ static void fc_seq_send_ack(struct fc_seq *sp, const struct fc_frame *rx_fp)
         struct fc_frame_header *rx_fh;
         struct fc_frame_header *fh;
         struct fc_exch *ep = fc_seq_exch(sp);
-        struct fc_lport *lp = ep->lp;
+        struct fc_lport *lport = ep->lp;
         unsigned int f_ctl;
 
         /*
          * Don't send ACKs for class 3.
          */
         if (fc_sof_needs_ack(fr_sof(rx_fp))) {
-                fp = fc_frame_alloc(lp, 0);
+                fp = fc_frame_alloc(lport, 0);
                 if (!fp)
                         return;
 
@@ -980,12 +1109,16 @@ static void fc_seq_send_ack(struct fc_seq *sp, const struct fc_frame *rx_fp)
                 else
                         fr_eof(fp) = FC_EOF_N;
 
-                (void) lp->tt.frame_send(lp, fp);
+                lport->tt.frame_send(lport, fp);
         }
 }
 
-/*
- * Send BLS Reject.
+/**
+ * fc_exch_send_ba_rjt() - Send BLS Reject
+ * @rx_fp:  The frame being rejected
+ * @reason: The reason the frame is being rejected
+ * @explan: The explaination for the rejection
+ *
  * This is for rejecting BA_ABTS only.
  */
 static void fc_exch_send_ba_rjt(struct fc_frame *rx_fp,
@@ -996,11 +1129,11 @@ static void fc_exch_send_ba_rjt(struct fc_frame *rx_fp,
         struct fc_frame_header *rx_fh;
         struct fc_frame_header *fh;
         struct fc_ba_rjt *rp;
-        struct fc_lport *lp;
+        struct fc_lport *lport;
         unsigned int f_ctl;
 
-        lp = fr_dev(rx_fp);
-        fp = fc_frame_alloc(lp, sizeof(*rp));
+        lport = fr_dev(rx_fp);
+        fp = fc_frame_alloc(lport, sizeof(*rp));
         if (!fp)
                 return;
         fh = fc_frame_header_get(fp);
@@ -1045,13 +1178,17 @@ static void fc_exch_send_ba_rjt(struct fc_frame *rx_fp,
         if (fc_sof_needs_ack(fr_sof(fp)))
                 fr_eof(fp) = FC_EOF_N;
 
-        (void) lp->tt.frame_send(lp, fp);
+        lport->tt.frame_send(lport, fp);
 }
 
-/*
- * Handle an incoming ABTS.  This would be for target mode usually,
- * but could be due to lost FCP transfer ready, confirm or RRQ.
- * We always handle this as an exchange abort, ignoring the parameter.
+/**
+ * fc_exch_recv_abts() - Handle an incoming ABTS
+ * @ep:    The exchange the abort was on
+ * @rx_fp: The ABTS frame
+ *
+ * This would be for target mode usually, but could be due to lost
+ * FCP transfer ready, confirm or RRQ. We always handle this as an
+ * exchange abort, ignoring the parameter.
  */
 static void fc_exch_recv_abts(struct fc_exch *ep, struct fc_frame *rx_fp)
 {
@@ -1100,10 +1237,14 @@ free:
         fc_frame_free(rx_fp);
 }
 
-/*
- * Handle receive where the other end is originating the sequence.
+/**
+ * fc_exch_recv_req() - Handler for an incoming request where is other
+ *                      end is originating the sequence
+ * @lport: The local port that received the request
+ * @mp:    The EM that the exchange is on
+ * @fp:    The request frame
  */
-static void fc_exch_recv_req(struct fc_lport *lp, struct fc_exch_mgr *mp,
+static void fc_exch_recv_req(struct fc_lport *lport, struct fc_exch_mgr *mp,
                              struct fc_frame *fp)
 {
         struct fc_frame_header *fh = fc_frame_header_get(fp);
@@ -1114,8 +1255,17 @@ static void fc_exch_recv_req(struct fc_lport *lp, struct fc_exch_mgr *mp,
         u32 f_ctl;
         enum fc_pf_rjt_reason reject;
 
+        /* We can have the wrong fc_lport at this point with NPIV, which is a
+         * problem now that we know a new exchange needs to be allocated
+         */
+        lport = fc_vport_id_lookup(lport, ntoh24(fh->fh_d_id));
+        if (!lport) {
+                fc_frame_free(fp);
+                return;
+        }
+
         fr_seq(fp) = NULL;
-        reject = fc_seq_lookup_recip(lp, mp, fp);
+        reject = fc_seq_lookup_recip(lport, mp, fp);
         if (reject == FC_RJT_NONE) {
                 sp = fr_seq(fp);        /* sequence will be held */
                 ep = fc_seq_exch(sp);
@@ -1138,17 +1288,21 @@ static void fc_exch_recv_req(struct fc_lport *lp, struct fc_exch_mgr *mp,
                 if (ep->resp)
                         ep->resp(sp, fp, ep->arg);
                 else
-                        lp->tt.lport_recv(lp, sp, fp);
+                        lport->tt.lport_recv(lport, sp, fp);
                 fc_exch_release(ep);    /* release from lookup */
         } else {
-                FC_LPORT_DBG(lp, "exch/seq lookup failed: reject %x\n", reject);
+                FC_LPORT_DBG(lport, "exch/seq lookup failed: reject %x\n",
+                             reject);
                 fc_frame_free(fp);
         }
 }
 
-/*
- * Handle receive where the other end is originating the sequence in
- * response to our exchange.
+/**
+ * fc_exch_recv_seq_resp() - Handler for an incoming response where the other
+ *                           end is the originator of the sequence that is a
+ *                           response to our initial exchange
+ * @mp: The EM that the exchange is on
+ * @fp: The response frame
  */
 static void fc_exch_recv_seq_resp(struct fc_exch_mgr *mp, struct fc_frame *fp)
 {
@@ -1239,8 +1393,11 @@ out:
         fc_frame_free(fp);
 }
 
-/*
- * Handle receive for a sequence where other end is responding to our sequence.
+/**
+ * fc_exch_recv_resp() - Handler for a sequence where other end is
+ *                       responding to our sequence
+ * @mp: The EM that the exchange is on
+ * @fp: The response frame
  */
 static void fc_exch_recv_resp(struct fc_exch_mgr *mp, struct fc_frame *fp)
 {
@@ -1256,9 +1413,13 @@ static void fc_exch_recv_resp(struct fc_exch_mgr *mp, struct fc_frame *fp)
         fc_frame_free(fp);
 }
 
-/*
- * Handle the response to an ABTS for exchange or sequence.
- * This can be BA_ACC or BA_RJT.
+/**
+ * fc_exch_abts_resp() - Handler for a response to an ABT
+ * @ep: The exchange that the frame is on
+ * @fp: The response frame
+ *
+ * This response would be to an ABTS cancelling an exchange or sequence.
+ * The response can be either BA_ACC or BA_RJT
  */
 static void fc_exch_abts_resp(struct fc_exch *ep, struct fc_frame *fp)
 {
@@ -1333,9 +1494,12 @@ static void fc_exch_abts_resp(struct fc_exch *ep, struct fc_frame *fp)
 
 }
 
-/*
- * Receive BLS sequence.
- * This is always a sequence initiated by the remote side.
+/**
+ * fc_exch_recv_bls() - Handler for a BLS sequence
+ * @mp: The EM that the exchange is on
+ * @fp: The request frame
+ *
+ * The BLS frame is always a sequence initiated by the remote side.
  * We may be either the originator or recipient of the exchange.
  */
 static void fc_exch_recv_bls(struct fc_exch_mgr *mp, struct fc_frame *fp)
@@ -1392,8 +1556,10 @@ static void fc_exch_recv_bls(struct fc_exch_mgr *mp, struct fc_frame *fp)
                 fc_exch_release(ep);    /* release hold taken by fc_exch_find */
 }
 
-/*
- * Accept sequence with LS_ACC.
+/**
+ * fc_seq_ls_acc() - Accept sequence with LS_ACC
+ * @req_sp: The request sequence
+ *
  * If this fails due to allocation or transmit congestion, assume the
  * originator will repeat the sequence.
  */
@@ -1413,8 +1579,12 @@ static void fc_seq_ls_acc(struct fc_seq *req_sp)
         }
 }
 
-/*
- * Reject sequence with ELS LS_RJT.
+/**
+ * fc_seq_ls_rjt() - Reject a sequence with ELS LS_RJT
+ * @req_sp: The request sequence
+ * @reason: The reason the sequence is being rejected
+ * @explan: The explaination for the rejection
+ *
  * If this fails due to allocation or transmit congestion, assume the
  * originator will repeat the sequence.
  */
@@ -1437,6 +1607,10 @@ static void fc_seq_ls_rjt(struct fc_seq *req_sp, enum fc_els_rjt_reason reason,
         }
 }
 
+/**
+ * fc_exch_reset() - Reset an exchange
+ * @ep: The exchange to be reset
+ */
 static void fc_exch_reset(struct fc_exch *ep)
 {
         struct fc_seq *sp;
@@ -1446,12 +1620,6 @@ static void fc_exch_reset(struct fc_exch *ep)
 
         spin_lock_bh(&ep->ex_lock);
         ep->state |= FC_EX_RST_CLEANUP;
-        /*
-         * we really want to call del_timer_sync, but cannot due
-         * to the lport calling with the lport lock held (some resp
-         * functions can also grab the lport lock which could cause
-         * a deadlock).
-         */
         if (cancel_delayed_work(&ep->timeout_work))
                 atomic_dec(&ep->ex_refcnt);     /* drop hold for timer */
         resp = ep->resp;
@@ -1471,16 +1639,16 @@ static void fc_exch_reset(struct fc_exch *ep)
 }
 
 /**
- * fc_exch_pool_reset() - Resets an per cpu exches pool.
- * @lport:      ptr to the local port
- * @pool:       ptr to the per cpu exches pool
- * @sid:        source FC ID
- * @did:        destination FC ID
+ * fc_exch_pool_reset() - Reset a per cpu exchange pool
+ * @lport: The local port that the exchange pool is on
+ * @pool:  The exchange pool to be reset
+ * @sid:   The source ID
+ * @did:   The destination ID
  *
- * Resets an per cpu exches pool, releasing its all sequences
- * and exchanges. If sid is non-zero, then reset only exchanges
- * we sourced from that FID. If did is non-zero, reset only
- * exchanges destined to that FID.
+ * Resets a per cpu exches pool, releasing all of its sequences
+ * and exchanges. If sid is non-zero then reset only exchanges
+ * we sourced from the local port's FID. If did is non-zero then
+ * only reset exchanges destined for the local port's FID.
  */
 static void fc_exch_pool_reset(struct fc_lport *lport,
                                struct fc_exch_pool *pool,
@@ -1514,15 +1682,15 @@ restart:
 }
 
 /**
- * fc_exch_mgr_reset() - Resets all EMs of a lport
- * @lport:      ptr to the local port
- * @sid:        source FC ID
- * @did:        destination FC ID
+ * fc_exch_mgr_reset() - Reset all EMs of a local port
+ * @lport: The local port whose EMs are to be reset
+ * @sid:   The source ID
+ * @did:   The destination ID
  *
- * Reset all EMs of a lport, releasing its all sequences and
- * exchanges. If sid is non-zero, then reset only exchanges
- * we sourced from that FID. If did is non-zero, reset only
- * exchanges destined to that FID.
+ * Reset all EMs associated with a given local port. Release all
+ * sequences and exchanges. If sid is non-zero then reset only the
+ * exchanges sent from the local port's FID. If did is non-zero then
+ * reset only exchanges destined for the local port's FID.
  */
 void fc_exch_mgr_reset(struct fc_lport *lport, u32 sid, u32 did)
 {
@@ -1538,8 +1706,11 @@ void fc_exch_mgr_reset(struct fc_lport *lport, u32 sid, u32 did)
 }
 EXPORT_SYMBOL(fc_exch_mgr_reset);
 
-/*
- * Handle incoming ELS REC - Read Exchange Concise.
+/**
+ * fc_exch_els_rec() - Handler for ELS REC (Read Exchange Concise) requests
+ * @sp:  The sequence the REC is on
+ * @rfp: The REC frame
+ *
  * Note that the requesting port may be different than the S_ID in the request.
  */
 static void fc_exch_els_rec(struct fc_seq *sp, struct fc_frame *rfp)
@@ -1621,10 +1792,11 @@ reject:
         fc_frame_free(rfp);
 }
 
-/*
- * Handle response from RRQ.
- * Not much to do here, really.
- * Should report errors.
+/**
+ * fc_exch_rrq_resp() - Handler for RRQ responses
+ * @sp:  The sequence that the RRQ is on
+ * @fp:  The RRQ frame
+ * @arg: The exchange that the RRQ is on
  *
  * TODO: fix error handler.
  */
@@ -1664,21 +1836,99 @@ cleanup:
         fc_exch_release(aborted_ep);
 }
 
-/*
- * Send ELS RRQ - Reinstate Recovery Qualifier.
+
+/**
+ * fc_exch_seq_send() - Send a frame using a new exchange and sequence
+ * @lport:      The local port to send the frame on
+ * @fp:         The frame to be sent
+ * @resp:       The response handler for this request
+ * @destructor: The destructor for the exchange
+ * @arg:        The argument to be passed to the response handler
+ * @timer_msec: The timeout period for the exchange
+ *
+ * The frame pointer with some of the header's fields must be
+ * filled before calling this routine, those fields are:
+ *
+ * - routing control
+ * - FC port did
+ * - FC port sid
+ * - FC header type
+ * - frame control
+ * - parameter or relative offset
+ */
+static struct fc_seq *fc_exch_seq_send(struct fc_lport *lport,
+                                       struct fc_frame *fp,
+                                       void (*resp)(struct fc_seq *,
+                                                    struct fc_frame *fp,
+                                                    void *arg),
+                                       void (*destructor)(struct fc_seq *,
+                                                          void *),
+                                       void *arg, u32 timer_msec)
+{
+        struct fc_exch *ep;
+        struct fc_seq *sp = NULL;
+        struct fc_frame_header *fh;
+        int rc = 1;
+
+        ep = fc_exch_alloc(lport, fp);
+        if (!ep) {
+                fc_frame_free(fp);
+                return NULL;
+        }
+        ep->esb_stat |= ESB_ST_SEQ_INIT;
+        fh = fc_frame_header_get(fp);
+        fc_exch_set_addr(ep, ntoh24(fh->fh_s_id), ntoh24(fh->fh_d_id));
+        ep->resp = resp;
+        ep->destructor = destructor;
+        ep->arg = arg;
+        ep->r_a_tov = FC_DEF_R_A_TOV;
+        ep->lp = lport;
+        sp = &ep->seq;
+
+        ep->fh_type = fh->fh_type; /* save for possbile timeout handling */
+        ep->f_ctl = ntoh24(fh->fh_f_ctl);
+        fc_exch_setup_hdr(ep, fp, ep->f_ctl);
+        sp->cnt++;
+
+        if (ep->xid <= lport->lro_xid && fh->fh_r_ctl == FC_RCTL_DD_UNSOL_CMD)
+                fc_fcp_ddp_setup(fr_fsp(fp), ep->xid);
+
+        if (unlikely(lport->tt.frame_send(lport, fp)))
+                goto err;
+
+        if (timer_msec)
+                fc_exch_timer_set_locked(ep, timer_msec);
+        ep->f_ctl &= ~FC_FC_FIRST_SEQ;  /* not first seq */
+
+        if (ep->f_ctl & FC_FC_SEQ_INIT)
+                ep->esb_stat &= ~ESB_ST_SEQ_INIT;
+        spin_unlock_bh(&ep->ex_lock);
+        return sp;
+err:
+        rc = fc_exch_done_locked(ep);
+        spin_unlock_bh(&ep->ex_lock);
+        if (!rc)
+                fc_exch_delete(ep);
+        return NULL;
+}
+
+/**
+ * fc_exch_rrq() - Send an ELS RRQ (Reinstate Recovery Qualifier) command
+ * @ep: The exchange to send the RRQ on
+ *
  * This tells the remote port to stop blocking the use of
  * the exchange and the seq_cnt range.
  */
 static void fc_exch_rrq(struct fc_exch *ep)
 {
-        struct fc_lport *lp;
+        struct fc_lport *lport;
         struct fc_els_rrq *rrq;
         struct fc_frame *fp;
         u32 did;
 
-        lp = ep->lp;
+        lport = ep->lp;
 
-        fp = fc_frame_alloc(lp, sizeof(*rrq));
+        fp = fc_frame_alloc(lport, sizeof(*rrq));
         if (!fp)
                 goto retry;
 
@@ -1694,10 +1944,11 @@ static void fc_exch_rrq(struct fc_exch *ep)
                 did = ep->sid;
 
         fc_fill_fc_hdr(fp, FC_RCTL_ELS_REQ, did,
-                       fc_host_port_id(lp->host), FC_TYPE_ELS,
+                       fc_host_port_id(lport->host), FC_TYPE_ELS,
                        FC_FC_FIRST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
 
-        if (fc_exch_seq_send(lp, fp, fc_exch_rrq_resp, NULL, ep, lp->e_d_tov))
+        if (fc_exch_seq_send(lport, fp, fc_exch_rrq_resp, NULL, ep,
+                             lport->e_d_tov))
                 return;
 
 retry:
@@ -1714,12 +1965,14 @@ retry:
 }
 
 
-/*
- * Handle incoming ELS RRQ - Reset Recovery Qualifier.
+/**
+ * fc_exch_els_rrq() - Handler for ELS RRQ (Reset Recovery Qualifier) requests
+ * @sp: The sequence that the RRQ is on
+ * @fp: The RRQ frame
  */
 static void fc_exch_els_rrq(struct fc_seq *sp, struct fc_frame *fp)
 {
-        struct fc_exch *ep;             /* request or subject exchange */
+        struct fc_exch *ep = NULL;      /* request or subject exchange */
         struct fc_els_rrq *rp;
         u32 sid;
         u16 xid;
@@ -1769,17 +2022,24 @@ static void fc_exch_els_rrq(struct fc_seq *sp, struct fc_frame *fp)
          * Send LS_ACC.
          */
         fc_seq_ls_acc(sp);
-        fc_frame_free(fp);
-        return;
+        goto out;
 
 unlock_reject:
         spin_unlock_bh(&ep->ex_lock);
-        fc_exch_release(ep);    /* drop hold from fc_exch_find */
 reject:
         fc_seq_ls_rjt(sp, ELS_RJT_LOGIC, explan);
+out:
         fc_frame_free(fp);
+        if (ep)
+                fc_exch_release(ep);    /* drop hold from fc_exch_find */
 }
 
+/**
+ * fc_exch_mgr_add() - Add an exchange manager to a local port's list of EMs
+ * @lport: The local port to add the exchange manager to
+ * @mp:    The exchange manager to be added to the local port
+ * @match: The match routine that indicates when this EM should be used
+ */
 struct fc_exch_mgr_anchor *fc_exch_mgr_add(struct fc_lport *lport,
                                            struct fc_exch_mgr *mp,
                                            bool (*match)(struct fc_frame *))
@@ -1799,6 +2059,10 @@ struct fc_exch_mgr_anchor *fc_exch_mgr_add(struct fc_lport *lport,
 }
 EXPORT_SYMBOL(fc_exch_mgr_add);
 
+/**
+ * fc_exch_mgr_destroy() - Destroy an exchange manager
+ * @kref: The reference to the EM to be destroyed
+ */
 static void fc_exch_mgr_destroy(struct kref *kref)
 {
         struct fc_exch_mgr *mp = container_of(kref, struct fc_exch_mgr, kref);
@@ -1808,6 +2072,10 @@ static void fc_exch_mgr_destroy(struct kref *kref)
         kfree(mp);
 }
 
+/**
+ * fc_exch_mgr_del() - Delete an EM from a local port's list
+ * @ema: The exchange manager anchor identifying the EM to be deleted
+ */
 void fc_exch_mgr_del(struct fc_exch_mgr_anchor *ema)
 {
         /* remove EM anchor from EM anchors list */
@@ -1817,7 +2085,35 @@ void fc_exch_mgr_del(struct fc_exch_mgr_anchor *ema)
 }
 EXPORT_SYMBOL(fc_exch_mgr_del);
 
-struct fc_exch_mgr *fc_exch_mgr_alloc(struct fc_lport *lp,
+/**
+ * fc_exch_mgr_list_clone() - Share all exchange manager objects
+ * @src: Source lport to clone exchange managers from
+ * @dst: New lport that takes references to all the exchange managers
+ */
+int fc_exch_mgr_list_clone(struct fc_lport *src, struct fc_lport *dst)
+{
+        struct fc_exch_mgr_anchor *ema, *tmp;
+
+        list_for_each_entry(ema, &src->ema_list, ema_list) {
+                if (!fc_exch_mgr_add(dst, ema->mp, ema->match))
+                        goto err;
+        }
+        return 0;
+err:
+        list_for_each_entry_safe(ema, tmp, &dst->ema_list, ema_list)
+                fc_exch_mgr_del(ema);
+        return -ENOMEM;
+}
+
+/**
+ * fc_exch_mgr_alloc() - Allocate an exchange manager
+ * @lport:   The local port that the new EM will be associated with
+ * @class:   The default FC class for new exchanges
+ * @min_xid: The minimum XID for exchanges from the new EM
+ * @max_xid: The maximum XID for exchanges from the new EM
+ * @match:   The match routine for the new EM
+ */
+struct fc_exch_mgr *fc_exch_mgr_alloc(struct fc_lport *lport,
                                       enum fc_class class,
                                       u16 min_xid, u16 max_xid,
                                       bool (*match)(struct fc_frame *))
@@ -1830,7 +2126,7 @@ struct fc_exch_mgr *fc_exch_mgr_alloc(struct fc_lport *lp,
 
         if (max_xid <= min_xid || max_xid == FC_XID_UNKNOWN ||
             (min_xid & fc_cpu_mask) != 0) {
-                FC_LPORT_DBG(lp, "Invalid min_xid 0x:%x and max_xid 0x:%x\n",
+                FC_LPORT_DBG(lport, "Invalid min_xid 0x:%x and max_xid 0x:%x\n",
                              min_xid, max_xid);
                 return NULL;
         }
@@ -1873,7 +2169,7 @@ struct fc_exch_mgr *fc_exch_mgr_alloc(struct fc_lport *lp,
         }
 
         kref_init(&mp->kref);
-        if (!fc_exch_mgr_add(lp, mp, match)) {
+        if (!fc_exch_mgr_add(lport, mp, match)) {
                 free_percpu(mp->pool);
                 goto free_mempool;
         }
@@ -1894,76 +2190,26 @@ free_mp:
 }
 EXPORT_SYMBOL(fc_exch_mgr_alloc);
 
+/**
+ * fc_exch_mgr_free() - Free all exchange managers on a local port
+ * @lport: The local port whose EMs are to be freed
+ */
 void fc_exch_mgr_free(struct fc_lport *lport)
 {
         struct fc_exch_mgr_anchor *ema, *next;
 
+        flush_workqueue(fc_exch_workqueue);
         list_for_each_entry_safe(ema, next, &lport->ema_list, ema_list)
                 fc_exch_mgr_del(ema);
 }
 EXPORT_SYMBOL(fc_exch_mgr_free);
 
-
-struct fc_seq *fc_exch_seq_send(struct fc_lport *lp,
-                                struct fc_frame *fp,
-                                void (*resp)(struct fc_seq *,
-                                             struct fc_frame *fp,
-                                             void *arg),
-                                void (*destructor)(struct fc_seq *, void *),
-                                void *arg, u32 timer_msec)
-{
-        struct fc_exch *ep;
-        struct fc_seq *sp = NULL;
-        struct fc_frame_header *fh;
-        int rc = 1;
-
-        ep = fc_exch_alloc(lp, fp);
-        if (!ep) {
-                fc_frame_free(fp);
-                return NULL;
-        }
-        ep->esb_stat |= ESB_ST_SEQ_INIT;
-        fh = fc_frame_header_get(fp);
-        fc_exch_set_addr(ep, ntoh24(fh->fh_s_id), ntoh24(fh->fh_d_id));
-        ep->resp = resp;
-        ep->destructor = destructor;
-        ep->arg = arg;
-        ep->r_a_tov = FC_DEF_R_A_TOV;
-        ep->lp = lp;
-        sp = &ep->seq;
-
-        ep->fh_type = fh->fh_type; /* save for possbile timeout handling */
-        ep->f_ctl = ntoh24(fh->fh_f_ctl);
-        fc_exch_setup_hdr(ep, fp, ep->f_ctl);
-        sp->cnt++;
-
-        if (ep->xid <= lp->lro_xid)
-                fc_fcp_ddp_setup(fr_fsp(fp), ep->xid);
-
-        if (unlikely(lp->tt.frame_send(lp, fp)))
-                goto err;
-
-        if (timer_msec)
-                fc_exch_timer_set_locked(ep, timer_msec);
-        ep->f_ctl &= ~FC_FC_FIRST_SEQ;  /* not first seq */
-
-        if (ep->f_ctl & FC_FC_SEQ_INIT)
-                ep->esb_stat &= ~ESB_ST_SEQ_INIT;
-        spin_unlock_bh(&ep->ex_lock);
-        return sp;
-err:
-        rc = fc_exch_done_locked(ep);
-        spin_unlock_bh(&ep->ex_lock);
-        if (!rc)
-                fc_exch_delete(ep);
-        return NULL;
-}
-EXPORT_SYMBOL(fc_exch_seq_send);
-
-/*
- * Receive a frame
+/**
+ * fc_exch_recv() - Handler for received frames
+ * @lport: The local port the frame was received on
+ * @fp:    The received frame
  */
-void fc_exch_recv(struct fc_lport *lp, struct fc_frame *fp)
+void fc_exch_recv(struct fc_lport *lport, struct fc_frame *fp)
 {
         struct fc_frame_header *fh = fc_frame_header_get(fp);
         struct fc_exch_mgr_anchor *ema;
@@ -1971,8 +2217,8 @@ void fc_exch_recv(struct fc_lport *lp, struct fc_frame *fp)
         u16 oxid;
 
         /* lport lock ? */
-        if (!lp || lp->state == LPORT_ST_DISABLED) {
-                FC_LPORT_DBG(lp, "Receiving frames for an lport that "
+        if (!lport || lport->state == LPORT_ST_DISABLED) {
+                FC_LPORT_DBG(lport, "Receiving frames for an lport that "
                              "has not been initialized correctly\n");
                 fc_frame_free(fp);
                 return;
@@ -1981,7 +2227,7 @@ void fc_exch_recv(struct fc_lport *lp, struct fc_frame *fp)
         f_ctl = ntoh24(fh->fh_f_ctl);
         oxid = ntohs(fh->fh_ox_id);
         if (f_ctl & FC_FC_EX_CTX) {
-                list_for_each_entry(ema, &lp->ema_list, ema_list) {
+                list_for_each_entry(ema, &lport->ema_list, ema_list) {
                         if ((oxid >= ema->mp->min_xid) &&
                             (oxid <= ema->mp->max_xid)) {
                                 found = 1;
@@ -1990,13 +2236,13 @@ void fc_exch_recv(struct fc_lport *lp, struct fc_frame *fp)
                 }
 
                 if (!found) {
-                        FC_LPORT_DBG(lp, "Received response for out "
+                        FC_LPORT_DBG(lport, "Received response for out "
                                      "of range oxid:%hx\n", oxid);
                         fc_frame_free(fp);
                         return;
                 }
         } else
-                ema = list_entry(lp->ema_list.prev, typeof(*ema), ema_list);
+                ema = list_entry(lport->ema_list.prev, typeof(*ema), ema_list);
 
         /*
          * If frame is marked invalid, just drop it.
@@ -2015,37 +2261,56 @@ void fc_exch_recv(struct fc_lport *lp, struct fc_frame *fp)
                 else if (f_ctl & FC_FC_SEQ_CTX)
                         fc_exch_recv_resp(ema->mp, fp);
                 else
-                        fc_exch_recv_req(lp, ema->mp, fp);
+                        fc_exch_recv_req(lport, ema->mp, fp);
                 break;
         default:
-                FC_LPORT_DBG(lp, "dropping invalid frame (eof %x)", fr_eof(fp));
+                FC_LPORT_DBG(lport, "dropping invalid frame (eof %x)",
+                             fr_eof(fp));
                 fc_frame_free(fp);
         }
 }
 EXPORT_SYMBOL(fc_exch_recv);
 
-int fc_exch_init(struct fc_lport *lp)
+/**
+ * fc_exch_init() - Initialize the exchange layer for a local port
+ * @lport: The local port to initialize the exchange layer for
+ */
+int fc_exch_init(struct fc_lport *lport)
 {
-        if (!lp->tt.seq_start_next)
-                lp->tt.seq_start_next = fc_seq_start_next;
+        if (!lport->tt.seq_start_next)
+                lport->tt.seq_start_next = fc_seq_start_next;
 
-        if (!lp->tt.exch_seq_send)
-                lp->tt.exch_seq_send = fc_exch_seq_send;
+        if (!lport->tt.exch_seq_send)
+                lport->tt.exch_seq_send = fc_exch_seq_send;
 
-        if (!lp->tt.seq_send)
-                lp->tt.seq_send = fc_seq_send;
+        if (!lport->tt.seq_send)
+                lport->tt.seq_send = fc_seq_send;
 
-        if (!lp->tt.seq_els_rsp_send)
-                lp->tt.seq_els_rsp_send = fc_seq_els_rsp_send;
+        if (!lport->tt.seq_els_rsp_send)
+                lport->tt.seq_els_rsp_send = fc_seq_els_rsp_send;
 
-        if (!lp->tt.exch_done)
-                lp->tt.exch_done = fc_exch_done;
+        if (!lport->tt.exch_done)
+                lport->tt.exch_done = fc_exch_done;
 
-        if (!lp->tt.exch_mgr_reset)
-                lp->tt.exch_mgr_reset = fc_exch_mgr_reset;
+        if (!lport->tt.exch_mgr_reset)
+                lport->tt.exch_mgr_reset = fc_exch_mgr_reset;
 
-        if (!lp->tt.seq_exch_abort)
-                lp->tt.seq_exch_abort = fc_seq_exch_abort;
+        if (!lport->tt.seq_exch_abort)
+                lport->tt.seq_exch_abort = fc_seq_exch_abort;
+
+        return 0;
+}
+EXPORT_SYMBOL(fc_exch_init);
+
+/**
+ * fc_setup_exch_mgr() - Setup an exchange manager
+ */
+int fc_setup_exch_mgr()
+{
+        fc_em_cachep = kmem_cache_create("libfc_em", sizeof(struct fc_exch),
+                                         0, SLAB_HWCACHE_ALIGN, NULL);
+        if (!fc_em_cachep)
+                return -ENOMEM;
 
         /*
          * Initialize fc_cpu_mask and fc_cpu_order. The
@@ -2069,20 +2334,17 @@ int fc_exch_init(struct fc_lport *lp)
         }
         fc_cpu_mask--;
 
-        return 0;
-}
-EXPORT_SYMBOL(fc_exch_init);
-
-int fc_setup_exch_mgr(void)
-{
-        fc_em_cachep = kmem_cache_create("libfc_em", sizeof(struct fc_exch),
-                                         0, SLAB_HWCACHE_ALIGN, NULL);
-        if (!fc_em_cachep)
+        fc_exch_workqueue = create_singlethread_workqueue("fc_exch_workqueue");
+        if (!fc_exch_workqueue)
                 return -ENOMEM;
         return 0;
 }
 
-void fc_destroy_exch_mgr(void)
+/**
+ * fc_destroy_exch_mgr() - Destroy an exchange manager
+ */
+void fc_destroy_exch_mgr()
 {
+        destroy_workqueue(fc_exch_workqueue);
         kmem_cache_destroy(fc_em_cachep);
 }
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index 59a4408b27b5..17396c708b08 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -27,6 +27,7 @@
 #include <linux/scatterlist.h>
 #include <linux/err.h>
 #include <linux/crc32.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi_tcq.h>
 #include <scsi/scsi.h>
@@ -39,26 +40,19 @@
 #include <scsi/libfc.h>
 #include <scsi/fc_encode.h>
 
-MODULE_AUTHOR("Open-FCoE.org");
-MODULE_DESCRIPTION("libfc");
-MODULE_LICENSE("GPL v2");
+#include "fc_libfc.h"
 
-unsigned int fc_debug_logging;
-module_param_named(debug_logging, fc_debug_logging, int, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
-
-static struct kmem_cache *scsi_pkt_cachep;
+struct kmem_cache *scsi_pkt_cachep;
 
 /* SRB state definitions */
 #define FC_SRB_FREE             0               /* cmd is free */
 #define FC_SRB_CMD_SENT         (1 << 0)        /* cmd has been sent */
 #define FC_SRB_RCV_STATUS       (1 << 1)        /* response has arrived */
 #define FC_SRB_ABORT_PENDING    (1 << 2)        /* cmd abort sent to device */
-#define FC_SRB_ABORTED          (1 << 3)        /* abort acknowleged */
+#define FC_SRB_ABORTED          (1 << 3)        /* abort acknowledged */
 #define FC_SRB_DISCONTIG        (1 << 4)        /* non-sequential data recvd */
 #define FC_SRB_COMPL            (1 << 5)        /* fc_io_compl has been run */
 #define FC_SRB_FCP_PROCESSING_TMO (1 << 6)      /* timer function processing */
-#define FC_SRB_NOMEM            (1 << 7)        /* dropped to out of mem */
 
 #define FC_SRB_READ             (1 << 1)
 #define FC_SRB_WRITE            (1 << 0)
@@ -73,10 +67,22 @@ static struct kmem_cache *scsi_pkt_cachep;
 #define CMD_SCSI_STATUS(Cmnd)       ((Cmnd)->SCp.Status)
 #define CMD_RESID_LEN(Cmnd)         ((Cmnd)->SCp.buffers_residual)
 
+/**
+ * struct fc_fcp_internal - FCP layer internal data
+ * @scsi_pkt_pool: Memory pool to draw FCP packets from
+ * @scsi_queue_lock: Protects the scsi_pkt_queue
+ * @scsi_pkt_queue: Current FCP packets
+ * @last_can_queue_ramp_down_time: ramp down time
+ * @last_can_queue_ramp_up_time: ramp up time
+ * @max_can_queue: max can_queue size
+ */
 struct fc_fcp_internal {
-        mempool_t       *scsi_pkt_pool;
-        struct list_head scsi_pkt_queue;
-        u8              throttled;
+        mempool_t               *scsi_pkt_pool;
+        spinlock_t              scsi_queue_lock;
+        struct list_head        scsi_pkt_queue;
+        unsigned long           last_can_queue_ramp_down_time;
+        unsigned long           last_can_queue_ramp_up_time;
+        int                     max_can_queue;
 };
 
 #define fc_get_scsi_internal(x) ((struct fc_fcp_internal *)(x)->scsi_priv)
@@ -90,9 +96,9 @@ static void fc_fcp_recv(struct fc_seq *, struct fc_frame *, void *);
 static void fc_fcp_resp(struct fc_fcp_pkt *, struct fc_frame *);
 static void fc_fcp_complete_locked(struct fc_fcp_pkt *);
 static void fc_tm_done(struct fc_seq *, struct fc_frame *, void *);
-static void fc_fcp_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp);
+static void fc_fcp_error(struct fc_fcp_pkt *, struct fc_frame *);
 static void fc_timeout_error(struct fc_fcp_pkt *);
-static void fc_fcp_timeout(unsigned long data);
+static void fc_fcp_timeout(unsigned long);
 static void fc_fcp_rec(struct fc_fcp_pkt *);
 static void fc_fcp_rec_error(struct fc_fcp_pkt *, struct fc_frame *);
 static void fc_fcp_rec_resp(struct fc_seq *, struct fc_frame *, void *);
@@ -124,6 +130,7 @@ static void fc_fcp_srr_error(struct fc_fcp_pkt *, struct fc_frame *);
 #define FC_SCSI_TM_TOV          (10 * HZ)
 #define FC_SCSI_REC_TOV         (2 * HZ)
 #define FC_HOST_RESET_TIMEOUT   (30 * HZ)
+#define FC_CAN_QUEUE_PERIOD     (60 * HZ)
 
 #define FC_MAX_ERROR_CNT        5
 #define FC_MAX_RECOV_RETRY      3
@@ -131,23 +138,22 @@ static void fc_fcp_srr_error(struct fc_fcp_pkt *, struct fc_frame *);
 #define FC_FCP_DFLT_QUEUE_DEPTH 32
 
 /**
- * fc_fcp_pkt_alloc - allocation routine for scsi_pkt packet
- * @lp:         fc lport struct
- * @gfp:        gfp flags for allocation
+ * fc_fcp_pkt_alloc() - Allocate a fcp_pkt
+ * @lport: The local port that the FCP packet is for
+ * @gfp:   GFP flags for allocation
  *
- * This is used by upper layer scsi driver.
- * Return Value : scsi_pkt structure or null on allocation failure.
- * Context      : call from process context. no locking required.
+ * Return value: fcp_pkt structure or null on allocation failure.
+ * Context:      Can be called from process context, no lock is required.
  */
-static struct fc_fcp_pkt *fc_fcp_pkt_alloc(struct fc_lport *lp, gfp_t gfp)
+static struct fc_fcp_pkt *fc_fcp_pkt_alloc(struct fc_lport *lport, gfp_t gfp)
 {
-        struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
+        struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
         struct fc_fcp_pkt *fsp;
 
         fsp = mempool_alloc(si->scsi_pkt_pool, gfp);
         if (fsp) {
                 memset(fsp, 0, sizeof(*fsp));
-                fsp->lp = lp;
+                fsp->lp = lport;
                 atomic_set(&fsp->ref_cnt, 1);
                 init_timer(&fsp->timer);
                 INIT_LIST_HEAD(&fsp->list);
@@ -157,12 +163,11 @@ static struct fc_fcp_pkt *fc_fcp_pkt_alloc(struct fc_lport *lp, gfp_t gfp)
 }
 
 /**
- * fc_fcp_pkt_release() - release hold on scsi_pkt packet
- * @fsp:        fcp packet struct
+ * fc_fcp_pkt_release() - Release hold on a fcp_pkt
+ * @fsp: The FCP packet to be released
  *
- * This is used by upper layer scsi driver.
- * Context      : call from process  and interrupt context.
- *                no locking required
+ * Context: Can be called from process or interrupt context,
+ *          no lock is required.
  */
 static void fc_fcp_pkt_release(struct fc_fcp_pkt *fsp)
 {
@@ -173,20 +178,25 @@ static void fc_fcp_pkt_release(struct fc_fcp_pkt *fsp)
         }
 }
 
+/**
+ * fc_fcp_pkt_hold() - Hold a fcp_pkt
+ * @fsp: The FCP packet to be held
+ */
 static void fc_fcp_pkt_hold(struct fc_fcp_pkt *fsp)
 {
         atomic_inc(&fsp->ref_cnt);
 }
 
 /**
- * fc_fcp_pkt_destory() - release hold on scsi_pkt packet
- * @seq:                exchange sequence
- * @fsp:        fcp packet struct
+ * fc_fcp_pkt_destory() - Release hold on a fcp_pkt
+ * @seq: The sequence that the FCP packet is on (required by destructor API)
+ * @fsp: The FCP packet to be released
+ *
+ * This routine is called by a destructor callback in the exch_seq_send()
+ * routine of the libfc Transport Template. The 'struct fc_seq' is a required
+ * argument even though it is not used by this routine.
  *
- * Release hold on scsi_pkt packet set to keep scsi_pkt
- * till EM layer exch resource is not freed.
- * Context      : called from from EM layer.
- *                no locking required
+ * Context: No locking required.
  */
 static void fc_fcp_pkt_destroy(struct fc_seq *seq, void *fsp)
 {
@@ -194,10 +204,10 @@ static void fc_fcp_pkt_destroy(struct fc_seq *seq, void *fsp)
 }
 
 /**
- * fc_fcp_lock_pkt() - lock a packet and get a ref to it.
- * @fsp:        fcp packet
+ * fc_fcp_lock_pkt() - Lock a fcp_pkt and increase its reference count
+ * @fsp: The FCP packet to be locked and incremented
  *
- * We should only return error if we return a command to scsi-ml before
+ * We should only return error if we return a command to SCSI-ml before
  * getting a response. This can happen in cases where we send a abort, but
  * do not wait for the response and the abort and command can be passing
  * each other on the wire/network-layer.
@@ -222,18 +232,33 @@ static inline int fc_fcp_lock_pkt(struct fc_fcp_pkt *fsp)
         return 0;
 }
 
+/**
+ * fc_fcp_unlock_pkt() - Release a fcp_pkt's lock and decrement its
+ *                       reference count
+ * @fsp: The FCP packet to be unlocked and decremented
+ */
 static inline void fc_fcp_unlock_pkt(struct fc_fcp_pkt *fsp)
 {
         spin_unlock_bh(&fsp->scsi_pkt_lock);
         fc_fcp_pkt_release(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
+ */
 static void fc_fcp_timer_set(struct fc_fcp_pkt *fsp, unsigned long delay)
 {
         if (!(fsp->state & FC_SRB_COMPL))
                 mod_timer(&fsp->timer, jiffies + delay);
 }
 
+/**
+ * fc_fcp_send_abort() - Send an abort for exchanges associated with a
+ *                       fcp_pkt
+ * @fsp: The FCP packet to abort exchanges on
+ */
 static int fc_fcp_send_abort(struct fc_fcp_pkt *fsp)
 {
         if (!fsp->seq_ptr)
@@ -243,9 +268,14 @@ static int fc_fcp_send_abort(struct fc_fcp_pkt *fsp)
         return fsp->lp->tt.seq_exch_abort(fsp->seq_ptr, 0);
 }
 
-/*
- * Retry command.
- * An abort isn't needed.
+/**
+ * fc_fcp_retry_cmd() - Retry a fcp_pkt
+ * @fsp: The FCP packet to be retried
+ *
+ * Sets the status code to be FC_ERROR and then calls
+ * fc_fcp_complete_locked() which in turn calls fc_io_compl().
+ * fc_io_compl() will notify the SCSI-ml that the I/O is done.
+ * The SCSI-ml will retry the command.
  */
 static void fc_fcp_retry_cmd(struct fc_fcp_pkt *fsp)
 {
@@ -260,64 +290,145 @@ static void fc_fcp_retry_cmd(struct fc_fcp_pkt *fsp)
         fc_fcp_complete_locked(fsp);
 }
 
-/*
- * fc_fcp_ddp_setup - calls to LLD's ddp_setup to set up DDP
- * transfer for a read I/O indicated by the fc_fcp_pkt.
- * @fsp: ptr to the fc_fcp_pkt
- *
- * This is called in exch_seq_send() when we have a newly allocated
- * exchange with a valid exchange id to setup ddp.
- *
- * returns: none
+/**
+ * fc_fcp_ddp_setup() - Calls a LLD's ddp_setup routine to set up DDP context
+ * @fsp: The FCP packet that will manage the DDP frames
+ * @xid: The XID that will be used for the DDP exchange
  */
 void fc_fcp_ddp_setup(struct fc_fcp_pkt *fsp, u16 xid)
 {
-        struct fc_lport *lp;
-
-        if (!fsp)
-                return;
+        struct fc_lport *lport;
 
-        lp = fsp->lp;
+        lport = fsp->lp;
         if ((fsp->req_flags & FC_SRB_READ) &&
-            (lp->lro_enabled) && (lp->tt.ddp_setup)) {
-                if (lp->tt.ddp_setup(lp, xid, scsi_sglist(fsp->cmd),
-                                     scsi_sg_count(fsp->cmd)))
+            (lport->lro_enabled) && (lport->tt.ddp_setup)) {
+                if (lport->tt.ddp_setup(lport, xid, scsi_sglist(fsp->cmd),
+                                        scsi_sg_count(fsp->cmd)))
                         fsp->xfer_ddp = xid;
         }
 }
-EXPORT_SYMBOL(fc_fcp_ddp_setup);
 
-/*
- * fc_fcp_ddp_done - calls to LLD's ddp_done to release any
- * DDP related resources for this I/O if it is initialized
- * as a ddp transfer
- * @fsp: ptr to the fc_fcp_pkt
- *
- * returns: none
+/**
+ * fc_fcp_ddp_done() - Calls a LLD's ddp_done routine to release any
+ *                     DDP related resources for a fcp_pkt
+ * @fsp: The FCP packet that DDP had been used on
  */
 static void fc_fcp_ddp_done(struct fc_fcp_pkt *fsp)
 {
-        struct fc_lport *lp;
+        struct fc_lport *lport;
 
         if (!fsp)
                 return;
 
-        lp = fsp->lp;
-        if (fsp->xfer_ddp && lp->tt.ddp_done) {
-                fsp->xfer_len = lp->tt.ddp_done(lp, fsp->xfer_ddp);
-                fsp->xfer_ddp = 0;
+        if (fsp->xfer_ddp == FC_XID_UNKNOWN)
+                return;
+
+        lport = fsp->lp;
+        if (lport->tt.ddp_done) {
+                fsp->xfer_len = lport->tt.ddp_done(lport, fsp->xfer_ddp);
+                fsp->xfer_ddp = FC_XID_UNKNOWN;
+        }
+}
+
+/**
+ * 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);
+        int can_queue;
+
+        if (si->last_can_queue_ramp_up_time &&
+            (time_before(jiffies, si->last_can_queue_ramp_up_time +
+                         FC_CAN_QUEUE_PERIOD)))
+                return;
+
+        if (time_before(jiffies, si->last_can_queue_ramp_down_time +
+                        FC_CAN_QUEUE_PERIOD))
+                return;
+
+        si->last_can_queue_ramp_up_time = jiffies;
+
+        can_queue = lport->host->can_queue << 1;
+        if (can_queue >= si->max_can_queue) {
+                can_queue = si->max_can_queue;
+                si->last_can_queue_ramp_down_time = 0;
         }
+        lport->host->can_queue = can_queue;
+        shost_printk(KERN_ERR, lport->host, "libfc: increased "
+                     "can_queue to %d.\n", can_queue);
 }
 
+/**
+ * fc_fcp_can_queue_ramp_down() - reduces can_queue
+ * @lport: lport to reduce can_queue
+ *
+ * If we are getting memory allocation failures, then we may
+ * be trying to execute too many commands. We let the running
+ * 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);
+        int can_queue;
+
+        if (si->last_can_queue_ramp_down_time &&
+            (time_before(jiffies, si->last_can_queue_ramp_down_time +
+                         FC_CAN_QUEUE_PERIOD)))
+                return;
+
+        si->last_can_queue_ramp_down_time = jiffies;
+
+        can_queue = lport->host->can_queue;
+        can_queue >>= 1;
+        if (!can_queue)
+                can_queue = 1;
+        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);
+}
 
 /*
- * Receive SCSI data from target.
- * Called after receiving solicited data.
+ * fc_fcp_frame_alloc() -  Allocates fc_frame structure and buffer.
+ * @lport:      fc lport struct
+ * @len:        payload length
+ *
+ * Allocates fc_frame structure and buffer but if fails to allocate
+ * then reduce can_queue.
+ */
+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;
+}
+
+/**
+ * fc_fcp_recv_data() - Handler for receiving SCSI-FCP data from a target
+ * @fsp: The FCP packet the data is on
+ * @fp:  The data frame
  */
 static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 {
         struct scsi_cmnd *sc = fsp->cmd;
-        struct fc_lport *lp = fsp->lp;
+        struct fc_lport *lport = fsp->lp;
         struct fcoe_dev_stats *stats;
         struct fc_frame_header *fh;
         size_t start_offset;
@@ -327,7 +438,7 @@ static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
         size_t len;
         void *buf;
         struct scatterlist *sg;
-        size_t remaining;
+        u32 nents;
 
         fh = fc_frame_header_get(fp);
         offset = ntohl(fh->fh_parm_offset);
@@ -351,65 +462,29 @@ static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
         if (offset != fsp->xfer_len)
                 fsp->state |= FC_SRB_DISCONTIG;
 
-        crc = 0;
-        if (fr_flags(fp) & FCPHF_CRC_UNCHECKED)
-                crc = crc32(~0, (u8 *) fh, sizeof(*fh));
-
         sg = scsi_sglist(sc);
-        remaining = len;
-
-        while (remaining > 0 && sg) {
-                size_t off;
-                void *page_addr;
-                size_t sg_bytes;
-
-                if (offset >= sg->length) {
-                        offset -= sg->length;
-                        sg = sg_next(sg);
-                        continue;
-                }
-                sg_bytes = min(remaining, sg->length - offset);
-
-                /*
-                 * The scatterlist item may be bigger than PAGE_SIZE,
-                 * but we are limited to mapping PAGE_SIZE at a time.
-                 */
-                off = offset + sg->offset;
-                sg_bytes = min(sg_bytes, (size_t)
-                               (PAGE_SIZE - (off & ~PAGE_MASK)));
-                page_addr = kmap_atomic(sg_page(sg) + (off >> PAGE_SHIFT),
-                                        KM_SOFTIRQ0);
-                if (!page_addr)
-                        break;          /* XXX panic? */
-
-                if (fr_flags(fp) & FCPHF_CRC_UNCHECKED)
-                        crc = crc32(crc, buf, sg_bytes);
-                memcpy((char *)page_addr + (off & ~PAGE_MASK), buf,
-                       sg_bytes);
-
-                kunmap_atomic(page_addr, KM_SOFTIRQ0);
-                buf += sg_bytes;
-                offset += sg_bytes;
-                remaining -= sg_bytes;
-                copy_len += sg_bytes;
-        }
+        nents = scsi_sg_count(sc);
 
-        if (fr_flags(fp) & FCPHF_CRC_UNCHECKED) {
+        if (!(fr_flags(fp) & FCPHF_CRC_UNCHECKED)) {
+                copy_len = fc_copy_buffer_to_sglist(buf, len, sg, &nents,
+                                                    &offset, KM_SOFTIRQ0, NULL);
+        } else {
+                crc = crc32(~0, (u8 *) fh, sizeof(*fh));
+                copy_len = fc_copy_buffer_to_sglist(buf, len, sg, &nents,
+                                                    &offset, KM_SOFTIRQ0, &crc);
                 buf = fc_frame_payload_get(fp, 0);
-                if (len % 4) {
+                if (len % 4)
                         crc = crc32(crc, buf + len, 4 - (len % 4));
-                        len += 4 - (len % 4);
-                }
 
                 if (~crc != le32_to_cpu(fr_crc(fp))) {
 crc_err:
-                        stats = fc_lport_get_stats(lp);
+                        stats = fc_lport_get_stats(lport);
                         stats->ErrorFrames++;
                         /* FIXME - per cpu count, not total count! */
                         if (stats->InvalidCRCCount++ < 5)
                                 printk(KERN_WARNING "libfc: CRC error on data "
                                        "frame for port (%6x)\n",
-                                       fc_host_port_id(lp->host));
+                                       fc_host_port_id(lport->host));
                         /*
                          * Assume the frame is total garbage.
                          * We may have copied it over the good part
@@ -437,18 +512,17 @@ crc_err:
 }
 
 /**
- * fc_fcp_send_data() -  Send SCSI data to target.
- * @fsp: ptr to fc_fcp_pkt
- * @sp: ptr to this sequence
- * @offset: starting offset for this data request
- * @seq_blen: the burst length for this data request
+ * fc_fcp_send_data() - Send SCSI data to a target
+ * @fsp:      The FCP packet the data is on
+ * @sp:       The sequence the data is to be sent on
+ * @offset:   The starting offset for this data request
+ * @seq_blen: The burst length for this data request
  *
  * Called after receiving a Transfer Ready data descriptor.
- * if LLD is capable of seq offload then send down seq_blen
- * size of data in single frame, otherwise send multiple FC
- * frames of max FC frame payload supported by target port.
- *
- * Returns : 0 for success.
+ * If the LLD is capable of sequence offload then send down the
+ * seq_blen amount of data in single frame, otherwise send
+ * multiple frames of the maximum frame payload supported by
+ * the target port.
  */
 static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
                             size_t offset, size_t seq_blen)
@@ -457,16 +531,18 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
         struct scsi_cmnd *sc;
         struct scatterlist *sg;
         struct fc_frame *fp = NULL;
-        struct fc_lport *lp = fsp->lp;
+        struct fc_lport *lport = fsp->lp;
+        struct page *page;
         size_t remaining;
         size_t t_blen;
         size_t tlen;
         size_t sg_bytes;
         size_t frame_offset, fh_parm_offset;
+        size_t off;
         int error;
         void *data = NULL;
         void *page_addr;
-        int using_sg = lp->sg_supp;
+        int using_sg = lport->sg_supp;
         u32 f_ctl;
 
         WARN_ON(seq_blen <= 0);
@@ -488,10 +564,10 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
          * to max FC frame payload previously set in fsp->max_payload.
          */
         t_blen = fsp->max_payload;
-        if (lp->seq_offload) {
-                t_blen = min(seq_blen, (size_t)lp->lso_max);
+        if (lport->seq_offload) {
+                t_blen = min(seq_blen, (size_t)lport->lso_max);
                 FC_FCP_DBG(fsp, "fsp=%p:lso:blen=%zx lso_max=0x%x t_blen=%zx\n",
-                           fsp, seq_blen, lp->lso_max, t_blen);
+                           fsp, seq_blen, lport->lso_max, t_blen);
         }
 
         WARN_ON(t_blen < FC_MIN_MAX_PAYLOAD);
@@ -503,7 +579,7 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
         remaining = seq_blen;
         fh_parm_offset = frame_offset = offset;
         tlen = 0;
-        seq = lp->tt.seq_start_next(seq);
+        seq = lport->tt.seq_start_next(seq);
         f_ctl = FC_FC_REL_OFF;
         WARN_ON(!seq);
 
@@ -525,43 +601,34 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
                          */
                         if (tlen % 4)
                                 using_sg = 0;
-                        if (using_sg) {
-                                fp = _fc_frame_alloc(lp, 0);
-                                if (!fp)
-                                        return -ENOMEM;
-                        } else {
-                                fp = fc_frame_alloc(lp, tlen);
-                                if (!fp)
-                                        return -ENOMEM;
+                        fp = fc_frame_alloc(lport, using_sg ? 0 : tlen);
+                        if (!fp)
+                                return -ENOMEM;
 
-                                data = (void *)(fr_hdr(fp)) +
-                                        sizeof(struct fc_frame_header);
-                        }
+                        data = fc_frame_header_get(fp) + 1;
                         fh_parm_offset = frame_offset;
                         fr_max_payload(fp) = fsp->max_payload;
                 }
+
+                off = offset + sg->offset;
                 sg_bytes = min(tlen, sg->length - offset);
+                sg_bytes = min(sg_bytes,
+                               (size_t) (PAGE_SIZE - (off & ~PAGE_MASK)));
+                page = sg_page(sg) + (off >> PAGE_SHIFT);
                 if (using_sg) {
-                        get_page(sg_page(sg));
+                        get_page(page);
                         skb_fill_page_desc(fp_skb(fp),
                                            skb_shinfo(fp_skb(fp))->nr_frags,
-                                           sg_page(sg), sg->offset + offset,
-                                           sg_bytes);
+                                           page, off & ~PAGE_MASK, sg_bytes);
                         fp_skb(fp)->data_len += sg_bytes;
                         fr_len(fp) += sg_bytes;
                         fp_skb(fp)->truesize += PAGE_SIZE;
                 } else {
-                        size_t off = offset + sg->offset;
-
                         /*
                          * The scatterlist item may be bigger than PAGE_SIZE,
                          * but we must not cross pages inside the kmap.
                          */
-                        sg_bytes = min(sg_bytes, (size_t) (PAGE_SIZE -
-                                                           (off & ~PAGE_MASK)));
-                        page_addr = kmap_atomic(sg_page(sg) +
-                                                (off >> PAGE_SHIFT),
-                                                KM_SOFTIRQ0);
+                        page_addr = kmap_atomic(page, KM_SOFTIRQ0);
                         memcpy(data, (char *)page_addr + (off & ~PAGE_MASK),
                                sg_bytes);
                         kunmap_atomic(page_addr, KM_SOFTIRQ0);
@@ -572,7 +639,8 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
                 tlen -= sg_bytes;
                 remaining -= sg_bytes;
 
-                if (tlen)
+                if ((skb_shinfo(fp_skb(fp))->nr_frags < FC_FRAME_SG_LEN) &&
+                    (tlen))
                         continue;
 
                 /*
@@ -589,7 +657,7 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
                 /*
                  * send fragment using for a sequence.
                  */
-                error = lp->tt.seq_send(lp, seq, fp);
+                error = lport->tt.seq_send(lport, seq, fp);
                 if (error) {
                         WARN_ON(1);             /* send error should be rare */
                         fc_fcp_retry_cmd(fsp);
@@ -601,6 +669,11 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
         return 0;
 }
 
+/**
+ * fc_fcp_abts_resp() - Send an ABTS response
+ * @fsp: The FCP packet that is being aborted
+ * @fp:  The response frame
+ */
 static void fc_fcp_abts_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 {
         int ba_done = 1;
@@ -637,46 +710,13 @@ static void fc_fcp_abts_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 }
 
 /**
- * fc_fcp_reduce_can_queue() - drop can_queue
- * @lp: lport to drop queueing for
- *
- * If we are getting memory allocation failures, then we may
- * be trying to execute too many commands. We let the running
- * 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.
- */
-static void fc_fcp_reduce_can_queue(struct fc_lport *lp)
-{
-        struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
-        unsigned long flags;
-        int can_queue;
-
-        spin_lock_irqsave(lp->host->host_lock, flags);
-        if (si->throttled)
-                goto done;
-        si->throttled = 1;
-
-        can_queue = lp->host->can_queue;
-        can_queue >>= 1;
-        if (!can_queue)
-                can_queue = 1;
-        lp->host->can_queue = can_queue;
-        shost_printk(KERN_ERR, lp->host, "libfc: Could not allocate frame.\n"
-                     "Reducing can_queue to %d.\n", can_queue);
-done:
-        spin_unlock_irqrestore(lp->host->host_lock, flags);
-}
-
-/**
- * fc_fcp_recv() - Reveive FCP frames
+ * fc_fcp_recv() - Reveive an FCP frame
  * @seq: The sequence the frame is on
- * @fp: The FC frame
+ * @fp:  The received frame
  * @arg: The related FCP packet
  *
- * Return   : None
- * Context  : called from Soft IRQ context
- *            can not called holding list lock
+ * Context: Called from Soft IRQ context. Can not be called
+ *          holding the FCP packet list lock.
  */
 static void fc_fcp_recv(struct fc_seq *seq, struct fc_frame *fp, void *arg)
 {
@@ -687,8 +727,10 @@ static void fc_fcp_recv(struct fc_seq *seq, struct fc_frame *fp, void *arg)
         u8 r_ctl;
         int rc = 0;
 
-        if (IS_ERR(fp))
-                goto errout;
+        if (IS_ERR(fp)) {
+                fc_fcp_error(fsp, fp);
+                return;
+        }
 
         fh = fc_frame_header_get(fp);
         r_ctl = fh->fh_r_ctl;
@@ -721,8 +763,6 @@ static void fc_fcp_recv(struct fc_seq *seq, struct fc_frame *fp, void *arg)
                                       (size_t) ntohl(dd->ft_burst_len));
                 if (!rc)
                         seq->rec_data = fsp->xfer_len;
-                else if (rc == -ENOMEM)
-                        fsp->state |= FC_SRB_NOMEM;
         } else if (r_ctl == FC_RCTL_DD_SOL_DATA) {
                 /*
                  * received a DATA frame
@@ -742,13 +782,13 @@ unlock:
         fc_fcp_unlock_pkt(fsp);
 out:
         fc_frame_free(fp);
-errout:
-        if (IS_ERR(fp))
-                fc_fcp_error(fsp, fp);
-        else if (rc == -ENOMEM)
-                fc_fcp_reduce_can_queue(lport);
 }
 
+/**
+ * fc_fcp_resp() - Handler for FCP responses
+ * @fsp: The FCP packet the response is for
+ * @fp:  The response frame
+ */
 static void fc_fcp_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 {
         struct fc_frame_header *fh;
@@ -862,15 +902,16 @@ err:
 }
 
 /**
- * fc_fcp_complete_locked() - complete processing of a fcp packet
- * @fsp:        fcp packet
+ * fc_fcp_complete_locked() - Complete processing of a fcp_pkt with the
+ *                            fcp_pkt lock held
+ * @fsp: The FCP packet to be completed
  *
  * This function may sleep if a timer is pending. The packet lock must be
  * held, and the host lock must not be held.
  */
 static void fc_fcp_complete_locked(struct fc_fcp_pkt *fsp)
 {
-        struct fc_lport *lp = fsp->lp;
+        struct fc_lport *lport = fsp->lp;
         struct fc_seq *seq;
         struct fc_exch *ep;
         u32 f_ctl;
@@ -901,8 +942,8 @@ static void fc_fcp_complete_locked(struct fc_fcp_pkt *fsp)
                         struct fc_frame *conf_frame;
                         struct fc_seq *csp;
 
-                        csp = lp->tt.seq_start_next(seq);
-                        conf_frame = fc_frame_alloc(fsp->lp, 0);
+                        csp = lport->tt.seq_start_next(seq);
+                        conf_frame = fc_fcp_frame_alloc(fsp->lp, 0);
                         if (conf_frame) {
                                 f_ctl = FC_FC_SEQ_INIT;
                                 f_ctl |= FC_FC_LAST_SEQ | FC_FC_END_SEQ;
@@ -910,43 +951,48 @@ static void fc_fcp_complete_locked(struct fc_fcp_pkt *fsp)
                                 fc_fill_fc_hdr(conf_frame, FC_RCTL_DD_SOL_CTL,
                                                ep->did, ep->sid,
                                                FC_TYPE_FCP, f_ctl, 0);
-                                lp->tt.seq_send(lp, csp, conf_frame);
+                                lport->tt.seq_send(lport, csp, conf_frame);
                         }
                 }
-                lp->tt.exch_done(seq);
+                lport->tt.exch_done(seq);
         }
         fc_io_compl(fsp);
 }
 
+/**
+ * fc_fcp_cleanup_cmd() - Cancel the active exchange on a fcp_pkt
+ * @fsp:   The FCP packet whose exchanges should be canceled
+ * @error: The reason for the cancellation
+ */
 static void fc_fcp_cleanup_cmd(struct fc_fcp_pkt *fsp, int error)
 {
-        struct fc_lport *lp = fsp->lp;
+        struct fc_lport *lport = fsp->lp;
 
         if (fsp->seq_ptr) {
-                lp->tt.exch_done(fsp->seq_ptr);
+                lport->tt.exch_done(fsp->seq_ptr);
                 fsp->seq_ptr = NULL;
         }
         fsp->status_code = error;
 }
 
 /**
- * fc_fcp_cleanup_each_cmd() - Cleanup active commads
- * @lp:         logical port
- * @id:         target id
- * @lun:        lun
- * @error:      fsp status code
+ * fc_fcp_cleanup_each_cmd() - Cancel all exchanges on a local port
+ * @lport: The local port whose exchanges should be canceled
+ * @id:    The target's ID
+ * @lun:   The LUN
+ * @error: The reason for cancellation
  *
  * If lun or id is -1, they are ignored.
  */
-static void fc_fcp_cleanup_each_cmd(struct fc_lport *lp, unsigned int id,
+static void fc_fcp_cleanup_each_cmd(struct fc_lport *lport, unsigned int id,
                                     unsigned int lun, int error)
 {
-        struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
+        struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
         struct fc_fcp_pkt *fsp;
         struct scsi_cmnd *sc_cmd;
         unsigned long flags;
 
-        spin_lock_irqsave(lp->host->host_lock, flags);
+        spin_lock_irqsave(&si->scsi_queue_lock, flags);
 restart:
         list_for_each_entry(fsp, &si->scsi_pkt_queue, list) {
                 sc_cmd = fsp->cmd;
@@ -957,7 +1003,7 @@ restart:
                         continue;
 
                 fc_fcp_pkt_hold(fsp);
-                spin_unlock_irqrestore(lp->host->host_lock, flags);
+                spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
 
                 if (!fc_fcp_lock_pkt(fsp)) {
                         fc_fcp_cleanup_cmd(fsp, error);
@@ -966,35 +1012,37 @@ restart:
                 }
 
                 fc_fcp_pkt_release(fsp);
-                spin_lock_irqsave(lp->host->host_lock, flags);
+                spin_lock_irqsave(&si->scsi_queue_lock, flags);
                 /*
                  * while we dropped the lock multiple pkts could
                  * have been released, so we have to start over.
                  */
                 goto restart;
         }
-        spin_unlock_irqrestore(lp->host->host_lock, flags);
+        spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
 }
 
-static void fc_fcp_abort_io(struct fc_lport *lp)
+/**
+ * fc_fcp_abort_io() - Abort all FCP-SCSI exchanges on a local port
+ * @lport: The local port whose exchanges are to be aborted
+ */
+static void fc_fcp_abort_io(struct fc_lport *lport)
 {
-        fc_fcp_cleanup_each_cmd(lp, -1, -1, FC_HRD_ERROR);
+        fc_fcp_cleanup_each_cmd(lport, -1, -1, FC_HRD_ERROR);
 }
 
 /**
- * fc_fcp_pkt_send() - send a fcp packet to the lower level.
- * @lp:         fc lport
- * @fsp:        fc packet.
+ * fc_fcp_pkt_send() - Send a fcp_pkt
+ * @lport: The local port to send the FCP packet on
+ * @fsp:   The FCP packet to send
  *
- * This is called by upper layer protocol.
- * Return   : zero for success and -1 for failure
- * Context  : called from queuecommand which can be called from process
- *            or scsi soft irq.
- * Locks    : called with the host lock and irqs disabled.
+ * Return:  Zero for success and -1 for failure
+ * Locks:   Called without locks held
  */
-static int fc_fcp_pkt_send(struct fc_lport *lp, struct fc_fcp_pkt *fsp)
+static int fc_fcp_pkt_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp)
 {
-        struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
+        struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
+        unsigned long flags;
         int rc;
 
         fsp->cmd->SCp.ptr = (char *)fsp;
@@ -1004,18 +1052,27 @@ static int fc_fcp_pkt_send(struct fc_lport *lp, struct fc_fcp_pkt *fsp)
         int_to_scsilun(fsp->cmd->device->lun,
                        (struct scsi_lun *)fsp->cdb_cmd.fc_lun);
         memcpy(fsp->cdb_cmd.fc_cdb, fsp->cmd->cmnd, fsp->cmd->cmd_len);
-        list_add_tail(&fsp->list, &si->scsi_pkt_queue);
 
-        spin_unlock_irq(lp->host->host_lock);
-        rc = lp->tt.fcp_cmd_send(lp, fsp, fc_fcp_recv);
-        spin_lock_irq(lp->host->host_lock);
-        if (rc)
+        spin_lock_irqsave(&si->scsi_queue_lock, flags);
+        list_add_tail(&fsp->list, &si->scsi_pkt_queue);
+        spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
+        rc = lport->tt.fcp_cmd_send(lport, fsp, fc_fcp_recv);
+        if (unlikely(rc)) {
+                spin_lock_irqsave(&si->scsi_queue_lock, flags);
                 list_del(&fsp->list);
+                spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
+        }
 
         return rc;
 }
 
-static int fc_fcp_cmd_send(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
+/**
+ * fc_fcp_cmd_send() - Send a FCP command
+ * @lport: The local port to send the command on
+ * @fsp:   The FCP packet the command is on
+ * @resp:  The handler for the response
+ */
+static int fc_fcp_cmd_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
                            void (*resp)(struct fc_seq *,
                                         struct fc_frame *fp,
                                         void *arg))
@@ -1023,14 +1080,14 @@ static int fc_fcp_cmd_send(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
         struct fc_frame *fp;
         struct fc_seq *seq;
         struct fc_rport *rport;
-        struct fc_rport_libfc_priv *rp;
+        struct fc_rport_libfc_priv *rpriv;
         const size_t len = sizeof(fsp->cdb_cmd);
         int rc = 0;
 
         if (fc_fcp_lock_pkt(fsp))
                 return 0;
 
-        fp = fc_frame_alloc(lp, sizeof(fsp->cdb_cmd));
+        fp = fc_fcp_frame_alloc(lport, sizeof(fsp->cdb_cmd));
         if (!fp) {
                 rc = -1;
                 goto unlock;
@@ -1040,15 +1097,15 @@ static int fc_fcp_cmd_send(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
         fr_fsp(fp) = fsp;
         rport = fsp->rport;
         fsp->max_payload = rport->maxframe_size;
-        rp = rport->dd_data;
+        rpriv = rport->dd_data;
 
         fc_fill_fc_hdr(fp, FC_RCTL_DD_UNSOL_CMD, rport->port_id,
-                       fc_host_port_id(rp->local_port->host), FC_TYPE_FCP,
+                       fc_host_port_id(rpriv->local_port->host), FC_TYPE_FCP,
                        FC_FC_FIRST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
 
-        seq = lp->tt.exch_seq_send(lp, fp, resp, fc_fcp_pkt_destroy, fsp, 0);
+        seq = lport->tt.exch_seq_send(lport, fp, resp, fc_fcp_pkt_destroy,
+                                      fsp, 0);
         if (!seq) {
-                fc_frame_free(fp);
                 rc = -1;
                 goto unlock;
         }
@@ -1065,8 +1122,10 @@ unlock:
         return rc;
 }
 
-/*
- * transport error handler
+/**
+ * fc_fcp_error() - Handler for FCP layer errors
+ * @fsp: The FCP packet the error is on
+ * @fp:  The frame that has errored
  */
 static void fc_fcp_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 {
@@ -1091,11 +1150,13 @@ unlock:
         fc_fcp_unlock_pkt(fsp);
 }
 
-/*
- * Scsi abort handler- calls to send an abort
- * and then wait for abort completion
+/**
+ * fc_fcp_pkt_abort() - Abort a fcp_pkt
+ * @fsp:   The FCP packet to abort on
+ *
+ * Called to send an abort and then wait for abort completion
  */
-static int fc_fcp_pkt_abort(struct fc_lport *lp, struct fc_fcp_pkt *fsp)
+static int fc_fcp_pkt_abort(struct fc_fcp_pkt *fsp)
 {
         int rc = FAILED;
 
@@ -1122,14 +1183,15 @@ static int fc_fcp_pkt_abort(struct fc_lport *lp, struct fc_fcp_pkt *fsp)
         return rc;
 }
 
-/*
- * Retry LUN reset after resource allocation failed.
+/**
+ * fc_lun_reset_send() - Send LUN reset command
+ * @data: The FCP packet that identifies the LUN to be reset
  */
 static void fc_lun_reset_send(unsigned long data)
 {
         struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
-        struct fc_lport *lp = fsp->lp;
-        if (lp->tt.fcp_cmd_send(lp, fsp, fc_tm_done)) {
+        struct fc_lport *lport = fsp->lp;
+        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))
@@ -1140,11 +1202,15 @@ static void fc_lun_reset_send(unsigned long data)
         }
 }
 
-/*
- * Scsi device reset handler- send a LUN RESET to the device
- * and wait for reset reply
+/**
+ * fc_lun_reset() - Send a LUN RESET command to a device
+ *                  and wait for the reply
+ * @lport: The local port to sent the comand on
+ * @fsp:   The FCP packet that identifies the LUN to be reset
+ * @id:    The SCSI command ID
+ * @lun:   The LUN ID to be reset
  */
-static int fc_lun_reset(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
+static int fc_lun_reset(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
                         unsigned int id, unsigned int lun)
 {
         int rc;
@@ -1172,14 +1238,14 @@ static int fc_lun_reset(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
 
         spin_lock_bh(&fsp->scsi_pkt_lock);
         if (fsp->seq_ptr) {
-                lp->tt.exch_done(fsp->seq_ptr);
+                lport->tt.exch_done(fsp->seq_ptr);
                 fsp->seq_ptr = NULL;
         }
         fsp->wait_for_comp = 0;
         spin_unlock_bh(&fsp->scsi_pkt_lock);
 
         if (!rc) {
-                FC_SCSI_DBG(lp, "lun reset failed\n");
+                FC_SCSI_DBG(lport, "lun reset failed\n");
                 return FAILED;
         }
 
@@ -1187,13 +1253,16 @@ static int fc_lun_reset(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
         if (fsp->cdb_status != FCP_TMF_CMPL)
                 return FAILED;
 
-        FC_SCSI_DBG(lp, "lun reset to lun %u completed\n", lun);
-        fc_fcp_cleanup_each_cmd(lp, id, lun, FC_CMD_ABORTED);
+        FC_SCSI_DBG(lport, "lun reset to lun %u completed\n", lun);
+        fc_fcp_cleanup_each_cmd(lport, id, lun, FC_CMD_ABORTED);
         return SUCCESS;
 }
 
-/*
- * Task Managment response handler
+/**
+ * fc_tm_done() - Task Managment response handler
+ * @seq: The sequence that the response is on
+ * @fp:  The response frame
+ * @arg: The FCP packet the response is for
  */
 static void fc_tm_done(struct fc_seq *seq, struct fc_frame *fp, void *arg)
 {
@@ -1230,34 +1299,31 @@ static void fc_tm_done(struct fc_seq *seq, struct fc_frame *fp, void *arg)
         fc_fcp_unlock_pkt(fsp);
 }
 
-static void fc_fcp_cleanup(struct fc_lport *lp)
+/**
+ * fc_fcp_cleanup() - Cleanup all FCP exchanges on a local port
+ * @lport: The local port to be cleaned up
+ */
+static void fc_fcp_cleanup(struct fc_lport *lport)
 {
-        fc_fcp_cleanup_each_cmd(lp, -1, -1, FC_ERROR);
+        fc_fcp_cleanup_each_cmd(lport, -1, -1, FC_ERROR);
 }
 
-/*
- * fc_fcp_timeout: called by OS timer function.
- *
- * The timer has been inactivated and must be reactivated if desired
- * using fc_fcp_timer_set().
- *
- * Algorithm:
- *
- * If REC is supported, just issue it, and return.  The REC exchange will
- * complete or time out, and recovery can continue at that point.
- *
- * Otherwise, if the response has been received without all the data,
- * it has been ER_TIMEOUT since the response was received.
+/**
+ * fc_fcp_timeout() - Handler for fcp_pkt timeouts
+ * @data: The FCP packet that has timed out
  *
- * If the response has not been received,
- * we see if data was received recently.  If it has been, we continue waiting,
- * otherwise, we abort the command.
+ * If REC is supported then just issue it and return. The REC exchange will
+ * complete or time out and recovery can continue at that point. Otherwise,
+ * if the response has been received without all the data it has been
+ * ER_TIMEOUT since the response was received. If the response has not been
+ * received we see if data was received recently. If it has been then we
+ * continue waiting, otherwise, we abort the command.
  */
 static void fc_fcp_timeout(unsigned long data)
 {
         struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
         struct fc_rport *rport = fsp->rport;
-        struct fc_rport_libfc_priv *rp = rport->dd_data;
+        struct fc_rport_libfc_priv *rpriv = rport->dd_data;
 
         if (fc_fcp_lock_pkt(fsp))
                 return;
@@ -1267,7 +1333,7 @@ static void fc_fcp_timeout(unsigned long data)
 
         fsp->state |= FC_SRB_FCP_PROCESSING_TMO;
 
-        if (rp->flags & FC_RP_FLAGS_REC_SUPPORTED)
+        if (rpriv->flags & FC_RP_FLAGS_REC_SUPPORTED)
                 fc_fcp_rec(fsp);
         else if (time_after_eq(fsp->last_pkt_time + (FC_SCSI_ER_TIMEOUT / 2),
                                jiffies))
@@ -1281,39 +1347,40 @@ unlock:
         fc_fcp_unlock_pkt(fsp);
 }
 
-/*
- * Send a REC ELS request
+/**
+ * fc_fcp_rec() - Send a REC ELS request
+ * @fsp: The FCP packet to send the REC request on
  */
 static void fc_fcp_rec(struct fc_fcp_pkt *fsp)
 {
-        struct fc_lport *lp;
+        struct fc_lport *lport;
         struct fc_frame *fp;
         struct fc_rport *rport;
-        struct fc_rport_libfc_priv *rp;
+        struct fc_rport_libfc_priv *rpriv;
 
-        lp = fsp->lp;
+        lport = fsp->lp;
         rport = fsp->rport;
-        rp = rport->dd_data;
-        if (!fsp->seq_ptr || rp->rp_state != RPORT_ST_READY) {
+        rpriv = rport->dd_data;
+        if (!fsp->seq_ptr || rpriv->rp_state != RPORT_ST_READY) {
                 fsp->status_code = FC_HRD_ERROR;
                 fsp->io_status = 0;
                 fc_fcp_complete_locked(fsp);
                 return;
         }
-        fp = fc_frame_alloc(lp, sizeof(struct fc_els_rec));
+        fp = fc_fcp_frame_alloc(lport, sizeof(struct fc_els_rec));
         if (!fp)
                 goto retry;
 
         fr_seq(fp) = fsp->seq_ptr;
         fc_fill_fc_hdr(fp, FC_RCTL_ELS_REQ, rport->port_id,
-                       fc_host_port_id(rp->local_port->host), FC_TYPE_ELS,
+                       fc_host_port_id(rpriv->local_port->host), FC_TYPE_ELS,
                        FC_FC_FIRST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
-        if (lp->tt.elsct_send(lp, rport->port_id, fp, ELS_REC, fc_fcp_rec_resp,
-                              fsp, jiffies_to_msecs(FC_SCSI_REC_TOV))) {
+        if (lport->tt.elsct_send(lport, rport->port_id, fp, ELS_REC,
+                                 fc_fcp_rec_resp, fsp,
+                                 jiffies_to_msecs(FC_SCSI_REC_TOV))) {
                 fc_fcp_pkt_hold(fsp);           /* hold while REC outstanding */
                 return;
         }
-        fc_frame_free(fp);
 retry:
         if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
                 fc_fcp_timer_set(fsp, FC_SCSI_REC_TOV);
@@ -1321,12 +1388,16 @@ retry:
                 fc_timeout_error(fsp);
 }
 
-/*
- * Receive handler for REC ELS frame
- * if it is a reject then let the scsi layer to handle
- * the timeout. if it is a LS_ACC then if the io was not completed
- * then set the timeout and return otherwise complete the exchange
- * and tell the scsi layer to restart the I/O.
+/**
+ * fc_fcp_rec_resp() - Handler for REC ELS responses
+ * @seq: The sequence the response is on
+ * @fp:  The response frame
+ * @arg: The FCP packet the response is on
+ *
+ * If the response is a reject then the scsi layer will handle
+ * the timeout. If the response is a LS_ACC then if the I/O was not completed
+ * set the timeout and return. If the I/O was completed then complete the
+ * exchange and tell the SCSI layer.
  */
 static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
 {
@@ -1338,7 +1409,7 @@ static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
         u32 offset;
         enum dma_data_direction data_dir;
         enum fc_rctl r_ctl;
-        struct fc_rport_libfc_priv *rp;
+        struct fc_rport_libfc_priv *rpriv;
 
         if (IS_ERR(fp)) {
                 fc_fcp_rec_error(fsp, fp);
@@ -1361,13 +1432,13 @@ static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
                         /* fall through */
                 case ELS_RJT_UNSUP:
                         FC_FCP_DBG(fsp, "device does not support REC\n");
-                        rp = fsp->rport->dd_data;
+                        rpriv = fsp->rport->dd_data;
                         /*
                          * if we do not spport RECs or got some bogus
                          * reason then resetup timer so we check for
                          * making progress.
                          */
-                        rp->flags &= ~FC_RP_FLAGS_REC_SUPPORTED;
+                        rpriv->flags &= ~FC_RP_FLAGS_REC_SUPPORTED;
                         fc_fcp_timer_set(fsp, FC_SCSI_ER_TIMEOUT);
                         break;
                 case ELS_RJT_LOGIC:
@@ -1464,8 +1535,10 @@ out:
         fc_frame_free(fp);
 }
 
-/*
- * Handle error response or timeout for REC exchange.
+/**
+ * fc_fcp_rec_error() - Handler for REC errors
+ * @fsp: The FCP packet the error is on
+ * @fp:  The REC frame
  */
 static void fc_fcp_rec_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 {
@@ -1504,10 +1577,9 @@ out:
         fc_fcp_pkt_release(fsp);        /* drop hold for outstanding REC */
 }
 
-/*
- * Time out error routine:
- * abort's the I/O close the exchange and
- * send completion notification to scsi layer
+/**
+ * fc_timeout_error() - Handler for fcp_pkt timeouts
+ * @fsp: The FCP packt that has timed out
  */
 static void fc_timeout_error(struct fc_fcp_pkt *fsp)
 {
@@ -1521,16 +1593,18 @@ static void fc_timeout_error(struct fc_fcp_pkt *fsp)
         fc_fcp_send_abort(fsp);
 }
 
-/*
- * Sequence retransmission request.
+/**
+ * fc_fcp_srr() - Send a SRR request (Sequence Retransmission Request)
+ * @fsp:   The FCP packet the SRR is to be sent on
+ * @r_ctl: The R_CTL field for the SRR request
  * This is called after receiving status but insufficient data, or
  * when expecting status but the request has timed out.
  */
 static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
 {
-        struct fc_lport *lp = fsp->lp;
+        struct fc_lport *lport = fsp->lp;
         struct fc_rport *rport;
-        struct fc_rport_libfc_priv *rp;
+        struct fc_rport_libfc_priv *rpriv;
         struct fc_exch *ep = fc_seq_exch(fsp->seq_ptr);
         struct fc_seq *seq;
         struct fcp_srr *srr;
@@ -1538,12 +1612,13 @@ static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
         u8 cdb_op;
 
         rport = fsp->rport;
-        rp = rport->dd_data;
+        rpriv = rport->dd_data;
         cdb_op = fsp->cdb_cmd.fc_cdb[0];
 
-        if (!(rp->flags & FC_RP_FLAGS_RETRY) || rp->rp_state != RPORT_ST_READY)
+        if (!(rpriv->flags & FC_RP_FLAGS_RETRY) ||
+            rpriv->rp_state != RPORT_ST_READY)
                 goto retry;                     /* shouldn't happen */
-        fp = fc_frame_alloc(lp, sizeof(*srr));
+        fp = fc_fcp_frame_alloc(lport, sizeof(*srr));
         if (!fp)
                 goto retry;
 
@@ -1556,15 +1631,14 @@ static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
         srr->srr_rel_off = htonl(offset);
 
         fc_fill_fc_hdr(fp, FC_RCTL_ELS4_REQ, rport->port_id,
-                       fc_host_port_id(rp->local_port->host), FC_TYPE_FCP,
+                       fc_host_port_id(rpriv->local_port->host), FC_TYPE_FCP,
                        FC_FC_FIRST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
 
-        seq = lp->tt.exch_seq_send(lp, fp, fc_fcp_srr_resp, NULL,
-                                   fsp, jiffies_to_msecs(FC_SCSI_REC_TOV));
-        if (!seq) {
-                fc_frame_free(fp);
+        seq = lport->tt.exch_seq_send(lport, fp, fc_fcp_srr_resp, NULL,
+                                      fsp, jiffies_to_msecs(FC_SCSI_REC_TOV));
+        if (!seq)
                 goto retry;
-        }
+
         fsp->recov_seq = seq;
         fsp->xfer_len = offset;
         fsp->xfer_contig_end = offset;
@@ -1575,8 +1649,11 @@ retry:
         fc_fcp_retry_cmd(fsp);
 }
 
-/*
- * Handle response from SRR.
+/**
+ * fc_fcp_srr_resp() - Handler for SRR response
+ * @seq: The sequence the SRR is on
+ * @fp:  The SRR frame
+ * @arg: The FCP packet the SRR is on
  */
 static void fc_fcp_srr_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
 {
@@ -1622,6 +1699,11 @@ out:
         fc_fcp_pkt_release(fsp);        /* drop hold for outstanding SRR */
 }
 
+/**
+ * fc_fcp_srr_error() - Handler for SRR errors
+ * @fsp: The FCP packet that the SRR error is on
+ * @fp:  The SRR frame
+ */
 static void fc_fcp_srr_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 {
         if (fc_fcp_lock_pkt(fsp))
@@ -1646,31 +1728,37 @@ out:
         fc_fcp_pkt_release(fsp);        /* drop hold for outstanding SRR */
 }
 
-static inline int fc_fcp_lport_queue_ready(struct fc_lport *lp)
+/**
+ * fc_fcp_lport_queue_ready() - Determine if the lport and it's queue is ready
+ * @lport: The local port to be checked
+ */
+static inline int fc_fcp_lport_queue_ready(struct fc_lport *lport)
 {
         /* lock ? */
-        return (lp->state == LPORT_ST_READY) && lp->link_up && !lp->qfull;
+        return (lport->state == LPORT_ST_READY) &&
+                lport->link_up && !lport->qfull;
 }
 
 /**
- * fc_queuecommand - The queuecommand function of the scsi template
- * @cmd:        struct scsi_cmnd to be executed
- * @done:       Callback function to be called when cmd is completed
+ * fc_queuecommand() - The queuecommand function of the SCSI template
+ * @cmd:   The scsi_cmnd to be executed
+ * @done:  The callback function to be called when the scsi_cmnd is complete
  *
- * this is the i/o strategy routine, called by the scsi layer
- * this routine is called with holding the host_lock.
+ * This is the i/o strategy routine, called by the SCSI layer. This routine
+ * is called with the host_lock held.
  */
 int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
 {
-        struct fc_lport *lp;
+        struct fc_lport *lport;
         struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
         struct fc_fcp_pkt *fsp;
-        struct fc_rport_libfc_priv *rp;
+        struct fc_rport_libfc_priv *rpriv;
         int rval;
         int rc = 0;
         struct fcoe_dev_stats *stats;
 
-        lp = shost_priv(sc_cmd->device->host);
+        lport = shost_priv(sc_cmd->device->host);
+        spin_unlock_irq(lport->host->host_lock);
 
         rval = fc_remote_port_chkready(rport);
         if (rval) {
@@ -1689,14 +1777,16 @@ int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
                 goto out;
         }
 
-        rp = rport->dd_data;
+        rpriv = rport->dd_data;
 
-        if (!fc_fcp_lport_queue_ready(lp)) {
+        if (!fc_fcp_lport_queue_ready(lport)) {
+                if (lport->qfull)
+                        fc_fcp_can_queue_ramp_down(lport);
                 rc = SCSI_MLQUEUE_HOST_BUSY;
                 goto out;
         }
 
-        fsp = fc_fcp_pkt_alloc(lp, GFP_ATOMIC);
+        fsp = fc_fcp_pkt_alloc(lport, GFP_ATOMIC);
         if (fsp == NULL) {
                 rc = SCSI_MLQUEUE_HOST_BUSY;
                 goto out;
@@ -1706,8 +1796,9 @@ int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
          * build the libfc request pkt
          */
         fsp->cmd = sc_cmd;      /* save the cmd */
-        fsp->lp = lp;           /* save the softc ptr */
+        fsp->lp = lport;        /* save the softc ptr */
         fsp->rport = rport;     /* set the remote port ptr */
+        fsp->xfer_ddp = FC_XID_UNKNOWN;
         sc_cmd->scsi_done = done;
 
         /*
@@ -1719,7 +1810,7 @@ int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
         /*
          * setup the data direction
          */
-        stats = fc_lport_get_stats(lp);
+        stats = fc_lport_get_stats(lport);
         if (sc_cmd->sc_data_direction == DMA_FROM_DEVICE) {
                 fsp->req_flags = FC_SRB_READ;
                 stats->InputRequests++;
@@ -1733,7 +1824,7 @@ int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
                 stats->ControlRequests++;
         }
 
-        fsp->tgt_flags = rp->flags;
+        fsp->tgt_flags = rpriv->flags;
 
         init_timer(&fsp->timer);
         fsp->timer.data = (unsigned long)fsp;
@@ -1743,30 +1834,30 @@ int fc_queuecommand(struct scsi_cmnd *sc_cmd, void (*done)(struct scsi_cmnd *))
          * if we get -1 return then put the request in the pending
          * queue.
          */
-        rval = fc_fcp_pkt_send(lp, fsp);
+        rval = fc_fcp_pkt_send(lport, fsp);
         if (rval != 0) {
                 fsp->state = FC_SRB_FREE;
                 fc_fcp_pkt_release(fsp);
                 rc = SCSI_MLQUEUE_HOST_BUSY;
         }
 out:
+        spin_lock_irq(lport->host->host_lock);
         return rc;
 }
 EXPORT_SYMBOL(fc_queuecommand);
 
 /**
- * fc_io_compl() -  Handle responses for completed commands
- * @fsp:        scsi packet
- *
- * Translates a error to a Linux SCSI error.
+ * fc_io_compl() - Handle responses for completed commands
+ * @fsp: The FCP packet that is complete
  *
+ * Translates fcp_pkt errors to a Linux SCSI errors.
  * The fcp packet lock must be held when calling.
  */
 static void fc_io_compl(struct fc_fcp_pkt *fsp)
 {
         struct fc_fcp_internal *si;
         struct scsi_cmnd *sc_cmd;
-        struct fc_lport *lp;
+        struct fc_lport *lport;
         unsigned long flags;
 
         /* release outstanding ddp context */
@@ -1779,30 +1870,23 @@ static void fc_io_compl(struct fc_fcp_pkt *fsp)
                 spin_lock_bh(&fsp->scsi_pkt_lock);
         }
 
-        lp = fsp->lp;
-        si = fc_get_scsi_internal(lp);
-        spin_lock_irqsave(lp->host->host_lock, flags);
-        if (!fsp->cmd) {
-                spin_unlock_irqrestore(lp->host->host_lock, flags);
+        lport = fsp->lp;
+        si = fc_get_scsi_internal(lport);
+        if (!fsp->cmd)
                 return;
-        }
 
         /*
-         * if a command timed out while we had to try and throttle IO
-         * and it is now getting cleaned up, then we are about to
-         * try again so clear the throttled flag incase we get more
-         * time outs.
+         * if can_queue ramp down is done then try can_queue ramp up
+         * since commands are completing now.
          */
-        if (si->throttled && fsp->state & FC_SRB_NOMEM)
-                si->throttled = 0;
+        if (si->last_can_queue_ramp_down_time)
+                fc_fcp_can_queue_ramp_up(lport);
 
         sc_cmd = fsp->cmd;
         fsp->cmd = NULL;
 
-        if (!sc_cmd->SCp.ptr) {
-                spin_unlock_irqrestore(lp->host->host_lock, flags);
+        if (!sc_cmd->SCp.ptr)
                 return;
-        }
 
         CMD_SCSI_STATUS(sc_cmd) = fsp->cdb_status;
         switch (fsp->status_code) {
@@ -1814,21 +1898,6 @@ static void fc_io_compl(struct fc_fcp_pkt *fsp)
                         sc_cmd->result = DID_OK << 16;
                         if (fsp->scsi_resid)
                                 CMD_RESID_LEN(sc_cmd) = fsp->scsi_resid;
-                } else if (fsp->cdb_status == QUEUE_FULL) {
-                        struct scsi_device *tmp_sdev;
-                        struct scsi_device *sdev = sc_cmd->device;
-
-                        shost_for_each_device(tmp_sdev, sdev->host) {
-                                if (tmp_sdev->id != sdev->id)
-                                        continue;
-
-                                if (tmp_sdev->queue_depth > 1) {
-                                        scsi_track_queue_full(tmp_sdev,
-                                                              tmp_sdev->
-                                                              queue_depth - 1);
-                                }
-                        }
-                        sc_cmd->result = (DID_OK << 16) | fsp->cdb_status;
                 } else {
                         /*
                          * transport level I/O was ok but scsi
@@ -1846,7 +1915,8 @@ static void fc_io_compl(struct fc_fcp_pkt *fsp)
                          * scsi status is good but transport level
                          * underrun.
                          */
-                        sc_cmd->result = DID_OK << 16;
+                        sc_cmd->result = (fsp->state & FC_SRB_RCV_STATUS ?
+                                          DID_OK : DID_ERROR) << 16;
                 } else {
                         /*
                          * scsi got underrun, this is an error
@@ -1878,63 +1948,46 @@ static void fc_io_compl(struct fc_fcp_pkt *fsp)
                 break;
         }
 
+        spin_lock_irqsave(&si->scsi_queue_lock, flags);
         list_del(&fsp->list);
+        spin_unlock_irqrestore(&si->scsi_queue_lock, flags);
         sc_cmd->SCp.ptr = NULL;
         sc_cmd->scsi_done(sc_cmd);
-        spin_unlock_irqrestore(lp->host->host_lock, flags);
 
         /* release ref from initial allocation in queue command */
         fc_fcp_pkt_release(fsp);
 }
 
 /**
- * fc_fcp_complete() - complete processing of a fcp packet
- * @fsp:        fcp packet
- *
- * This function may sleep if a fsp timer is pending.
- * The host lock must not be held by caller.
- */
-void fc_fcp_complete(struct fc_fcp_pkt *fsp)
-{
-        if (fc_fcp_lock_pkt(fsp))
-                return;
-
-        fc_fcp_complete_locked(fsp);
-        fc_fcp_unlock_pkt(fsp);
-}
-EXPORT_SYMBOL(fc_fcp_complete);
-
-/**
  * fc_eh_abort() - Abort a command
- * @sc_cmd:     scsi command to abort
+ * @sc_cmd: The SCSI command to abort
  *
- * From scsi host template.
- * send ABTS to the target device  and wait for the response
- * sc_cmd is the pointer to the command to be aborted.
+ * From SCSI host template.
+ * Send an ABTS to the target device and wait for the response.
  */
 int fc_eh_abort(struct scsi_cmnd *sc_cmd)
 {
         struct fc_fcp_pkt *fsp;
-        struct fc_lport *lp;
+        struct fc_lport *lport;
         int rc = FAILED;
         unsigned long flags;
 
-        lp = shost_priv(sc_cmd->device->host);
-        if (lp->state != LPORT_ST_READY)
+        lport = shost_priv(sc_cmd->device->host);
+        if (lport->state != LPORT_ST_READY)
                 return rc;
-        else if (!lp->link_up)
+        else if (!lport->link_up)
                 return rc;
 
-        spin_lock_irqsave(lp->host->host_lock, flags);
+        spin_lock_irqsave(lport->host->host_lock, flags);
         fsp = CMD_SP(sc_cmd);
         if (!fsp) {
                 /* command completed while scsi eh was setting up */
-                spin_unlock_irqrestore(lp->host->host_lock, flags);
+                spin_unlock_irqrestore(lport->host->host_lock, flags);
                 return SUCCESS;
         }
         /* grab a ref so the fsp and sc_cmd cannot be relased from under us */
         fc_fcp_pkt_hold(fsp);
-        spin_unlock_irqrestore(lp->host->host_lock, flags);
+        spin_unlock_irqrestore(lport->host->host_lock, flags);
 
         if (fc_fcp_lock_pkt(fsp)) {
                 /* completed while we were waiting for timer to be deleted */
@@ -1942,7 +1995,7 @@ int fc_eh_abort(struct scsi_cmnd *sc_cmd)
                 goto release_pkt;
         }
 
-        rc = fc_fcp_pkt_abort(lp, fsp);
+        rc = fc_fcp_pkt_abort(fsp);
         fc_fcp_unlock_pkt(fsp);
 
 release_pkt:
@@ -1952,37 +2005,34 @@ release_pkt:
 EXPORT_SYMBOL(fc_eh_abort);
 
 /**
- * fc_eh_device_reset() Reset a single LUN
- * @sc_cmd:     scsi command
+ * fc_eh_device_reset() - Reset a single LUN
+ * @sc_cmd: The SCSI command which identifies the device whose
+ *          LUN is to be reset
  *
- * Set from scsi host template to send tm cmd to the target and wait for the
- * response.
+ * Set from SCSI host template.
  */
 int fc_eh_device_reset(struct scsi_cmnd *sc_cmd)
 {
-        struct fc_lport *lp;
+        struct fc_lport *lport;
         struct fc_fcp_pkt *fsp;
         struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
         int rc = FAILED;
-        struct fc_rport_libfc_priv *rp;
         int rval;
 
         rval = fc_remote_port_chkready(rport);
         if (rval)
                 goto out;
 
-        rp = rport->dd_data;
-        lp = shost_priv(sc_cmd->device->host);
+        lport = shost_priv(sc_cmd->device->host);
 
-        if (lp->state != LPORT_ST_READY)
+        if (lport->state != LPORT_ST_READY)
                 return rc;
 
-        FC_SCSI_DBG(lp, "Resetting rport (%6x)\n", rport->port_id);
+        FC_SCSI_DBG(lport, "Resetting rport (%6x)\n", rport->port_id);
 
-        fsp = fc_fcp_pkt_alloc(lp, GFP_NOIO);
+        fsp = fc_fcp_pkt_alloc(lport, GFP_NOIO);
         if (fsp == NULL) {
                 printk(KERN_WARNING "libfc: could not allocate scsi_pkt\n");
-                sc_cmd->result = DID_NO_CONNECT << 16;
                 goto out;
         }
 
@@ -1991,13 +2041,13 @@ int fc_eh_device_reset(struct scsi_cmnd *sc_cmd)
          * the sc passed in is not setup for execution like when sent
          * through the queuecommand callout.
          */
-        fsp->lp = lp;           /* save the softc ptr */
+        fsp->lp = lport;        /* save the softc ptr */
         fsp->rport = rport;     /* set the remote port ptr */
 
         /*
          * flush outstanding commands
          */
-        rc = fc_lun_reset(lp, fsp, scmd_id(sc_cmd), sc_cmd->device->lun);
+        rc = fc_lun_reset(lport, fsp, scmd_id(sc_cmd), sc_cmd->device->lun);
         fsp->state = FC_SRB_FREE;
         fc_fcp_pkt_release(fsp);
 
@@ -2007,38 +2057,39 @@ out:
 EXPORT_SYMBOL(fc_eh_device_reset);
 
 /**
- * fc_eh_host_reset() - The reset function will reset the ports on the host.
- * @sc_cmd:     scsi command
+ * fc_eh_host_reset() - Reset a Scsi_Host.
+ * @sc_cmd: The SCSI command that identifies the SCSI host to be reset
  */
 int fc_eh_host_reset(struct scsi_cmnd *sc_cmd)
 {
         struct Scsi_Host *shost = sc_cmd->device->host;
-        struct fc_lport *lp = shost_priv(shost);
+        struct fc_lport *lport = shost_priv(shost);
         unsigned long wait_tmo;
 
-        FC_SCSI_DBG(lp, "Resetting host\n");
+        FC_SCSI_DBG(lport, "Resetting host\n");
 
-        lp->tt.lport_reset(lp);
+        lport->tt.lport_reset(lport);
         wait_tmo = jiffies + FC_HOST_RESET_TIMEOUT;
-        while (!fc_fcp_lport_queue_ready(lp) && time_before(jiffies, wait_tmo))
+        while (!fc_fcp_lport_queue_ready(lport) && time_before(jiffies,
+                                                               wait_tmo))
                 msleep(1000);
 
-        if (fc_fcp_lport_queue_ready(lp)) {
+        if (fc_fcp_lport_queue_ready(lport)) {
                 shost_printk(KERN_INFO, shost, "libfc: Host reset succeeded "
-                             "on port (%6x)\n", fc_host_port_id(lp->host));
+                             "on port (%6x)\n", fc_host_port_id(lport->host));
                 return SUCCESS;
         } else {
                 shost_printk(KERN_INFO, shost, "libfc: Host reset failed, "
                              "port (%6x) is not ready.\n",
-                             fc_host_port_id(lp->host));
+                             fc_host_port_id(lport->host));
                 return FAILED;
         }
 }
 EXPORT_SYMBOL(fc_eh_host_reset);
 
 /**
- * fc_slave_alloc() - configure queue depth
- * @sdev:       scsi device
+ * fc_slave_alloc() - Configure the queue depth of a Scsi_Host
+ * @sdev: The SCSI device that identifies the SCSI host
  *
  * Configures queue depth based on host's cmd_per_len. If not set
  * then we use the libfc default.
@@ -2046,29 +2097,50 @@ EXPORT_SYMBOL(fc_eh_host_reset);
 int fc_slave_alloc(struct scsi_device *sdev)
 {
         struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
-        int queue_depth;
 
         if (!rport || fc_remote_port_chkready(rport))
                 return -ENXIO;
 
-        if (sdev->tagged_supported) {
-                if (sdev->host->hostt->cmd_per_lun)
-                        queue_depth = sdev->host->hostt->cmd_per_lun;
-                else
-                        queue_depth = FC_FCP_DFLT_QUEUE_DEPTH;
-                scsi_activate_tcq(sdev, queue_depth);
-        }
+        if (sdev->tagged_supported)
+                scsi_activate_tcq(sdev, FC_FCP_DFLT_QUEUE_DEPTH);
+        else
+                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev),
+                                        FC_FCP_DFLT_QUEUE_DEPTH);
+
         return 0;
 }
 EXPORT_SYMBOL(fc_slave_alloc);
 
-int fc_change_queue_depth(struct scsi_device *sdev, int qdepth)
+/**
+ * fc_change_queue_depth() - Change a device's queue depth
+ * @sdev:   The SCSI device whose queue depth is to change
+ * @qdepth: The new queue depth
+ * @reason: The resason for the change
+ */
+int fc_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
 {
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+        switch (reason) {
+        case SCSI_QDEPTH_DEFAULT:
+                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+                break;
+        case SCSI_QDEPTH_QFULL:
+                scsi_track_queue_full(sdev, qdepth);
+                break;
+        case SCSI_QDEPTH_RAMP_UP:
+                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+                break;
+        default:
+                return -EOPNOTSUPP;
+        }
         return sdev->queue_depth;
 }
 EXPORT_SYMBOL(fc_change_queue_depth);
 
+/**
+ * fc_change_queue_type() - Change a device's queue type
+ * @sdev:     The SCSI device whose queue depth is to change
+ * @tag_type: Identifier for queue type
+ */
 int fc_change_queue_type(struct scsi_device *sdev, int tag_type)
 {
         if (sdev->tagged_supported) {
@@ -2084,39 +2156,71 @@ int fc_change_queue_type(struct scsi_device *sdev, int tag_type)
 }
 EXPORT_SYMBOL(fc_change_queue_type);
 
-void fc_fcp_destroy(struct fc_lport *lp)
+/**
+ * fc_fcp_destory() - Tear down the FCP layer for a given local port
+ * @lport: The local port that no longer needs the FCP layer
+ */
+void fc_fcp_destroy(struct fc_lport *lport)
 {
-        struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
+        struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
 
         if (!list_empty(&si->scsi_pkt_queue))
                 printk(KERN_ERR "libfc: Leaked SCSI packets when destroying "
-                       "port (%6x)\n", fc_host_port_id(lp->host));
+                       "port (%6x)\n", fc_host_port_id(lport->host));
 
         mempool_destroy(si->scsi_pkt_pool);
         kfree(si);
-        lp->scsi_priv = NULL;
+        lport->scsi_priv = NULL;
 }
 EXPORT_SYMBOL(fc_fcp_destroy);
 
-int fc_fcp_init(struct fc_lport *lp)
+int fc_setup_fcp()
+{
+        int rc = 0;
+
+        scsi_pkt_cachep = kmem_cache_create("libfc_fcp_pkt",
+                                            sizeof(struct fc_fcp_pkt),
+                                            0, SLAB_HWCACHE_ALIGN, NULL);
+        if (!scsi_pkt_cachep) {
+                printk(KERN_ERR "libfc: Unable to allocate SRB cache, "
+                       "module load failed!");
+                rc = -ENOMEM;
+        }
+
+        return rc;
+}
+
+void fc_destroy_fcp()
+{
+        if (scsi_pkt_cachep)
+                kmem_cache_destroy(scsi_pkt_cachep);
+}
+
+/**
+ * fc_fcp_init() - Initialize the FCP layer for a local port
+ * @lport: The local port to initialize the exchange layer for
+ */
+int fc_fcp_init(struct fc_lport *lport)
 {
         int rc;
         struct fc_fcp_internal *si;
 
-        if (!lp->tt.fcp_cmd_send)
-                lp->tt.fcp_cmd_send = fc_fcp_cmd_send;
+        if (!lport->tt.fcp_cmd_send)
+                lport->tt.fcp_cmd_send = fc_fcp_cmd_send;
 
-        if (!lp->tt.fcp_cleanup)
-                lp->tt.fcp_cleanup = fc_fcp_cleanup;
+        if (!lport->tt.fcp_cleanup)
+                lport->tt.fcp_cleanup = fc_fcp_cleanup;
 
-        if (!lp->tt.fcp_abort_io)
-                lp->tt.fcp_abort_io = fc_fcp_abort_io;
+        if (!lport->tt.fcp_abort_io)
+                lport->tt.fcp_abort_io = fc_fcp_abort_io;
 
         si = kzalloc(sizeof(struct fc_fcp_internal), GFP_KERNEL);
         if (!si)
                 return -ENOMEM;
-        lp->scsi_priv = si;
+        lport->scsi_priv = si;
+        si->max_can_queue = lport->host->can_queue;
         INIT_LIST_HEAD(&si->scsi_pkt_queue);
+        spin_lock_init(&si->scsi_queue_lock);
 
         si->scsi_pkt_pool = mempool_create_slab_pool(2, scsi_pkt_cachep);
         if (!si->scsi_pkt_pool) {
@@ -2130,42 +2234,3 @@ free_internal:
         return rc;
 }
 EXPORT_SYMBOL(fc_fcp_init);
-
-static int __init libfc_init(void)
-{
-        int rc;
-
-        scsi_pkt_cachep = kmem_cache_create("libfc_fcp_pkt",
-                                            sizeof(struct fc_fcp_pkt),
-                                            0, SLAB_HWCACHE_ALIGN, NULL);
-        if (scsi_pkt_cachep == NULL) {
-                printk(KERN_ERR "libfc: Unable to allocate SRB cache, "
-                       "module load failed!");
-                return -ENOMEM;
-        }
-
-        rc = fc_setup_exch_mgr();
-        if (rc)
-                goto destroy_pkt_cache;
-
-        rc = fc_setup_rport();
-        if (rc)
-                goto destroy_em;
-
-        return rc;
-destroy_em:
-        fc_destroy_exch_mgr();
-destroy_pkt_cache:
-        kmem_cache_destroy(scsi_pkt_cachep);
-        return rc;
-}
-
-static void __exit libfc_exit(void)
-{
-        kmem_cache_destroy(scsi_pkt_cachep);
-        fc_destroy_exch_mgr();
-        fc_destroy_rport();
-}
-
-module_init(libfc_init);
-module_exit(libfc_exit);
diff --git a/drivers/scsi/libfc/fc_frame.c b/drivers/scsi/libfc/fc_frame.c
index 63fe00cfe667..981329a17c48 100644
--- a/drivers/scsi/libfc/fc_frame.c
+++ b/drivers/scsi/libfc/fc_frame.c
@@ -24,6 +24,7 @@
 #include <linux/kernel.h>
 #include <linux/skbuff.h>
 #include <linux/crc32.h>
+#include <linux/gfp.h>
 
 #include <scsi/fc_frame.h>
 
@@ -51,24 +52,24 @@ EXPORT_SYMBOL(fc_frame_crc_check);
  * Allocate a frame intended to be sent via fcoe_xmit.
  * Get an sk_buff for the frame and set the length.
  */
-struct fc_frame *__fc_frame_alloc(size_t len)
+struct fc_frame *_fc_frame_alloc(size_t len)
 {
         struct fc_frame *fp;
         struct sk_buff *skb;
 
         WARN_ON((len % sizeof(u32)) != 0);
         len += sizeof(struct fc_frame_header);
-        skb = dev_alloc_skb(len + FC_FRAME_HEADROOM + FC_FRAME_TAILROOM);
+        skb = alloc_skb_fclone(len + FC_FRAME_HEADROOM + FC_FRAME_TAILROOM +
+                               NET_SKB_PAD, GFP_ATOMIC);
         if (!skb)
                 return NULL;
+        skb_reserve(skb, NET_SKB_PAD + FC_FRAME_HEADROOM);
         fp = (struct fc_frame *) skb;
         fc_frame_init(fp);
-        skb_reserve(skb, FC_FRAME_HEADROOM);
         skb_put(skb, len);
         return fp;
 }
-EXPORT_SYMBOL(__fc_frame_alloc);
-
+EXPORT_SYMBOL(_fc_frame_alloc);
 
 struct fc_frame *fc_frame_alloc_fill(struct fc_lport *lp, size_t payload_len)
 {
@@ -78,7 +79,7 @@ struct fc_frame *fc_frame_alloc_fill(struct fc_lport *lp, size_t payload_len)
         fill = payload_len % 4;
         if (fill != 0)
                 fill = 4 - fill;
-        fp = __fc_frame_alloc(payload_len + fill);
+        fp = _fc_frame_alloc(payload_len + fill);
         if (fp) {
                 memset((char *) fr_hdr(fp) + payload_len, 0, fill);
                 /* trim is OK, we just allocated it so there are no fragments */
@@ -87,3 +88,4 @@ struct fc_frame *fc_frame_alloc_fill(struct fc_lport *lp, size_t payload_len)
         }
         return fp;
 }
+EXPORT_SYMBOL(fc_frame_alloc_fill);
diff --git a/drivers/scsi/libfc/fc_libfc.c b/drivers/scsi/libfc/fc_libfc.c
new file mode 100644
index 000000000000..39f4b6ab04b4
--- /dev/null
+++ b/drivers/scsi/libfc/fc_libfc.c
@@ -0,0 +1,134 @@
+/*
+ * Copyright(c) 2009 Intel Corporation. All rights reserved.
+ *
+ * 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.
+ *
+ * Maintained at www.Open-FCoE.org
+ */
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/scatterlist.h>
+#include <linux/crc32.h>
+
+#include <scsi/libfc.h>
+
+#include "fc_libfc.h"
+
+MODULE_AUTHOR("Open-FCoE.org");
+MODULE_DESCRIPTION("libfc");
+MODULE_LICENSE("GPL v2");
+
+unsigned int fc_debug_logging;
+module_param_named(debug_logging, fc_debug_logging, int, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
+
+/**
+ * libfc_init() - Initialize libfc.ko
+ */
+static int __init libfc_init(void)
+{
+        int rc = 0;
+
+        rc = fc_setup_fcp();
+        if (rc)
+                return rc;
+
+        rc = fc_setup_exch_mgr();
+        if (rc)
+                goto destroy_pkt_cache;
+
+        rc = fc_setup_rport();
+        if (rc)
+                goto destroy_em;
+
+        return rc;
+destroy_em:
+        fc_destroy_exch_mgr();
+destroy_pkt_cache:
+        fc_destroy_fcp();
+        return rc;
+}
+module_init(libfc_init);
+
+/**
+ * libfc_exit() - Tear down libfc.ko
+ */
+static void __exit libfc_exit(void)
+{
+        fc_destroy_fcp();
+        fc_destroy_exch_mgr();
+        fc_destroy_rport();
+}
+module_exit(libfc_exit);
+
+/**
+ * fc_copy_buffer_to_sglist() - This routine copies the data of a buffer
+ *                              into a scatter-gather list (SG list).
+ *
+ * @buf: pointer to the data buffer.
+ * @len: the byte-length of the data buffer.
+ * @sg: pointer to the pointer of the SG list.
+ * @nents: pointer to the remaining number of entries in the SG list.
+ * @offset: pointer to the current offset in the SG list.
+ * @km_type: dedicated page table slot type for kmap_atomic.
+ * @crc: pointer to the 32-bit crc value.
+ *       If crc is NULL, CRC is not calculated.
+ */
+u32 fc_copy_buffer_to_sglist(void *buf, size_t len,
+                             struct scatterlist *sg,
+                             u32 *nents, size_t *offset,
+                             enum km_type km_type, u32 *crc)
+{
+        size_t remaining = len;
+        u32 copy_len = 0;
+
+        while (remaining > 0 && sg) {
+                size_t off, sg_bytes;
+                void *page_addr;
+
+                if (*offset >= sg->length) {
+                        /*
+                         * Check for end and drop resources
+                         * from the last iteration.
+                         */
+                        if (!(*nents))
+                                break;
+                        --(*nents);
+                        *offset -= sg->length;
+                        sg = sg_next(sg);
+                        continue;
+                }
+                sg_bytes = min(remaining, sg->length - *offset);
+
+                /*
+                 * The scatterlist item may be bigger than PAGE_SIZE,
+                 * but we are limited to mapping PAGE_SIZE at a time.
+                 */
+                off = *offset + sg->offset;
+                sg_bytes = min(sg_bytes,
+                               (size_t)(PAGE_SIZE - (off & ~PAGE_MASK)));
+                page_addr = kmap_atomic(sg_page(sg) + (off >> PAGE_SHIFT),
+                                        km_type);
+                if (crc)
+                        *crc = crc32(*crc, buf, sg_bytes);
+                memcpy((char *)page_addr + (off & ~PAGE_MASK), buf, sg_bytes);
+                kunmap_atomic(page_addr, km_type);
+                buf += sg_bytes;
+                *offset += sg_bytes;
+                remaining -= sg_bytes;
+                copy_len += sg_bytes;
+        }
+        return copy_len;
+}
diff --git a/drivers/scsi/libfc/fc_libfc.h b/drivers/scsi/libfc/fc_libfc.h
new file mode 100644
index 000000000000..741fd5c72e13
--- /dev/null
+++ b/drivers/scsi/libfc/fc_libfc.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright(c) 2009 Intel Corporation. All rights reserved.
+ *
+ * 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.
+ *
+ * Maintained at www.Open-FCoE.org
+ */
+
+#ifndef _FC_LIBFC_H_
+#define _FC_LIBFC_H_
+
+#define FC_LIBFC_LOGGING 0x01 /* General logging, not categorized */
+#define FC_LPORT_LOGGING 0x02 /* lport layer logging */
+#define FC_DISC_LOGGING  0x04 /* discovery layer logging */
+#define FC_RPORT_LOGGING 0x08 /* rport layer logging */
+#define FC_FCP_LOGGING   0x10 /* I/O path logging */
+#define FC_EM_LOGGING    0x20 /* Exchange Manager logging */
+#define FC_EXCH_LOGGING  0x40 /* Exchange/Sequence logging */
+#define FC_SCSI_LOGGING  0x80 /* SCSI logging (mostly error handling) */
+
+extern unsigned int fc_debug_logging;
+
+#define FC_CHECK_LOGGING(LEVEL, CMD)                    \
+        do {                                            \
+                if (unlikely(fc_debug_logging & LEVEL)) \
+                        do {                            \
+                                CMD;                    \
+                        } while (0);                    \
+        } while (0)
+
+#define FC_LIBFC_DBG(fmt, args...)                                      \
+        FC_CHECK_LOGGING(FC_LIBFC_LOGGING,                              \
+                         printk(KERN_INFO "libfc: " fmt, ##args))
+
+#define FC_LPORT_DBG(lport, fmt, args...)                               \
+        FC_CHECK_LOGGING(FC_LPORT_LOGGING,                              \
+                         printk(KERN_INFO "host%u: lport %6x: " fmt,    \
+                                (lport)->host->host_no,                 \
+                                fc_host_port_id((lport)->host), ##args))
+
+#define FC_DISC_DBG(disc, fmt, args...)                         \
+        FC_CHECK_LOGGING(FC_DISC_LOGGING,                       \
+                         printk(KERN_INFO "host%u: disc: " fmt, \
+                                (disc)->lport->host->host_no,   \
+                                ##args))
+
+#define FC_RPORT_ID_DBG(lport, port_id, fmt, args...)                   \
+        FC_CHECK_LOGGING(FC_RPORT_LOGGING,                              \
+                         printk(KERN_INFO "host%u: rport %6x: " fmt,    \
+                                (lport)->host->host_no,                 \
+                                (port_id), ##args))
+
+#define FC_RPORT_DBG(rdata, fmt, args...)                               \
+        FC_RPORT_ID_DBG((rdata)->local_port, (rdata)->ids.port_id, fmt, ##args)
+
+#define FC_FCP_DBG(pkt, fmt, args...)                                   \
+        FC_CHECK_LOGGING(FC_FCP_LOGGING,                                \
+                         printk(KERN_INFO "host%u: fcp: %6x: " fmt,     \
+                                (pkt)->lp->host->host_no,               \
+                                pkt->rport->port_id, ##args))
+
+#define FC_EXCH_DBG(exch, fmt, args...)                                 \
+        FC_CHECK_LOGGING(FC_EXCH_LOGGING,                               \
+                         printk(KERN_INFO "host%u: xid %4x: " fmt,      \
+                                (exch)->lp->host->host_no,              \
+                                exch->xid, ##args))
+
+#define FC_SCSI_DBG(lport, fmt, args...)                                \
+        FC_CHECK_LOGGING(FC_SCSI_LOGGING,                               \
+                         printk(KERN_INFO "host%u: scsi: " fmt,         \
+                                (lport)->host->host_no, ##args))
+
+/*
+ * Set up direct-data placement for this I/O request
+ */
+void fc_fcp_ddp_setup(struct fc_fcp_pkt *fsp, u16 xid);
+
+/*
+ * Module setup functions
+ */
+int fc_setup_exch_mgr(void);
+void fc_destroy_exch_mgr(void);
+int fc_setup_rport(void);
+void fc_destroy_rport(void);
+int fc_setup_fcp(void);
+void fc_destroy_fcp(void);
+
+/*
+ * Internal libfc functions
+ */
+const char *fc_els_resp_type(struct fc_frame *);
+
+/*
+ * Copies a buffer into an sg list
+ */
+u32 fc_copy_buffer_to_sglist(void *buf, size_t len,
+                             struct scatterlist *sg,
+                             u32 *nents, size_t *offset,
+                             enum km_type km_type, u32 *crc);
+
+#endif /* _FC_LIBFC_H_ */
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index bd2f77197447..d126ecfff704 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -56,7 +56,7 @@
  * at the same time.
  *
  * When discovery succeeds or fails a callback is made to the lport as
- * notification. Currently, succesful discovery causes the lport to take no
+ * notification. Currently, successful discovery causes the lport to take no
  * action. A failure will cause the lport to reset. There is likely a circular
  * locking problem with this implementation.
  */
@@ -88,12 +88,16 @@
  */
 
 #include <linux/timer.h>
+#include <linux/slab.h>
 #include <asm/unaligned.h>
 
 #include <scsi/fc/fc_gs.h>
 
 #include <scsi/libfc.h>
 #include <scsi/fc_encode.h>
+#include <linux/scatterlist.h>
+
+#include "fc_libfc.h"
 
 /* Fabric IDs to use for point-to-point mode, chosen on whims. */
 #define FC_LOCAL_PTP_FID_LO   0x010101
@@ -106,8 +110,7 @@ static void fc_lport_error(struct fc_lport *, struct fc_frame *);
 static void fc_lport_enter_reset(struct fc_lport *);
 static void fc_lport_enter_flogi(struct fc_lport *);
 static void fc_lport_enter_dns(struct fc_lport *);
-static void fc_lport_enter_rpn_id(struct fc_lport *);
-static void fc_lport_enter_rft_id(struct fc_lport *);
+static void fc_lport_enter_ns(struct fc_lport *, enum fc_lport_state);
 static void fc_lport_enter_scr(struct fc_lport *);
 static void fc_lport_enter_ready(struct fc_lport *);
 static void fc_lport_enter_logo(struct fc_lport *);
@@ -116,14 +119,40 @@ static const char *fc_lport_state_names[] = {
         [LPORT_ST_DISABLED] = "disabled",
         [LPORT_ST_FLOGI] =    "FLOGI",
         [LPORT_ST_DNS] =      "dNS",
-        [LPORT_ST_RPN_ID] =   "RPN_ID",
+        [LPORT_ST_RNN_ID] =   "RNN_ID",
+        [LPORT_ST_RSNN_NN] =  "RSNN_NN",
+        [LPORT_ST_RSPN_ID] =  "RSPN_ID",
         [LPORT_ST_RFT_ID] =   "RFT_ID",
+        [LPORT_ST_RFF_ID] =   "RFF_ID",
         [LPORT_ST_SCR] =      "SCR",
         [LPORT_ST_READY] =    "Ready",
         [LPORT_ST_LOGO] =     "LOGO",
         [LPORT_ST_RESET] =    "reset",
 };
 
+/**
+ * struct fc_bsg_info - FC Passthrough managemet structure
+ * @job:      The passthrough job
+ * @lport:    The local port to pass through a command
+ * @rsp_code: The expected response code
+ * @sg:       job->reply_payload.sg_list
+ * @nents:    job->reply_payload.sg_cnt
+ * @offset:   The offset into the response data
+ */
+struct fc_bsg_info {
+        struct fc_bsg_job *job;
+        struct fc_lport *lport;
+        u16 rsp_code;
+        struct scatterlist *sg;
+        u32 nents;
+        size_t offset;
+};
+
+/**
+ * fc_frame_drop() - Dummy frame handler
+ * @lport: The local port the frame was received on
+ * @fp:    The received frame
+ */
 static int fc_frame_drop(struct fc_lport *lport, struct fc_frame *fp)
 {
         fc_frame_free(fp);
@@ -150,8 +179,8 @@ static void fc_lport_rport_callback(struct fc_lport *lport,
         switch (event) {
         case RPORT_EV_READY:
                 if (lport->state == LPORT_ST_DNS) {
-                        lport->dns_rp = rdata;
-                        fc_lport_enter_rpn_id(lport);
+                        lport->dns_rdata = rdata;
+                        fc_lport_enter_ns(lport, LPORT_ST_RNN_ID);
                 } else {
                         FC_LPORT_DBG(lport, "Received an READY event "
                                      "on port (%6x) for the directory "
@@ -165,7 +194,7 @@ static void fc_lport_rport_callback(struct fc_lport *lport,
         case RPORT_EV_LOGO:
         case RPORT_EV_FAILED:
         case RPORT_EV_STOP:
-                lport->dns_rp = NULL;
+                lport->dns_rdata = NULL;
                 break;
         case RPORT_EV_NONE:
                 break;
@@ -189,8 +218,8 @@ static const char *fc_lport_state(struct fc_lport *lport)
 
 /**
  * fc_lport_ptp_setup() - Create an rport for point-to-point mode
- * @lport: The lport to attach the ptp rport to
- * @fid: The FID of the ptp rport
+ * @lport:       The lport to attach the ptp rport to
+ * @remote_fid:  The FID of the ptp rport
  * @remote_wwpn: The WWPN of the ptp rport
  * @remote_wwnn: The WWNN of the ptp rport
  */
@@ -199,18 +228,22 @@ static void fc_lport_ptp_setup(struct fc_lport *lport,
                                u64 remote_wwnn)
 {
         mutex_lock(&lport->disc.disc_mutex);
-        if (lport->ptp_rp)
-                lport->tt.rport_logoff(lport->ptp_rp);
-        lport->ptp_rp = lport->tt.rport_create(lport, remote_fid);
-        lport->ptp_rp->ids.port_name = remote_wwpn;
-        lport->ptp_rp->ids.node_name = remote_wwnn;
+        if (lport->ptp_rdata)
+                lport->tt.rport_logoff(lport->ptp_rdata);
+        lport->ptp_rdata = lport->tt.rport_create(lport, remote_fid);
+        lport->ptp_rdata->ids.port_name = remote_wwpn;
+        lport->ptp_rdata->ids.node_name = remote_wwnn;
         mutex_unlock(&lport->disc.disc_mutex);
 
-        lport->tt.rport_login(lport->ptp_rp);
+        lport->tt.rport_login(lport->ptp_rdata);
 
         fc_lport_enter_ready(lport);
 }
 
+/**
+ * fc_get_host_port_type() - Return the port type of the given Scsi_Host
+ * @shost: The SCSI host whose port type is to be determined
+ */
 void fc_get_host_port_type(struct Scsi_Host *shost)
 {
         /* TODO - currently just NPORT */
@@ -218,17 +251,33 @@ void fc_get_host_port_type(struct Scsi_Host *shost)
 }
 EXPORT_SYMBOL(fc_get_host_port_type);
 
+/**
+ * fc_get_host_port_state() - Return the port state of the given Scsi_Host
+ * @shost:  The SCSI host whose port state is to be determined
+ */
 void fc_get_host_port_state(struct Scsi_Host *shost)
 {
-        struct fc_lport *lp = shost_priv(shost);
+        struct fc_lport *lport = shost_priv(shost);
 
-        if (lp->link_up)
-                fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
+        mutex_lock(&lport->lp_mutex);
+        if (!lport->link_up)
+                fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
         else
-                fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
+                switch (lport->state) {
+                case LPORT_ST_READY:
+                        fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
+                        break;
+                default:
+                        fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
+                }
+        mutex_unlock(&lport->lp_mutex);
 }
 EXPORT_SYMBOL(fc_get_host_port_state);
 
+/**
+ * fc_get_host_speed() - Return the speed of the given Scsi_Host
+ * @shost: The SCSI host whose port speed is to be determined
+ */
 void fc_get_host_speed(struct Scsi_Host *shost)
 {
         struct fc_lport *lport = shost_priv(shost);
@@ -237,24 +286,28 @@ void fc_get_host_speed(struct Scsi_Host *shost)
 }
 EXPORT_SYMBOL(fc_get_host_speed);
 
+/**
+ * fc_get_host_stats() - Return the Scsi_Host's statistics
+ * @shost: The SCSI host whose statistics are to be returned
+ */
 struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost)
 {
         struct fc_host_statistics *fcoe_stats;
-        struct fc_lport *lp = shost_priv(shost);
+        struct fc_lport *lport = shost_priv(shost);
         struct timespec v0, v1;
         unsigned int cpu;
 
-        fcoe_stats = &lp->host_stats;
+        fcoe_stats = &lport->host_stats;
         memset(fcoe_stats, 0, sizeof(struct fc_host_statistics));
 
         jiffies_to_timespec(jiffies, &v0);
-        jiffies_to_timespec(lp->boot_time, &v1);
+        jiffies_to_timespec(lport->boot_time, &v1);
         fcoe_stats->seconds_since_last_reset = (v0.tv_sec - v1.tv_sec);
 
         for_each_possible_cpu(cpu) {
                 struct fcoe_dev_stats *stats;
 
-                stats = per_cpu_ptr(lp->dev_stats, cpu);
+                stats = per_cpu_ptr(lport->dev_stats, cpu);
 
                 fcoe_stats->tx_frames += stats->TxFrames;
                 fcoe_stats->tx_words += stats->TxWords;
@@ -279,12 +332,15 @@ struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost)
 }
 EXPORT_SYMBOL(fc_get_host_stats);
 
-/*
- * Fill in FLOGI command for request.
+/**
+ * fc_lport_flogi_fill() - Fill in FLOGI command for request
+ * @lport: The local port the FLOGI is for
+ * @flogi: The FLOGI command
+ * @op:    The opcode
  */
-static void
-fc_lport_flogi_fill(struct fc_lport *lport, struct fc_els_flogi *flogi,
-                    unsigned int op)
+static void fc_lport_flogi_fill(struct fc_lport *lport,
+                                struct fc_els_flogi *flogi,
+                                unsigned int op)
 {
         struct fc_els_csp *sp;
         struct fc_els_cssp *cp;
@@ -312,8 +368,10 @@ fc_lport_flogi_fill(struct fc_lport *lport, struct fc_els_flogi *flogi,
         }
 }
 
-/*
- * Add a supported FC-4 type.
+/**
+ * fc_lport_add_fc4_type() - Add a supported FC-4 type to a local port
+ * @lport: The local port to add a new FC-4 type to
+ * @type:  The new FC-4 type
  */
 static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type)
 {
@@ -325,11 +383,11 @@ static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type)
 
 /**
  * fc_lport_recv_rlir_req() - Handle received Registered Link Incident Report.
+ * @sp:    The sequence in the RLIR exchange
+ * @fp:    The RLIR request frame
  * @lport: Fibre Channel local port recieving the RLIR
- * @sp: current sequence in the RLIR exchange
- * @fp: RLIR request frame
  *
- * Locking Note: The lport lock is exected to be held before calling
+ * Locking Note: The lport lock is expected to be held before calling
  * this function.
  */
 static void fc_lport_recv_rlir_req(struct fc_seq *sp, struct fc_frame *fp,
@@ -344,11 +402,11 @@ static void fc_lport_recv_rlir_req(struct fc_seq *sp, struct fc_frame *fp,
 
 /**
  * fc_lport_recv_echo_req() - Handle received ECHO request
- * @lport: Fibre Channel local port recieving the ECHO
- * @sp: current sequence in the ECHO exchange
- * @fp: ECHO request frame
+ * @sp:    The sequence in the ECHO exchange
+ * @fp:    ECHO request frame
+ * @lport: The local port recieving the ECHO
  *
- * Locking Note: The lport lock is exected to be held before calling
+ * Locking Note: The lport lock is expected to be held before calling
  * this function.
  */
 static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
@@ -361,7 +419,7 @@ static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
         void *dp;
         u32 f_ctl;
 
-        FC_LPORT_DBG(lport, "Received RLIR request while in state %s\n",
+        FC_LPORT_DBG(lport, "Received ECHO request while in state %s\n",
                      fc_lport_state(lport));
 
         len = fr_len(in_fp) - sizeof(struct fc_frame_header);
@@ -374,7 +432,7 @@ static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
         if (fp) {
                 dp = fc_frame_payload_get(fp, len);
                 memcpy(dp, pp, len);
-                *((u32 *)dp) = htonl(ELS_LS_ACC << 24);
+                *((__be32 *)dp) = htonl(ELS_LS_ACC << 24);
                 sp = lport->tt.seq_start_next(sp);
                 f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ;
                 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
@@ -385,12 +443,12 @@ static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
 }
 
 /**
- * fc_lport_recv_echo_req() - Handle received Request Node ID data request
- * @lport: Fibre Channel local port recieving the RNID
- * @sp: current sequence in the RNID exchange
- * @fp: RNID request frame
+ * fc_lport_recv_rnid_req() - Handle received Request Node ID data request
+ * @sp:    The sequence in the RNID exchange
+ * @fp:    The RNID request frame
+ * @lport: The local port recieving the RNID
  *
- * Locking Note: The lport lock is exected to be held before calling
+ * Locking Note: The lport lock is expected to be held before calling
  * this function.
  */
 static void fc_lport_recv_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,
@@ -453,9 +511,9 @@ static void fc_lport_recv_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,
 
 /**
  * fc_lport_recv_logo_req() - Handle received fabric LOGO request
- * @lport: Fibre Channel local port recieving the LOGO
- * @sp: current sequence in the LOGO exchange
- * @fp: LOGO request frame
+ * @sp:    The sequence in the LOGO exchange
+ * @fp:    The LOGO request frame
+ * @lport: The local port recieving the LOGO
  *
  * Locking Note: The lport lock is exected to be held before calling
  * this function.
@@ -470,7 +528,7 @@ static void fc_lport_recv_logo_req(struct fc_seq *sp, struct fc_frame *fp,
 
 /**
  * fc_fabric_login() - Start the lport state machine
- * @lport: The lport that should log into the fabric
+ * @lport: The local port that should log into the fabric
  *
  * Locking Note: This function should not be called
  *               with the lport lock held.
@@ -480,7 +538,9 @@ int fc_fabric_login(struct fc_lport *lport)
         int rc = -1;
 
         mutex_lock(&lport->lp_mutex);
-        if (lport->state == LPORT_ST_DISABLED) {
+        if (lport->state == LPORT_ST_DISABLED ||
+            lport->state == LPORT_ST_LOGO) {
+                fc_lport_state_enter(lport, LPORT_ST_RESET);
                 fc_lport_enter_reset(lport);
                 rc = 0;
         }
@@ -491,47 +551,69 @@ int fc_fabric_login(struct fc_lport *lport)
 EXPORT_SYMBOL(fc_fabric_login);
 
 /**
- * fc_linkup() - Handler for transport linkup events
+ * __fc_linkup() - Handler for transport linkup events
  * @lport: The lport whose link is up
+ *
+ * Locking: must be called with the lp_mutex held
  */
-void fc_linkup(struct fc_lport *lport)
+void __fc_linkup(struct fc_lport *lport)
 {
-        printk(KERN_INFO "libfc: Link up on port (%6x)\n",
-               fc_host_port_id(lport->host));
-
-        mutex_lock(&lport->lp_mutex);
         if (!lport->link_up) {
                 lport->link_up = 1;
 
                 if (lport->state == LPORT_ST_RESET)
                         fc_lport_enter_flogi(lport);
         }
+}
+
+/**
+ * fc_linkup() - Handler for transport linkup events
+ * @lport: The local port whose link is up
+ */
+void fc_linkup(struct fc_lport *lport)
+{
+        printk(KERN_INFO "host%d: libfc: Link up on port (%6x)\n",
+               lport->host->host_no, fc_host_port_id(lport->host));
+
+        mutex_lock(&lport->lp_mutex);
+        __fc_linkup(lport);
         mutex_unlock(&lport->lp_mutex);
 }
 EXPORT_SYMBOL(fc_linkup);
 
 /**
- * fc_linkdown() - Handler for transport linkdown events
+ * __fc_linkdown() - Handler for transport linkdown events
  * @lport: The lport whose link is down
+ *
+ * Locking: must be called with the lp_mutex held
  */
-void fc_linkdown(struct fc_lport *lport)
+void __fc_linkdown(struct fc_lport *lport)
 {
-        mutex_lock(&lport->lp_mutex);
-        printk(KERN_INFO "libfc: Link down on port (%6x)\n",
-               fc_host_port_id(lport->host));
-
         if (lport->link_up) {
                 lport->link_up = 0;
                 fc_lport_enter_reset(lport);
                 lport->tt.fcp_cleanup(lport);
         }
+}
+
+/**
+ * fc_linkdown() - Handler for transport linkdown events
+ * @lport: The local port whose link is down
+ */
+void fc_linkdown(struct fc_lport *lport)
+{
+        printk(KERN_INFO "host%d: libfc: Link down on port (%6x)\n",
+               lport->host->host_no, fc_host_port_id(lport->host));
+
+        mutex_lock(&lport->lp_mutex);
+        __fc_linkdown(lport);
         mutex_unlock(&lport->lp_mutex);
 }
 EXPORT_SYMBOL(fc_linkdown);
 
 /**
  * fc_fabric_logoff() - Logout of the fabric
- * @lport:            fc_lport pointer to logoff the fabric
+ * @lport: The local port to logoff the fabric
  *
  * Return value:
  *      0 for success, -1 for failure
@@ -540,8 +622,8 @@ int fc_fabric_logoff(struct fc_lport *lport)
 {
         lport->tt.disc_stop_final(lport);
         mutex_lock(&lport->lp_mutex);
-        if (lport->dns_rp)
-                lport->tt.rport_logoff(lport->dns_rp);
+        if (lport->dns_rdata)
+                lport->tt.rport_logoff(lport->dns_rdata);
         mutex_unlock(&lport->lp_mutex);
         lport->tt.rport_flush_queue();
         mutex_lock(&lport->lp_mutex);
@@ -553,11 +635,9 @@ int fc_fabric_logoff(struct fc_lport *lport)
 EXPORT_SYMBOL(fc_fabric_logoff);
 
 /**
- * fc_lport_destroy() - unregister a fc_lport
- * @lport:            fc_lport pointer to unregister
+ * fc_lport_destroy() - Unregister a fc_lport
+ * @lport: The local port to unregister
  *
- * Return value:
- *      None
  * Note:
  * exit routine for fc_lport instance
  * clean-up all the allocated memory
@@ -580,13 +660,9 @@ int fc_lport_destroy(struct fc_lport *lport)
 EXPORT_SYMBOL(fc_lport_destroy);
 
 /**
- * fc_set_mfs() - sets up the mfs for the corresponding fc_lport
- * @lport: fc_lport pointer to unregister
- * @mfs: the new mfs for fc_lport
- *
- * Set mfs for the given fc_lport to the new mfs.
- *
- * Return: 0 for success
+ * fc_set_mfs() - Set the maximum frame size for a local port
+ * @lport: The local port to set the MFS for
+ * @mfs:   The new MFS
  */
 int fc_set_mfs(struct fc_lport *lport, u32 mfs)
 {
@@ -617,7 +693,7 @@ EXPORT_SYMBOL(fc_set_mfs);
 
 /**
  * fc_lport_disc_callback() - Callback for discovery events
- * @lport: FC local port
+ * @lport: The local port receiving the event
  * @event: The discovery event
  */
 void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
@@ -627,8 +703,9 @@ void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
                 FC_LPORT_DBG(lport, "Discovery succeeded\n");
                 break;
         case DISC_EV_FAILED:
-                printk(KERN_ERR "libfc: Discovery failed for port (%6x)\n",
-                       fc_host_port_id(lport->host));
+                printk(KERN_ERR "host%d: libfc: "
+                       "Discovery failed for port (%6x)\n",
+                       lport->host->host_no, fc_host_port_id(lport->host));
                 mutex_lock(&lport->lp_mutex);
                 fc_lport_enter_reset(lport);
                 mutex_unlock(&lport->lp_mutex);
@@ -641,7 +718,7 @@ void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
 
 /**
  * fc_rport_enter_ready() - Enter the ready state and start discovery
- * @lport: Fibre Channel local port that is ready
+ * @lport: The local port that is ready
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -652,22 +729,46 @@ static void fc_lport_enter_ready(struct fc_lport *lport)
                      fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_READY);
+        if (lport->vport)
+                fc_vport_set_state(lport->vport, FC_VPORT_ACTIVE);
+        fc_vports_linkchange(lport);
 
-        if (!lport->ptp_rp)
+        if (!lport->ptp_rdata)
                 lport->tt.disc_start(fc_lport_disc_callback, lport);
 }
 
 /**
+ * fc_lport_set_port_id() - set the local port Port ID
+ * @lport: The local port which will have its Port ID set.
+ * @port_id: The new port ID.
+ * @fp: The frame containing the incoming request, or NULL.
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this function.
+ */
+static void fc_lport_set_port_id(struct fc_lport *lport, u32 port_id,
+                                 struct fc_frame *fp)
+{
+        if (port_id)
+                printk(KERN_INFO "host%d: Assigned Port ID %6x\n",
+                       lport->host->host_no, port_id);
+
+        fc_host_port_id(lport->host) = port_id;
+        if (lport->tt.lport_set_port_id)
+                lport->tt.lport_set_port_id(lport, port_id, fp);
+}
+
+/**
  * fc_lport_recv_flogi_req() - Receive a FLOGI request
  * @sp_in: The sequence the FLOGI is on
- * @rx_fp: The frame the FLOGI is in
- * @lport: The lport that recieved the request
+ * @rx_fp: The FLOGI frame
+ * @lport: The local port that recieved the request
  *
  * A received FLOGI request indicates a point-to-point connection.
  * Accept it with the common service parameters indicating our N port.
  * Set up to do a PLOGI if we have the higher-number WWPN.
  *
- * Locking Note: The lport lock is exected to be held before calling
+ * Locking Note: The lport lock is expected to be held before calling
  * this function.
  */
 static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
@@ -695,8 +796,9 @@ static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
                 goto out;
         remote_wwpn = get_unaligned_be64(&flp->fl_wwpn);
         if (remote_wwpn == lport->wwpn) {
-                printk(KERN_WARNING "libfc: Received FLOGI from port "
-                       "with same WWPN %llx\n", remote_wwpn);
+                printk(KERN_WARNING "host%d: libfc: Received FLOGI from port "
+                       "with same WWPN %llx\n",
+                       lport->host->host_no, remote_wwpn);
                 goto out;
         }
         FC_LPORT_DBG(lport, "FLOGI from port WWPN %llx\n", remote_wwpn);
@@ -715,7 +817,7 @@ static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
                 remote_fid = FC_LOCAL_PTP_FID_HI;
         }
 
-        fc_host_port_id(lport->host) = local_fid;
+        fc_lport_set_port_id(lport, local_fid, rx_fp);
 
         fp = fc_frame_alloc(lport, sizeof(*flp));
         if (fp) {
@@ -747,9 +849,9 @@ out:
 
 /**
  * fc_lport_recv_req() - The generic lport request handler
- * @lport: The lport that received the request
- * @sp: The sequence the request is on
- * @fp: The frame the request is in
+ * @lport: The local port that received the request
+ * @sp:    The sequence the request is on
+ * @fp:    The request frame
  *
  * This function will see if the lport handles the request or
  * if an rport should handle the request.
@@ -817,8 +919,8 @@ static void fc_lport_recv_req(struct fc_lport *lport, struct fc_seq *sp,
 }
 
 /**
- * fc_lport_reset() - Reset an lport
- * @lport: The lport which should be reset
+ * fc_lport_reset() - Reset a local port
+ * @lport: The local port which should be reset
  *
  * Locking Note: This functions should not be called with the
  *               lport lock held.
@@ -834,29 +936,31 @@ int fc_lport_reset(struct fc_lport *lport)
 EXPORT_SYMBOL(fc_lport_reset);
 
 /**
- * fc_lport_reset_locked() - Reset the local port
- * @lport: Fibre Channel local port to be reset
+ * fc_lport_reset_locked() - Reset the local port w/ the lport lock held
+ * @lport: The local port to be reset
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
  */
 static void fc_lport_reset_locked(struct fc_lport *lport)
 {
-        if (lport->dns_rp)
-                lport->tt.rport_logoff(lport->dns_rp);
+        if (lport->dns_rdata)
+                lport->tt.rport_logoff(lport->dns_rdata);
 
-        lport->ptp_rp = NULL;
+        lport->ptp_rdata = NULL;
 
         lport->tt.disc_stop(lport);
 
         lport->tt.exch_mgr_reset(lport, 0, 0);
         fc_host_fabric_name(lport->host) = 0;
-        fc_host_port_id(lport->host) = 0;
+
+        if (fc_host_port_id(lport->host))
+                fc_lport_set_port_id(lport, 0, NULL);
 }
 
 /**
  * fc_lport_enter_reset() - Reset the local port
- * @lport: Fibre Channel local port to be reset
+ * @lport: The local port to be reset
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -866,15 +970,25 @@ static void fc_lport_enter_reset(struct fc_lport *lport)
         FC_LPORT_DBG(lport, "Entered RESET state from %s state\n",
                      fc_lport_state(lport));
 
+        if (lport->state == LPORT_ST_DISABLED || lport->state == LPORT_ST_LOGO)
+                return;
+
+        if (lport->vport) {
+                if (lport->link_up)
+                        fc_vport_set_state(lport->vport, FC_VPORT_INITIALIZING);
+                else
+                        fc_vport_set_state(lport->vport, FC_VPORT_LINKDOWN);
+        }
         fc_lport_state_enter(lport, LPORT_ST_RESET);
+        fc_vports_linkchange(lport);
         fc_lport_reset_locked(lport);
         if (lport->link_up)
                 fc_lport_enter_flogi(lport);
 }
 
 /**
- * fc_lport_enter_disabled() - disable the local port
- * @lport: Fibre Channel local port to be reset
+ * fc_lport_enter_disabled() - Disable the local port
+ * @lport: The local port to be reset
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -885,13 +999,14 @@ static void fc_lport_enter_disabled(struct fc_lport *lport)
                      fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_DISABLED);
+        fc_vports_linkchange(lport);
         fc_lport_reset_locked(lport);
 }
 
 /**
  * fc_lport_error() - Handler for any errors
- * @lport: The fc_lport object
- * @fp: The frame pointer
+ * @lport: The local port that the error was on
+ * @fp:    The error code encoded in a frame pointer
  *
  * If the error was caused by a resource allocation failure
  * then wait for half a second and retry, otherwise retry
@@ -922,8 +1037,11 @@ static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp)
                         case LPORT_ST_DISABLED:
                         case LPORT_ST_READY:
                         case LPORT_ST_RESET:
-                        case LPORT_ST_RPN_ID:
+                        case LPORT_ST_RNN_ID:
+                        case LPORT_ST_RSNN_NN:
+                        case LPORT_ST_RSPN_ID:
                         case LPORT_ST_RFT_ID:
+                        case LPORT_ST_RFF_ID:
                         case LPORT_ST_SCR:
                         case LPORT_ST_DNS:
                         case LPORT_ST_FLOGI:
@@ -936,33 +1054,33 @@ static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp)
 }
 
 /**
- * fc_lport_rft_id_resp() - Handle response to Register Fibre
- *                          Channel Types by ID (RPN_ID) request
- * @sp: current sequence in RPN_ID exchange
- * @fp: response frame
+ * fc_lport_ns_resp() - Handle response to a name server
+ *                      registration exchange
+ * @sp:     current sequence in exchange
+ * @fp:     response frame
  * @lp_arg: Fibre Channel host port instance
  *
  * Locking Note: This function will be called without the lport lock
- * held, but it will lock, call an _enter_* function or fc_lport_error
+ * held, but it will lock, call an _enter_* function or fc_lport_error()
  * and then unlock the lport.
  */
-static void fc_lport_rft_id_resp(struct fc_seq *sp, struct fc_frame *fp,
-                                 void *lp_arg)
+static void fc_lport_ns_resp(struct fc_seq *sp, struct fc_frame *fp,
+                             void *lp_arg)
 {
         struct fc_lport *lport = lp_arg;
         struct fc_frame_header *fh;
         struct fc_ct_hdr *ct;
 
-        FC_LPORT_DBG(lport, "Received a RFT_ID %s\n", fc_els_resp_type(fp));
+        FC_LPORT_DBG(lport, "Received a ns %s\n", fc_els_resp_type(fp));
 
         if (fp == ERR_PTR(-FC_EX_CLOSED))
                 return;
 
         mutex_lock(&lport->lp_mutex);
 
-        if (lport->state != LPORT_ST_RFT_ID) {
-                FC_LPORT_DBG(lport, "Received a RFT_ID response, but in state "
-                             "%s\n", fc_lport_state(lport));
+        if (lport->state < LPORT_ST_RNN_ID || lport->state > LPORT_ST_RFF_ID) {
+                FC_LPORT_DBG(lport, "Received a name server response, "
+                             "but in state %s\n", fc_lport_state(lport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -980,63 +1098,28 @@ static void fc_lport_rft_id_resp(struct fc_seq *sp, struct fc_frame *fp,
             ct->ct_fs_type == FC_FST_DIR &&
             ct->ct_fs_subtype == FC_NS_SUBTYPE &&
             ntohs(ct->ct_cmd) == FC_FS_ACC)
-                fc_lport_enter_scr(lport);
-        else
-                fc_lport_error(lport, fp);
-out:
-        fc_frame_free(fp);
-err:
-        mutex_unlock(&lport->lp_mutex);
-}
-
-/**
- * fc_lport_rpn_id_resp() - Handle response to Register Port
- *                          Name by ID (RPN_ID) request
- * @sp: current sequence in RPN_ID exchange
- * @fp: response frame
- * @lp_arg: Fibre Channel host port instance
- *
- * Locking Note: This function will be called without the lport lock
- * held, but it will lock, call an _enter_* function or fc_lport_error
- * and then unlock the lport.
- */
-static void fc_lport_rpn_id_resp(struct fc_seq *sp, struct fc_frame *fp,
-                                 void *lp_arg)
-{
-        struct fc_lport *lport = lp_arg;
-        struct fc_frame_header *fh;
-        struct fc_ct_hdr *ct;
-
-        FC_LPORT_DBG(lport, "Received a RPN_ID %s\n", fc_els_resp_type(fp));
-
-        if (fp == ERR_PTR(-FC_EX_CLOSED))
-                return;
-
-        mutex_lock(&lport->lp_mutex);
-
-        if (lport->state != LPORT_ST_RPN_ID) {
-                FC_LPORT_DBG(lport, "Received a RPN_ID response, but in state "
-                             "%s\n", fc_lport_state(lport));
-                if (IS_ERR(fp))
-                        goto err;
-                goto out;
-        }
-
-        if (IS_ERR(fp)) {
-                fc_lport_error(lport, fp);
-                goto err;
-        }
-
-        fh = fc_frame_header_get(fp);
-        ct = fc_frame_payload_get(fp, sizeof(*ct));
-        if (fh && ct && fh->fh_type == FC_TYPE_CT &&
-            ct->ct_fs_type == FC_FST_DIR &&
-            ct->ct_fs_subtype == FC_NS_SUBTYPE &&
-            ntohs(ct->ct_cmd) == FC_FS_ACC)
-                fc_lport_enter_rft_id(lport);
+                switch (lport->state) {
+                case LPORT_ST_RNN_ID:
+                        fc_lport_enter_ns(lport, LPORT_ST_RSNN_NN);
+                        break;
+                case LPORT_ST_RSNN_NN:
+                        fc_lport_enter_ns(lport, LPORT_ST_RSPN_ID);
+                        break;
+                case LPORT_ST_RSPN_ID:
+                        fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
+                        break;
+                case LPORT_ST_RFT_ID:
+                        fc_lport_enter_ns(lport, LPORT_ST_RFF_ID);
+                        break;
+                case LPORT_ST_RFF_ID:
+                        fc_lport_enter_scr(lport);
+                        break;
+                default:
+                        /* should have already been caught by state checks */
+                        break;
+                }
         else
                 fc_lport_error(lport, fp);
-
 out:
         fc_frame_free(fp);
 err:
@@ -1045,8 +1128,8 @@ err:
 
 /**
  * fc_lport_scr_resp() - Handle response to State Change Register (SCR) request
- * @sp: current sequence in SCR exchange
- * @fp: response frame
+ * @sp:     current sequence in SCR exchange
+ * @fp:     response frame
  * @lp_arg: Fibre Channel lport port instance that sent the registration request
  *
  * Locking Note: This function will be called without the lport lock
@@ -1092,8 +1175,8 @@ err:
 }
 
 /**
- * fc_lport_enter_scr() - Send a State Change Register (SCR) request
- * @lport: Fibre Channel local port to register for state changes
+ * fc_lport_enter_scr() - Send a SCR (State Change Register) request
+ * @lport: The local port to register for state changes
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -1114,78 +1197,74 @@ static void fc_lport_enter_scr(struct fc_lport *lport)
         }
 
         if (!lport->tt.elsct_send(lport, FC_FID_FCTRL, fp, ELS_SCR,
-                                  fc_lport_scr_resp, lport, lport->e_d_tov))
-                fc_lport_error(lport, fp);
+                                  fc_lport_scr_resp, lport,
+                                  2 * lport->r_a_tov))
+                fc_lport_error(lport, NULL);
 }
 
 /**
- * fc_lport_enter_rft_id() - Register FC4-types with the name server
+ * fc_lport_enter_ns() - register some object with the name server
  * @lport: Fibre Channel local port to register
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
  */
-static void fc_lport_enter_rft_id(struct fc_lport *lport)
+static void fc_lport_enter_ns(struct fc_lport *lport, enum fc_lport_state state)
 {
         struct fc_frame *fp;
-        struct fc_ns_fts *lps;
-        int i;
+        enum fc_ns_req cmd;
+        int size = sizeof(struct fc_ct_hdr);
+        size_t len;
 
-        FC_LPORT_DBG(lport, "Entered RFT_ID state from %s state\n",
+        FC_LPORT_DBG(lport, "Entered %s state from %s state\n",
+                     fc_lport_state_names[state],
                      fc_lport_state(lport));
 
-        fc_lport_state_enter(lport, LPORT_ST_RFT_ID);
+        fc_lport_state_enter(lport, state);
 
-        lps = &lport->fcts;
-        i = sizeof(lps->ff_type_map) / sizeof(lps->ff_type_map[0]);
-        while (--i >= 0)
-                if (ntohl(lps->ff_type_map[i]) != 0)
-                        break;
-        if (i < 0) {
-                /* nothing to register, move on to SCR */
-                fc_lport_enter_scr(lport);
-                return;
-        }
-
-        fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) +
-                            sizeof(struct fc_ns_rft));
-        if (!fp) {
-                fc_lport_error(lport, fp);
+        switch (state) {
+        case LPORT_ST_RNN_ID:
+                cmd = FC_NS_RNN_ID;
+                size += sizeof(struct fc_ns_rn_id);
+                break;
+        case LPORT_ST_RSNN_NN:
+                len = strnlen(fc_host_symbolic_name(lport->host), 255);
+                /* if there is no symbolic name, skip to RFT_ID */
+                if (!len)
+                        return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
+                cmd = FC_NS_RSNN_NN;
+                size += sizeof(struct fc_ns_rsnn) + len;
+                break;
+        case LPORT_ST_RSPN_ID:
+                len = strnlen(fc_host_symbolic_name(lport->host), 255);
+                /* if there is no symbolic name, skip to RFT_ID */
+                if (!len)
+                        return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
+                cmd = FC_NS_RSPN_ID;
+                size += sizeof(struct fc_ns_rspn) + len;
+                break;
+        case LPORT_ST_RFT_ID:
+                cmd = FC_NS_RFT_ID;
+                size += sizeof(struct fc_ns_rft);
+                break;
+        case LPORT_ST_RFF_ID:
+                cmd = FC_NS_RFF_ID;
+                size += sizeof(struct fc_ns_rff_id);
+                break;
+        default:
+                fc_lport_error(lport, NULL);
                 return;
         }
 
-        if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, FC_NS_RFT_ID,
-                                  fc_lport_rft_id_resp,
-                                  lport, lport->e_d_tov))
-                fc_lport_error(lport, fp);
-}
-
-/**
- * fc_rport_enter_rft_id() - Register port name with the name server
- * @lport: Fibre Channel local port to register
- *
- * Locking Note: The lport lock is expected to be held before calling
- * this routine.
- */
-static void fc_lport_enter_rpn_id(struct fc_lport *lport)
-{
-        struct fc_frame *fp;
-
-        FC_LPORT_DBG(lport, "Entered RPN_ID state from %s state\n",
-                     fc_lport_state(lport));
-
-        fc_lport_state_enter(lport, LPORT_ST_RPN_ID);
-
-        fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) +
-                            sizeof(struct fc_ns_rn_id));
+        fp = fc_frame_alloc(lport, size);
         if (!fp) {
                 fc_lport_error(lport, fp);
                 return;
         }
 
-        if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, FC_NS_RPN_ID,
-                                  fc_lport_rpn_id_resp,
-                                  lport, lport->e_d_tov))
+        if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, cmd,
+                                  fc_lport_ns_resp,
+                                  lport, 3 * lport->r_a_tov))
                 fc_lport_error(lport, fp);
 }
 
@@ -1194,8 +1273,8 @@ static struct fc_rport_operations fc_lport_rport_ops = {
 };
 
 /**
- * fc_rport_enter_dns() - Create a rport to the name server
- * @lport: Fibre Channel local port requesting a rport for the name server
+ * fc_rport_enter_dns() - Create a fc_rport for the name server
+ * @lport: The local port requesting a remote port for the name server
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -1224,8 +1303,8 @@ err:
 }
 
 /**
- * fc_lport_timeout() - Handler for the retry_work timer.
- * @work: The work struct of the fc_lport
+ * fc_lport_timeout() - Handler for the retry_work timer
+ * @work: The work struct of the local port
  */
 static void fc_lport_timeout(struct work_struct *work)
 {
@@ -1237,21 +1316,25 @@ static void fc_lport_timeout(struct work_struct *work)
 
         switch (lport->state) {
         case LPORT_ST_DISABLED:
+                WARN_ON(1);
+                break;
         case LPORT_ST_READY:
-        case LPORT_ST_RESET:
                 WARN_ON(1);
                 break;
+        case LPORT_ST_RESET:
+                break;
         case LPORT_ST_FLOGI:
                 fc_lport_enter_flogi(lport);
                 break;
         case LPORT_ST_DNS:
                 fc_lport_enter_dns(lport);
                 break;
-        case LPORT_ST_RPN_ID:
-                fc_lport_enter_rpn_id(lport);
-                break;
+        case LPORT_ST_RNN_ID:
+        case LPORT_ST_RSNN_NN:
+        case LPORT_ST_RSPN_ID:
         case LPORT_ST_RFT_ID:
-                fc_lport_enter_rft_id(lport);
+        case LPORT_ST_RFF_ID:
+                fc_lport_enter_ns(lport, lport->state);
                 break;
         case LPORT_ST_SCR:
                 fc_lport_enter_scr(lport);
@@ -1266,16 +1349,16 @@ static void fc_lport_timeout(struct work_struct *work)
 
 /**
  * fc_lport_logo_resp() - Handle response to LOGO request
- * @sp: current sequence in LOGO exchange
- * @fp: response frame
- * @lp_arg: Fibre Channel lport port instance that sent the LOGO request
+ * @sp:     The sequence that the LOGO was on
+ * @fp:     The LOGO frame
+ * @lp_arg: The lport port that received the LOGO request
  *
  * Locking Note: This function will be called without the lport lock
- * held, but it will lock, call an _enter_* function or fc_lport_error
+ * held, but it will lock, call an _enter_* function or fc_lport_error()
  * and then unlock the lport.
  */
-static void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
-                               void *lp_arg)
+void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
+                        void *lp_arg)
 {
         struct fc_lport *lport = lp_arg;
         u8 op;
@@ -1311,10 +1394,11 @@ out:
 err:
         mutex_unlock(&lport->lp_mutex);
 }
+EXPORT_SYMBOL(fc_lport_logo_resp);
 
 /**
  * fc_rport_enter_logo() - Logout of the fabric
- * @lport: Fibre Channel local port to be logged out
+ * @lport: The local port to be logged out
  *
  * Locking Note: The lport lock is expected to be held before calling
  * this routine.
@@ -1328,6 +1412,7 @@ static void fc_lport_enter_logo(struct fc_lport *lport)
                      fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_LOGO);
+        fc_vports_linkchange(lport);
 
         fp = fc_frame_alloc(lport, sizeof(*logo));
         if (!fp) {
@@ -1336,22 +1421,23 @@ static void fc_lport_enter_logo(struct fc_lport *lport)
         }
 
         if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp, ELS_LOGO,
-                                  fc_lport_logo_resp, lport, lport->e_d_tov))
-                fc_lport_error(lport, fp);
+                                  fc_lport_logo_resp, lport,
+                                  2 * lport->r_a_tov))
+                fc_lport_error(lport, NULL);
 }
 
 /**
  * fc_lport_flogi_resp() - Handle response to FLOGI request
- * @sp: current sequence in FLOGI exchange
- * @fp: response frame
- * @lp_arg: Fibre Channel lport port instance that sent the FLOGI request
+ * @sp:     The sequence that the FLOGI was on
+ * @fp:     The FLOGI response frame
+ * @lp_arg: The lport port that received the FLOGI response
  *
  * Locking Note: This function will be called without the lport lock
- * held, but it will lock, call an _enter_* function or fc_lport_error
+ * held, but it will lock, call an _enter_* function or fc_lport_error()
  * and then unlock the lport.
  */
-static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
-                                void *lp_arg)
+void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
+                         void *lp_arg)
 {
         struct fc_lport *lport = lp_arg;
         struct fc_frame_header *fh;
@@ -1385,11 +1471,6 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
         fh = fc_frame_header_get(fp);
         did = ntoh24(fh->fh_d_id);
         if (fc_frame_payload_op(fp) == ELS_LS_ACC && did != 0) {
-
-                printk(KERN_INFO "libfc: Assigned FID (%6x) in FLOGI response\n",
-                       did);
-                fc_host_port_id(lport->host) = did;
-
                 flp = fc_frame_payload_get(fp, sizeof(*flp));
                 if (flp) {
                         mfs = ntohs(flp->fl_csp.sp_bb_data) &
@@ -1402,12 +1483,18 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
                         e_d_tov = ntohl(flp->fl_csp.sp_e_d_tov);
                         if (csp_flags & FC_SP_FT_EDTR)
                                 e_d_tov /= 1000000;
+
+                        lport->npiv_enabled = !!(csp_flags & FC_SP_FT_NPIV_ACC);
+
                         if ((csp_flags & FC_SP_FT_FPORT) == 0) {
                                 if (e_d_tov > lport->e_d_tov)
                                         lport->e_d_tov = e_d_tov;
                                 lport->r_a_tov = 2 * e_d_tov;
-                                printk(KERN_INFO "libfc: Port (%6x) entered "
-                                       "point to point mode\n", did);
+                                fc_lport_set_port_id(lport, did, fp);
+                                printk(KERN_INFO "host%d: libfc: "
+                                       "Port (%6x) entered "
+                                       "point-to-point mode\n",
+                                       lport->host->host_no, did);
                                 fc_lport_ptp_setup(lport, ntoh24(fh->fh_s_id),
                                                    get_unaligned_be64(
                                                            &flp->fl_wwpn),
@@ -1418,6 +1505,7 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
                                 lport->r_a_tov = r_a_tov;
                                 fc_host_fabric_name(lport->host) =
                                         get_unaligned_be64(&flp->fl_wwnn);
+                                fc_lport_set_port_id(lport, did, fp);
                                 fc_lport_enter_dns(lport);
                         }
                 }
@@ -1430,6 +1518,7 @@ out:
 err:
         mutex_unlock(&lport->lp_mutex);
 }
+EXPORT_SYMBOL(fc_lport_flogi_resp);
 
 /**
  * fc_rport_enter_flogi() - Send a FLOGI request to the fabric manager
@@ -1451,12 +1540,18 @@ void fc_lport_enter_flogi(struct fc_lport *lport)
         if (!fp)
                 return fc_lport_error(lport, fp);
 
-        if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp, ELS_FLOGI,
-                                  fc_lport_flogi_resp, lport, lport->e_d_tov))
-                fc_lport_error(lport, fp);
+        if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp,
+                                  lport->vport ? ELS_FDISC : ELS_FLOGI,
+                                  fc_lport_flogi_resp, lport,
+                                  lport->vport ? 2 * lport->r_a_tov :
+                                  lport->e_d_tov))
+                fc_lport_error(lport, NULL);
 }
 
-/* Configure a fc_lport */
+/**
+ * fc_lport_config() - Configure a fc_lport
+ * @lport: The local port to be configured
+ */
 int fc_lport_config(struct fc_lport *lport)
 {
         INIT_DELAYED_WORK(&lport->retry_work, fc_lport_timeout);
@@ -1471,6 +1566,10 @@ int fc_lport_config(struct fc_lport *lport)
 }
 EXPORT_SYMBOL(fc_lport_config);
 
+/**
+ * fc_lport_init() - Initialize the lport layer for a local port
+ * @lport: The local port to initialize the exchange layer for
+ */
 int fc_lport_init(struct fc_lport *lport)
 {
         if (!lport->tt.lport_recv)
@@ -1500,7 +1599,254 @@ int fc_lport_init(struct fc_lport *lport)
         if (lport->link_supported_speeds & FC_PORTSPEED_10GBIT)
                 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_10GBIT;
 
-        INIT_LIST_HEAD(&lport->ema_list);
         return 0;
 }
 EXPORT_SYMBOL(fc_lport_init);
+
+/**
+ * fc_lport_bsg_resp() - The common response handler for FC Passthrough requests
+ * @sp:       The sequence for the FC Passthrough response
+ * @fp:       The response frame
+ * @info_arg: The BSG info that the response is for
+ */
+static void fc_lport_bsg_resp(struct fc_seq *sp, struct fc_frame *fp,
+                              void *info_arg)
+{
+        struct fc_bsg_info *info = info_arg;
+        struct fc_bsg_job *job = info->job;
+        struct fc_lport *lport = info->lport;
+        struct fc_frame_header *fh;
+        size_t len;
+        void *buf;
+
+        if (IS_ERR(fp)) {
+                job->reply->result = (PTR_ERR(fp) == -FC_EX_CLOSED) ?
+                        -ECONNABORTED : -ETIMEDOUT;
+                job->reply_len = sizeof(uint32_t);
+                job->state_flags |= FC_RQST_STATE_DONE;
+                job->job_done(job);
+                kfree(info);
+                return;
+        }
+
+        mutex_lock(&lport->lp_mutex);
+        fh = fc_frame_header_get(fp);
+        len = fr_len(fp) - sizeof(*fh);
+        buf = fc_frame_payload_get(fp, 0);
+
+        if (fr_sof(fp) == FC_SOF_I3 && !ntohs(fh->fh_seq_cnt)) {
+                /* Get the response code from the first frame payload */
+                unsigned short cmd = (info->rsp_code == FC_FS_ACC) ?
+                        ntohs(((struct fc_ct_hdr *)buf)->ct_cmd) :
+                        (unsigned short)fc_frame_payload_op(fp);
+
+                /* Save the reply status of the job */
+                job->reply->reply_data.ctels_reply.status =
+                        (cmd == info->rsp_code) ?
+                        FC_CTELS_STATUS_OK : FC_CTELS_STATUS_REJECT;
+        }
+
+        job->reply->reply_payload_rcv_len +=
+                fc_copy_buffer_to_sglist(buf, len, info->sg, &info->nents,
+                                         &info->offset, KM_BIO_SRC_IRQ, NULL);
+
+        if (fr_eof(fp) == FC_EOF_T &&
+            (ntoh24(fh->fh_f_ctl) & (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) ==
+            (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) {
+                if (job->reply->reply_payload_rcv_len >
+                    job->reply_payload.payload_len)
+                        job->reply->reply_payload_rcv_len =
+                                job->reply_payload.payload_len;
+                job->reply->result = 0;
+                job->state_flags |= FC_RQST_STATE_DONE;
+                job->job_done(job);
+                kfree(info);
+        }
+        fc_frame_free(fp);
+        mutex_unlock(&lport->lp_mutex);
+}
+
+/**
+ * fc_lport_els_request() - Send ELS passthrough request
+ * @job:   The BSG Passthrough job
+ * @lport: The local port sending the request
+ * @did:   The destination port id
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this routine.
+ */
+static int fc_lport_els_request(struct fc_bsg_job *job,
+                                struct fc_lport *lport,
+                                u32 did, u32 tov)
+{
+        struct fc_bsg_info *info;
+        struct fc_frame *fp;
+        struct fc_frame_header *fh;
+        char *pp;
+        int len;
+
+        fp = fc_frame_alloc(lport, job->request_payload.payload_len);
+        if (!fp)
+                return -ENOMEM;
+
+        len = job->request_payload.payload_len;
+        pp = fc_frame_payload_get(fp, len);
+
+        sg_copy_to_buffer(job->request_payload.sg_list,
+                          job->request_payload.sg_cnt,
+                          pp, len);
+
+        fh = fc_frame_header_get(fp);
+        fh->fh_r_ctl = FC_RCTL_ELS_REQ;
+        hton24(fh->fh_d_id, did);
+        hton24(fh->fh_s_id, fc_host_port_id(lport->host));
+        fh->fh_type = FC_TYPE_ELS;
+        hton24(fh->fh_f_ctl, FC_FC_FIRST_SEQ |
+               FC_FC_END_SEQ | FC_FC_SEQ_INIT);
+        fh->fh_cs_ctl = 0;
+        fh->fh_df_ctl = 0;
+        fh->fh_parm_offset = 0;
+
+        info = kzalloc(sizeof(struct fc_bsg_info), GFP_KERNEL);
+        if (!info) {
+                fc_frame_free(fp);
+                return -ENOMEM;
+        }
+
+        info->job = job;
+        info->lport = lport;
+        info->rsp_code = ELS_LS_ACC;
+        info->nents = job->reply_payload.sg_cnt;
+        info->sg = job->reply_payload.sg_list;
+
+        if (!lport->tt.exch_seq_send(lport, fp, fc_lport_bsg_resp,
+                                     NULL, info, tov))
+                return -ECOMM;
+        return 0;
+}
+
+/**
+ * fc_lport_ct_request() - Send CT Passthrough request
+ * @job:   The BSG Passthrough job
+ * @lport: The local port sending the request
+ * @did:   The destination FC-ID
+ * @tov:   The timeout period to wait for the response
+ *
+ * Locking Note: The lport lock is expected to be held before calling
+ * this routine.
+ */
+static int fc_lport_ct_request(struct fc_bsg_job *job,
+                               struct fc_lport *lport, u32 did, u32 tov)
+{
+        struct fc_bsg_info *info;
+        struct fc_frame *fp;
+        struct fc_frame_header *fh;
+        struct fc_ct_req *ct;
+        size_t len;
+
+        fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) +
+                            job->request_payload.payload_len);
+        if (!fp)
+                return -ENOMEM;
+
+        len = job->request_payload.payload_len;
+        ct = fc_frame_payload_get(fp, len);
+
+        sg_copy_to_buffer(job->request_payload.sg_list,
+                          job->request_payload.sg_cnt,
+                          ct, len);
+
+        fh = fc_frame_header_get(fp);
+        fh->fh_r_ctl = FC_RCTL_DD_UNSOL_CTL;
+        hton24(fh->fh_d_id, did);
+        hton24(fh->fh_s_id, fc_host_port_id(lport->host));
+        fh->fh_type = FC_TYPE_CT;
+        hton24(fh->fh_f_ctl, FC_FC_FIRST_SEQ |
+               FC_FC_END_SEQ | FC_FC_SEQ_INIT);
+        fh->fh_cs_ctl = 0;
+        fh->fh_df_ctl = 0;
+        fh->fh_parm_offset = 0;
+
+        info = kzalloc(sizeof(struct fc_bsg_info), GFP_KERNEL);
+        if (!info) {
+                fc_frame_free(fp);
+                return -ENOMEM;
+        }
+
+        info->job = job;
+        info->lport = lport;
+        info->rsp_code = FC_FS_ACC;
+        info->nents = job->reply_payload.sg_cnt;
+        info->sg = job->reply_payload.sg_list;
+
+        if (!lport->tt.exch_seq_send(lport, fp, fc_lport_bsg_resp,
+                                     NULL, info, tov))
+                return -ECOMM;
+        return 0;
+}
+
+/**
+ * fc_lport_bsg_request() - The common entry point for sending
+ *                          FC Passthrough requests
+ * @job: The BSG passthrough job
+ */
+int fc_lport_bsg_request(struct fc_bsg_job *job)
+{
+        struct request *rsp = job->req->next_rq;
+        struct Scsi_Host *shost = job->shost;
+        struct fc_lport *lport = shost_priv(shost);
+        struct fc_rport *rport;
+        struct fc_rport_priv *rdata;
+        int rc = -EINVAL;
+        u32 did;
+
+        job->reply->reply_payload_rcv_len = 0;
+        if (rsp)
+                rsp->resid_len = job->reply_payload.payload_len;
+
+        mutex_lock(&lport->lp_mutex);
+
+        switch (job->request->msgcode) {
+        case FC_BSG_RPT_ELS:
+                rport = job->rport;
+                if (!rport)
+                        break;
+
+                rdata = rport->dd_data;
+                rc = fc_lport_els_request(job, lport, rport->port_id,
+                                          rdata->e_d_tov);
+                break;
+
+        case FC_BSG_RPT_CT:
+                rport = job->rport;
+                if (!rport)
+                        break;
+
+                rdata = rport->dd_data;
+                rc = fc_lport_ct_request(job, lport, rport->port_id,
+                                         rdata->e_d_tov);
+                break;
+
+        case FC_BSG_HST_CT:
+                did = ntoh24(job->request->rqst_data.h_ct.port_id);
+                if (did == FC_FID_DIR_SERV)
+                        rdata = lport->dns_rdata;
+                else
+                        rdata = lport->tt.rport_lookup(lport, did);
+
+                if (!rdata)
+                        break;
+
+                rc = fc_lport_ct_request(job, lport, did, rdata->e_d_tov);
+                break;
+
+        case FC_BSG_HST_ELS_NOLOGIN:
+                did = ntoh24(job->request->rqst_data.h_els.port_id);
+                rc = fc_lport_els_request(job, lport, did, lport->e_d_tov);
+                break;
+        }
+
+        mutex_unlock(&lport->lp_mutex);
+        return rc;
+}
+EXPORT_SYMBOL(fc_lport_bsg_request);
diff --git a/drivers/scsi/libfc/fc_npiv.c b/drivers/scsi/libfc/fc_npiv.c
new file mode 100644
index 000000000000..c68f6c7341c2
--- /dev/null
+++ b/drivers/scsi/libfc/fc_npiv.c
@@ -0,0 +1,161 @@
+/*
+ * Copyright(c) 2009 Intel Corporation. All rights reserved.
+ *
+ * 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.
+ *
+ * Maintained at www.Open-FCoE.org
+ */
+
+/*
+ * NPIV VN_Port helper functions for libfc
+ */
+
+#include <scsi/libfc.h>
+
+/**
+ * fc_vport_create() - Create a new NPIV vport instance
+ * @vport: fc_vport structure from scsi_transport_fc
+ * @privsize: driver private data size to allocate along with the Scsi_Host
+ */
+
+struct fc_lport *libfc_vport_create(struct fc_vport *vport, int privsize)
+{
+        struct Scsi_Host *shost = vport_to_shost(vport);
+        struct fc_lport *n_port = shost_priv(shost);
+        struct fc_lport *vn_port;
+
+        vn_port = libfc_host_alloc(shost->hostt, privsize);
+        if (!vn_port)
+                goto err_out;
+        if (fc_exch_mgr_list_clone(n_port, vn_port))
+                goto err_put;
+
+        vn_port->vport = vport;
+        vport->dd_data = vn_port;
+
+        mutex_lock(&n_port->lp_mutex);
+        list_add_tail(&vn_port->list, &n_port->vports);
+        mutex_unlock(&n_port->lp_mutex);
+
+        return vn_port;
+
+err_put:
+        scsi_host_put(vn_port->host);
+err_out:
+        return NULL;
+}
+EXPORT_SYMBOL(libfc_vport_create);
+
+/**
+ * fc_vport_id_lookup() - find NPIV lport that matches a given fabric ID
+ * @n_port: Top level N_Port which may have multiple NPIV VN_Ports
+ * @port_id: Fabric ID to find a match for
+ *
+ * Returns: matching lport pointer or NULL if there is no match
+ */
+struct fc_lport *fc_vport_id_lookup(struct fc_lport *n_port, u32 port_id)
+{
+        struct fc_lport *lport = NULL;
+        struct fc_lport *vn_port;
+
+        if (fc_host_port_id(n_port->host) == port_id)
+                return n_port;
+
+        mutex_lock(&n_port->lp_mutex);
+        list_for_each_entry(vn_port, &n_port->vports, list) {
+                if (fc_host_port_id(vn_port->host) == port_id) {
+                        lport = vn_port;
+                        break;
+                }
+        }
+        mutex_unlock(&n_port->lp_mutex);
+
+        return lport;
+}
+
+/*
+ * When setting the link state of vports during an lport state change, it's
+ * necessary to hold the lp_mutex of both the N_Port and the VN_Port.
+ * This tells the lockdep engine to treat the nested locking of the VN_Port
+ * as a different lock class.
+ */
+enum libfc_lport_mutex_class {
+        LPORT_MUTEX_NORMAL = 0,
+        LPORT_MUTEX_VN_PORT = 1,
+};
+
+/**
+ * __fc_vport_setlink() - update link and status on a VN_Port
+ * @n_port: parent N_Port
+ * @vn_port: VN_Port to update
+ *
+ * Locking: must be called with both the N_Port and VN_Port lp_mutex held
+ */
+static void __fc_vport_setlink(struct fc_lport *n_port,
+                               struct fc_lport *vn_port)
+{
+        struct fc_vport *vport = vn_port->vport;
+
+        if (vn_port->state == LPORT_ST_DISABLED)
+                return;
+
+        if (n_port->state == LPORT_ST_READY) {
+                if (n_port->npiv_enabled) {
+                        fc_vport_set_state(vport, FC_VPORT_INITIALIZING);
+                        __fc_linkup(vn_port);
+                } else {
+                        fc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
+                        __fc_linkdown(vn_port);
+                }
+        } else {
+                fc_vport_set_state(vport, FC_VPORT_LINKDOWN);
+                __fc_linkdown(vn_port);
+        }
+}
+
+/**
+ * fc_vport_setlink() - update link and status on a VN_Port
+ * @vn_port: virtual port to update
+ */
+void fc_vport_setlink(struct fc_lport *vn_port)
+{
+        struct fc_vport *vport = vn_port->vport;
+        struct Scsi_Host *shost = vport_to_shost(vport);
+        struct fc_lport *n_port = shost_priv(shost);
+
+        mutex_lock(&n_port->lp_mutex);
+        mutex_lock_nested(&vn_port->lp_mutex, LPORT_MUTEX_VN_PORT);
+        __fc_vport_setlink(n_port, vn_port);
+        mutex_unlock(&vn_port->lp_mutex);
+        mutex_unlock(&n_port->lp_mutex);
+}
+EXPORT_SYMBOL(fc_vport_setlink);
+
+/**
+ * fc_vports_linkchange() - change the link state of all vports
+ * @n_port: Parent N_Port that has changed state
+ *
+ * Locking: called with the n_port lp_mutex held
+ */
+void fc_vports_linkchange(struct fc_lport *n_port)
+{
+        struct fc_lport *vn_port;
+
+        list_for_each_entry(vn_port, &n_port->vports, list) {
+                mutex_lock_nested(&vn_port->lp_mutex, LPORT_MUTEX_VN_PORT);
+                __fc_vport_setlink(n_port, vn_port);
+                mutex_unlock(&vn_port->lp_mutex);
+        }
+}
+
diff --git a/drivers/scsi/libfc/fc_rport.c b/drivers/scsi/libfc/fc_rport.c
index 03ea6748e7ee..b37d0ff28b35 100644
--- a/drivers/scsi/libfc/fc_rport.c
+++ b/drivers/scsi/libfc/fc_rport.c
@@ -47,6 +47,7 @@
 #include <linux/kernel.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 #include <linux/rcupdate.h>
 #include <linux/timer.h>
 #include <linux/workqueue.h>
@@ -55,6 +56,8 @@
 #include <scsi/libfc.h>
 #include <scsi/fc_encode.h>
 
+#include "fc_libfc.h"
+
 struct workqueue_struct *rport_event_queue;
 
 static void fc_rport_enter_plogi(struct fc_rport_priv *);
@@ -86,12 +89,13 @@ static const char *fc_rport_state_names[] = {
         [RPORT_ST_LOGO] = "LOGO",
         [RPORT_ST_ADISC] = "ADISC",
         [RPORT_ST_DELETE] = "Delete",
+        [RPORT_ST_RESTART] = "Restart",
 };
 
 /**
- * fc_rport_lookup() - lookup a remote port by port_id
- * @lport: Fibre Channel host port instance
- * @port_id: remote port port_id to match
+ * fc_rport_lookup() - Lookup a remote port by port_id
+ * @lport:   The local port to lookup the remote port on
+ * @port_id: The remote port ID to look up
  */
 static struct fc_rport_priv *fc_rport_lookup(const struct fc_lport *lport,
                                              u32 port_id)
@@ -99,16 +103,17 @@ static struct fc_rport_priv *fc_rport_lookup(const struct fc_lport *lport,
         struct fc_rport_priv *rdata;
 
         list_for_each_entry(rdata, &lport->disc.rports, peers)
-                if (rdata->ids.port_id == port_id &&
-                    rdata->rp_state != RPORT_ST_DELETE)
+                if (rdata->ids.port_id == port_id)
                         return rdata;
         return NULL;
 }
 
 /**
  * fc_rport_create() - Create a new remote port
- * @lport:   The local port that the new remote port is for
- * @port_id: The port ID for the new remote port
+ * @lport: The local port this remote port will be associated with
+ * @ids:   The identifiers for the new remote port
+ *
+ * The remote port will start in the INIT state.
  *
  * Locking note:  must be called with the disc_mutex held.
  */
@@ -147,8 +152,8 @@ static struct fc_rport_priv *fc_rport_create(struct fc_lport *lport,
 }
 
 /**
- * fc_rport_destroy() - free a remote port after last reference is released.
- * @kref: pointer to kref inside struct fc_rport_priv
+ * fc_rport_destroy() - Free a remote port after last reference is released
+ * @kref: The remote port's kref
  */
 static void fc_rport_destroy(struct kref *kref)
 {
@@ -159,8 +164,8 @@ static void fc_rport_destroy(struct kref *kref)
 }
 
 /**
- * fc_rport_state() - return a string for the state the rport is in
- * @rdata: remote port private data
+ * fc_rport_state() - Return a string identifying the remote port's state
+ * @rdata: The remote port
  */
 static const char *fc_rport_state(struct fc_rport_priv *rdata)
 {
@@ -173,9 +178,9 @@ static const char *fc_rport_state(struct fc_rport_priv *rdata)
 }
 
 /**
- * fc_set_rport_loss_tmo() - Set the remote port loss timeout in seconds.
- * @rport: Pointer to Fibre Channel remote port structure
- * @timeout: timeout in seconds
+ * fc_set_rport_loss_tmo() - Set the remote port loss timeout
+ * @rport:   The remote port that gets a new timeout value
+ * @timeout: The new timeout value (in seconds)
  */
 void fc_set_rport_loss_tmo(struct fc_rport *rport, u32 timeout)
 {
@@ -187,9 +192,11 @@ void fc_set_rport_loss_tmo(struct fc_rport *rport, u32 timeout)
 EXPORT_SYMBOL(fc_set_rport_loss_tmo);
 
 /**
- * fc_plogi_get_maxframe() - Get max payload from the common service parameters
- * @flp: FLOGI payload structure
- * @maxval: upper limit, may be less than what is in the service parameters
+ * fc_plogi_get_maxframe() - Get the maximum payload from the common service
+ *                           parameters in a FLOGI frame
+ * @flp:    The FLOGI payload
+ * @maxval: The maximum frame size upper limit; this may be less than what
+ *          is in the service parameters
  */
 static unsigned int fc_plogi_get_maxframe(struct fc_els_flogi *flp,
                                           unsigned int maxval)
@@ -210,9 +217,9 @@ static unsigned int fc_plogi_get_maxframe(struct fc_els_flogi *flp,
 }
 
 /**
- * fc_rport_state_enter() - Change the rport's state
- * @rdata: The rport whose state should change
- * @new: The new state of the rport
+ * fc_rport_state_enter() - Change the state of a remote port
+ * @rdata: The remote port whose state should change
+ * @new:   The new state
  *
  * Locking Note: Called with the rport lock held
  */
@@ -224,17 +231,22 @@ static void fc_rport_state_enter(struct fc_rport_priv *rdata,
         rdata->rp_state = new;
 }
 
+/**
+ * fc_rport_work() - Handler for remote port events in the rport_event_queue
+ * @work: Handle to the remote port being dequeued
+ */
 static void fc_rport_work(struct work_struct *work)
 {
         u32 port_id;
         struct fc_rport_priv *rdata =
                 container_of(work, struct fc_rport_priv, event_work);
-        struct fc_rport_libfc_priv *rp;
+        struct fc_rport_libfc_priv *rpriv;
         enum fc_rport_event event;
         struct fc_lport *lport = rdata->local_port;
         struct fc_rport_operations *rport_ops;
         struct fc_rport_identifiers ids;
         struct fc_rport *rport;
+        int restart = 0;
 
         mutex_lock(&rdata->rp_mutex);
         event = rdata->event;
@@ -265,12 +277,12 @@ static void fc_rport_work(struct work_struct *work)
                 rport->maxframe_size = rdata->maxframe_size;
                 rport->supported_classes = rdata->supported_classes;
 
-                rp = rport->dd_data;
-                rp->local_port = lport;
-                rp->rp_state = rdata->rp_state;
-                rp->flags = rdata->flags;
-                rp->e_d_tov = rdata->e_d_tov;
-                rp->r_a_tov = rdata->r_a_tov;
+                rpriv = rport->dd_data;
+                rpriv->local_port = lport;
+                rpriv->rp_state = rdata->rp_state;
+                rpriv->flags = rdata->flags;
+                rpriv->e_d_tov = rdata->e_d_tov;
+                rpriv->r_a_tov = rdata->r_a_tov;
                 mutex_unlock(&rdata->rp_mutex);
 
                 if (rport_ops && rport_ops->event_callback) {
@@ -287,8 +299,20 @@ static void fc_rport_work(struct work_struct *work)
                 mutex_unlock(&rdata->rp_mutex);
 
                 if (port_id != FC_FID_DIR_SERV) {
+                        /*
+                         * We must drop rp_mutex before taking disc_mutex.
+                         * Re-evaluate state to allow for restart.
+                         * A transition to RESTART state must only happen
+                         * while disc_mutex is held and rdata is on the list.
+                         */
                         mutex_lock(&lport->disc.disc_mutex);
-                        list_del(&rdata->peers);
+                        mutex_lock(&rdata->rp_mutex);
+                        if (rdata->rp_state == RPORT_ST_RESTART)
+                                restart = 1;
+                        else
+                                list_del(&rdata->peers);
+                        rdata->event = RPORT_EV_NONE;
+                        mutex_unlock(&rdata->rp_mutex);
                         mutex_unlock(&lport->disc.disc_mutex);
                 }
 
@@ -305,14 +329,20 @@ static void fc_rport_work(struct work_struct *work)
                 lport->tt.exch_mgr_reset(lport, port_id, 0);
 
                 if (rport) {
-                        rp = rport->dd_data;
-                        rp->rp_state = RPORT_ST_DELETE;
+                        rpriv = rport->dd_data;
+                        rpriv->rp_state = RPORT_ST_DELETE;
                         mutex_lock(&rdata->rp_mutex);
                         rdata->rport = NULL;
                         mutex_unlock(&rdata->rp_mutex);
                         fc_remote_port_delete(rport);
                 }
-                kref_put(&rdata->kref, lport->tt.rport_destroy);
+                if (restart) {
+                        mutex_lock(&rdata->rp_mutex);
+                        FC_RPORT_DBG(rdata, "work restart\n");
+                        fc_rport_enter_plogi(rdata);
+                        mutex_unlock(&rdata->rp_mutex);
+                } else
+                        kref_put(&rdata->kref, lport->tt.rport_destroy);
                 break;
 
         default:
@@ -323,7 +353,7 @@ static void fc_rport_work(struct work_struct *work)
 
 /**
  * fc_rport_login() - Start the remote port login state machine
- * @rdata: private remote port
+ * @rdata: The remote port to be logged in to
  *
  * Locking Note: Called without the rport lock held. This
  * function will hold the rport lock, call an _enter_*
@@ -342,6 +372,12 @@ int fc_rport_login(struct fc_rport_priv *rdata)
                 FC_RPORT_DBG(rdata, "ADISC port\n");
                 fc_rport_enter_adisc(rdata);
                 break;
+        case RPORT_ST_RESTART:
+                break;
+        case RPORT_ST_DELETE:
+                FC_RPORT_DBG(rdata, "Restart deleted port\n");
+                fc_rport_state_enter(rdata, RPORT_ST_RESTART);
+                break;
         default:
                 FC_RPORT_DBG(rdata, "Login to port\n");
                 fc_rport_enter_plogi(rdata);
@@ -353,9 +389,9 @@ int fc_rport_login(struct fc_rport_priv *rdata)
 }
 
 /**
- * fc_rport_enter_delete() - schedule a remote port to be deleted.
- * @rdata: private remote port
- * @event: event to report as the reason for deletion
+ * fc_rport_enter_delete() - Schedule a remote port to be deleted
+ * @rdata: The remote port to be deleted
+ * @event: The event to report as the reason for deletion
  *
  * Locking Note: Called with the rport lock held.
  *
@@ -382,8 +418,8 @@ static void fc_rport_enter_delete(struct fc_rport_priv *rdata,
 }
 
 /**
- * fc_rport_logoff() - Logoff and remove an rport
- * @rdata: private remote port
+ * fc_rport_logoff() - Logoff and remove a remote port
+ * @rdata: The remote port to be logged off of
  *
  * Locking Note: Called without the rport lock held. This
  * function will hold the rport lock, call an _enter_*
@@ -397,26 +433,27 @@ int fc_rport_logoff(struct fc_rport_priv *rdata)
 
         if (rdata->rp_state == RPORT_ST_DELETE) {
                 FC_RPORT_DBG(rdata, "Port in Delete state, not removing\n");
-                mutex_unlock(&rdata->rp_mutex);
                 goto out;
         }
 
-        fc_rport_enter_logo(rdata);
+        if (rdata->rp_state == RPORT_ST_RESTART)
+                FC_RPORT_DBG(rdata, "Port in Restart state, deleting\n");
+        else
+                fc_rport_enter_logo(rdata);
 
         /*
          * Change the state to Delete so that we discard
          * the response.
          */
         fc_rport_enter_delete(rdata, RPORT_EV_STOP);
-        mutex_unlock(&rdata->rp_mutex);
-
 out:
+        mutex_unlock(&rdata->rp_mutex);
         return 0;
 }
 
 /**
- * fc_rport_enter_ready() - The rport is ready
- * @rdata: private remote port
+ * fc_rport_enter_ready() - Transition to the RPORT_ST_READY state
+ * @rdata: The remote port that is ready
  *
  * Locking Note: The rport lock is expected to be held before calling
  * this routine.
@@ -433,8 +470,8 @@ static void fc_rport_enter_ready(struct fc_rport_priv *rdata)
 }
 
 /**
- * fc_rport_timeout() - Handler for the retry_work timer.
- * @work: The work struct of the fc_rport_priv
+ * fc_rport_timeout() - Handler for the retry_work timer
+ * @work: Handle to the remote port that has timed out
  *
  * Locking Note: Called without the rport lock held. This
  * function will hold the rport lock, call an _enter_*
@@ -466,6 +503,7 @@ static void fc_rport_timeout(struct work_struct *work)
         case RPORT_ST_READY:
         case RPORT_ST_INIT:
         case RPORT_ST_DELETE:
+        case RPORT_ST_RESTART:
                 break;
         }
 
@@ -474,8 +512,8 @@ static void fc_rport_timeout(struct work_struct *work)
 
 /**
  * fc_rport_error() - Error handler, called once retries have been exhausted
- * @rdata: private remote port
- * @fp: The frame pointer
+ * @rdata: The remote port the error is happened on
+ * @fp:    The error code encapsulated in a frame pointer
  *
  * Locking Note: The rport lock is expected to be held before
  * calling this routine
@@ -499,6 +537,7 @@ static void fc_rport_error(struct fc_rport_priv *rdata, struct fc_frame *fp)
                 fc_rport_enter_logo(rdata);
                 break;
         case RPORT_ST_DELETE:
+        case RPORT_ST_RESTART:
         case RPORT_ST_READY:
         case RPORT_ST_INIT:
                 break;
@@ -506,9 +545,9 @@ static void fc_rport_error(struct fc_rport_priv *rdata, struct fc_frame *fp)
 }
 
 /**
- * fc_rport_error_retry() - Error handler when retries are desired
- * @rdata: private remote port data
- * @fp: The frame pointer
+ * fc_rport_error_retry() - Handler for remote port state retries
+ * @rdata: The remote port whose state is to be retried
+ * @fp:    The error code encapsulated in a frame pointer
  *
  * If the error was an exchange timeout retry immediately,
  * otherwise wait for E_D_TOV.
@@ -540,10 +579,10 @@ static void fc_rport_error_retry(struct fc_rport_priv *rdata,
 }
 
 /**
- * fc_rport_plogi_recv_resp() - Handle incoming ELS PLOGI response
- * @sp: current sequence in the PLOGI exchange
- * @fp: response frame
- * @rdata_arg: private remote port data
+ * fc_rport_plogi_recv_resp() - Handler for ELS PLOGI responses
+ * @sp:        The sequence the PLOGI is on
+ * @fp:        The PLOGI response frame
+ * @rdata_arg: The remote port that sent the PLOGI response
  *
  * Locking Note: This function will be called without the rport lock
  * held, but it will lock, call an _enter_* function or fc_rport_error
@@ -585,7 +624,7 @@ static void fc_rport_plogi_resp(struct fc_seq *sp, struct fc_frame *fp,
 
                 tov = ntohl(plp->fl_csp.sp_e_d_tov);
                 if (ntohs(plp->fl_csp.sp_features) & FC_SP_FT_EDTR)
-                        tov /= 1000;
+                        tov /= 1000000;
                 if (tov > rdata->e_d_tov)
                         rdata->e_d_tov = tov;
                 csp_seq = ntohs(plp->fl_csp.sp_tot_seq);
@@ -606,8 +645,8 @@ err:
 }
 
 /**
- * fc_rport_enter_plogi() - Send Port Login (PLOGI) request to peer
- * @rdata: private remote port data
+ * fc_rport_enter_plogi() - Send Port Login (PLOGI) request
+ * @rdata: The remote port to send a PLOGI to
  *
  * Locking Note: The rport lock is expected to be held before calling
  * this routine.
@@ -631,17 +670,18 @@ static void fc_rport_enter_plogi(struct fc_rport_priv *rdata)
         rdata->e_d_tov = lport->e_d_tov;
 
         if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_PLOGI,
-                                  fc_rport_plogi_resp, rdata, lport->e_d_tov))
-                fc_rport_error_retry(rdata, fp);
+                                  fc_rport_plogi_resp, rdata,
+                                  2 * lport->r_a_tov))
+                fc_rport_error_retry(rdata, NULL);
         else
                 kref_get(&rdata->kref);
 }
 
 /**
  * fc_rport_prli_resp() - Process Login (PRLI) response handler
- * @sp: current sequence in the PRLI exchange
- * @fp: response frame
- * @rdata_arg: private remote port data
+ * @sp:        The sequence the PRLI response was on
+ * @fp:        The PRLI response frame
+ * @rdata_arg: The remote port that sent the PRLI response
  *
  * Locking Note: This function will be called without the rport lock
  * held, but it will lock, call an _enter_* function or fc_rport_error
@@ -710,10 +750,10 @@ err:
 }
 
 /**
- * fc_rport_logo_resp() - Logout (LOGO) response handler
- * @sp: current sequence in the LOGO exchange
- * @fp: response frame
- * @rdata_arg: private remote port data
+ * fc_rport_logo_resp() - Handler for logout (LOGO) responses
+ * @sp:        The sequence the LOGO was on
+ * @fp:        The LOGO response frame
+ * @rdata_arg: The remote port that sent the LOGO response
  *
  * Locking Note: This function will be called without the rport lock
  * held, but it will lock, call an _enter_* function or fc_rport_error
@@ -756,8 +796,8 @@ err:
 }
 
 /**
- * fc_rport_enter_prli() - Send Process Login (PRLI) request to peer
- * @rdata: private remote port data
+ * fc_rport_enter_prli() - Send Process Login (PRLI) request
+ * @rdata: The remote port to send the PRLI request to
  *
  * Locking Note: The rport lock is expected to be held before calling
  * this routine.
@@ -792,17 +832,18 @@ static void fc_rport_enter_prli(struct fc_rport_priv *rdata)
         }
 
         if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_PRLI,
-                                  fc_rport_prli_resp, rdata, lport->e_d_tov))
-                fc_rport_error_retry(rdata, fp);
+                                  fc_rport_prli_resp, rdata,
+                                  2 * lport->r_a_tov))
+                fc_rport_error_retry(rdata, NULL);
         else
                 kref_get(&rdata->kref);
 }
 
 /**
- * fc_rport_els_rtv_resp() - Request Timeout Value response handler
- * @sp: current sequence in the RTV exchange
- * @fp: response frame
- * @rdata_arg: private remote port data
+ * fc_rport_els_rtv_resp() - Handler for Request Timeout Value (RTV) responses
+ * @sp:        The sequence the RTV was on
+ * @fp:        The RTV response frame
+ * @rdata_arg: The remote port that sent the RTV response
  *
  * Many targets don't seem to support this.
  *
@@ -865,8 +906,8 @@ err:
 }
 
 /**
- * fc_rport_enter_rtv() - Send Request Timeout Value (RTV) request to peer
- * @rdata: private remote port data
+ * fc_rport_enter_rtv() - Send Request Timeout Value (RTV) request
+ * @rdata: The remote port to send the RTV request to
  *
  * Locking Note: The rport lock is expected to be held before calling
  * this routine.
@@ -888,15 +929,16 @@ static void fc_rport_enter_rtv(struct fc_rport_priv *rdata)
         }
 
         if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_RTV,
-                                     fc_rport_rtv_resp, rdata, lport->e_d_tov))
-                fc_rport_error_retry(rdata, fp);
+                                  fc_rport_rtv_resp, rdata,
+                                  2 * lport->r_a_tov))
+                fc_rport_error_retry(rdata, NULL);
         else
                 kref_get(&rdata->kref);
 }
 
 /**
- * fc_rport_enter_logo() - Send Logout (LOGO) request to peer
- * @rdata: private remote port data
+ * fc_rport_enter_logo() - Send a logout (LOGO) request
+ * @rdata: The remote port to send the LOGO request to
  *
  * Locking Note: The rport lock is expected to be held before calling
  * this routine.
@@ -918,24 +960,25 @@ static void fc_rport_enter_logo(struct fc_rport_priv *rdata)
         }
 
         if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_LOGO,
-                                  fc_rport_logo_resp, rdata, lport->e_d_tov))
-                fc_rport_error_retry(rdata, fp);
+                                  fc_rport_logo_resp, rdata,
+                                  2 * lport->r_a_tov))
+                fc_rport_error_retry(rdata, NULL);
         else
                 kref_get(&rdata->kref);
 }
 
 /**
- * fc_rport_els_adisc_resp() - Address Discovery response handler
- * @sp: current sequence in the ADISC exchange
- * @fp: response frame
- * @rdata_arg: remote port private.
+ * fc_rport_els_adisc_resp() - Handler for Address Discovery (ADISC) responses
+ * @sp:        The sequence the ADISC response was on
+ * @fp:        The ADISC response frame
+ * @rdata_arg: The remote port that sent the ADISC response
  *
  * Locking Note: This function will be called without the rport lock
  * held, but it will lock, call an _enter_* function or fc_rport_error
  * and then unlock the rport.
  */
 static void fc_rport_adisc_resp(struct fc_seq *sp, struct fc_frame *fp,
-                              void *rdata_arg)
+                                void *rdata_arg)
 {
         struct fc_rport_priv *rdata = rdata_arg;
         struct fc_els_adisc *adisc;
@@ -983,8 +1026,8 @@ err:
 }
 
 /**
- * fc_rport_enter_adisc() - Send Address Discover (ADISC) request to peer
- * @rdata: remote port private data
+ * fc_rport_enter_adisc() - Send Address Discover (ADISC) request
+ * @rdata: The remote port to send the ADISC request to
  *
  * Locking Note: The rport lock is expected to be held before calling
  * this routine.
@@ -1005,17 +1048,18 @@ static void fc_rport_enter_adisc(struct fc_rport_priv *rdata)
                 return;
         }
         if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_ADISC,
-                                  fc_rport_adisc_resp, rdata, lport->e_d_tov))
-                fc_rport_error_retry(rdata, fp);
+                                  fc_rport_adisc_resp, rdata,
+                                  2 * lport->r_a_tov))
+                fc_rport_error_retry(rdata, NULL);
         else
                 kref_get(&rdata->kref);
 }
 
 /**
- * fc_rport_recv_adisc_req() - Handle incoming Address Discovery (ADISC) Request
- * @rdata: remote port private
- * @sp: current sequence in the ADISC exchange
- * @in_fp: ADISC request frame
+ * fc_rport_recv_adisc_req() - Handler for Address Discovery (ADISC) requests
+ * @rdata: The remote port that sent the ADISC request
+ * @sp:    The sequence the ADISC request was on
+ * @in_fp: The ADISC request frame
  *
  * Locking Note:  Called with the lport and rport locks held.
  */
@@ -1056,10 +1100,82 @@ drop:
 }
 
 /**
- * fc_rport_recv_els_req() - handle a validated ELS request.
- * @lport: Fibre Channel local port
- * @sp: current sequence in the PLOGI exchange
- * @fp: response frame
+ * fc_rport_recv_rls_req() - Handle received Read Link Status request
+ * @rdata: The remote port that sent the RLS request
+ * @sp: The sequence that the RLS was on
+ * @rx_fp: The PRLI request frame
+ *
+ * Locking Note: The rport lock is expected to be held before calling
+ * this function.
+ */
+static void fc_rport_recv_rls_req(struct fc_rport_priv *rdata,
+                                  struct fc_seq *sp, struct fc_frame *rx_fp)
+
+{
+        struct fc_lport *lport = rdata->local_port;
+        struct fc_frame *fp;
+        struct fc_exch *ep = fc_seq_exch(sp);
+        struct fc_els_rls *rls;
+        struct fc_els_rls_resp *rsp;
+        struct fc_els_lesb *lesb;
+        struct fc_seq_els_data rjt_data;
+        struct fc_host_statistics *hst;
+        u32 f_ctl;
+
+        FC_RPORT_DBG(rdata, "Received RLS request while in state %s\n",
+                     fc_rport_state(rdata));
+
+        rls = fc_frame_payload_get(rx_fp, sizeof(*rls));
+        if (!rls) {
+                rjt_data.reason = ELS_RJT_PROT;
+                rjt_data.explan = ELS_EXPL_INV_LEN;
+                goto out_rjt;
+        }
+
+        fp = fc_frame_alloc(lport, sizeof(*rsp));
+        if (!fp) {
+                rjt_data.reason = ELS_RJT_UNAB;
+                rjt_data.explan = ELS_EXPL_INSUF_RES;
+                goto out_rjt;
+        }
+
+        rsp = fc_frame_payload_get(fp, sizeof(*rsp));
+        memset(rsp, 0, sizeof(*rsp));
+        rsp->rls_cmd = ELS_LS_ACC;
+        lesb = &rsp->rls_lesb;
+        if (lport->tt.get_lesb) {
+                /* get LESB from LLD if it supports it */
+                lport->tt.get_lesb(lport, lesb);
+        } else {
+                fc_get_host_stats(lport->host);
+                hst = &lport->host_stats;
+                lesb->lesb_link_fail = htonl(hst->link_failure_count);
+                lesb->lesb_sync_loss = htonl(hst->loss_of_sync_count);
+                lesb->lesb_sig_loss = htonl(hst->loss_of_signal_count);
+                lesb->lesb_prim_err = htonl(hst->prim_seq_protocol_err_count);
+                lesb->lesb_inv_word = htonl(hst->invalid_tx_word_count);
+                lesb->lesb_inv_crc = htonl(hst->invalid_crc_count);
+        }
+
+        sp = lport->tt.seq_start_next(sp);
+        f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ;
+        fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
+                       FC_TYPE_ELS, f_ctl, 0);
+        lport->tt.seq_send(lport, sp, fp);
+        goto out;
+
+out_rjt:
+        rjt_data.fp = NULL;
+        lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
+out:
+        fc_frame_free(rx_fp);
+}
+
+/**
+ * fc_rport_recv_els_req() - Handler for validated ELS requests
+ * @lport: The local port that received the ELS request
+ * @sp:    The sequence that the ELS request was on
+ * @fp:    The ELS request frame
  *
  * Handle incoming ELS requests that require port login.
  * The ELS opcode has already been validated by the caller.
@@ -1117,6 +1233,9 @@ static void fc_rport_recv_els_req(struct fc_lport *lport,
                 els_data.fp = fp;
                 lport->tt.seq_els_rsp_send(sp, ELS_REC, &els_data);
                 break;
+        case ELS_RLS:
+                fc_rport_recv_rls_req(rdata, sp, fp);
+                break;
         default:
                 fc_frame_free(fp);      /* can't happen */
                 break;
@@ -1131,10 +1250,10 @@ reject:
 }
 
 /**
- * fc_rport_recv_req() - Handle a received ELS request from a rport
- * @sp: current sequence in the PLOGI exchange
- * @fp: response frame
- * @lport: Fibre Channel local port
+ * fc_rport_recv_req() - Handler for requests
+ * @sp:    The sequence the request was on
+ * @fp:    The request frame
+ * @lport: The local port that received the request
  *
  * Locking Note: Called with the lport lock held.
  */
@@ -1161,6 +1280,7 @@ void fc_rport_recv_req(struct fc_seq *sp, struct fc_frame *fp,
         case ELS_ADISC:
         case ELS_RRQ:
         case ELS_REC:
+        case ELS_RLS:
                 fc_rport_recv_els_req(lport, sp, fp);
                 break;
         default:
@@ -1174,10 +1294,10 @@ void fc_rport_recv_req(struct fc_seq *sp, struct fc_frame *fp,
 }
 
 /**
- * fc_rport_recv_plogi_req() - Handle incoming Port Login (PLOGI) request
- * @lport: local port
- * @sp: current sequence in the PLOGI exchange
- * @fp: PLOGI request frame
+ * fc_rport_recv_plogi_req() - Handler for Port Login (PLOGI) requests
+ * @lport: The local port that received the PLOGI request
+ * @sp:    The sequence that the PLOGI request was on
+ * @rx_fp: The PLOGI request frame
  *
  * Locking Note: The rport lock is held before calling this function.
  */
@@ -1248,6 +1368,7 @@ static void fc_rport_recv_plogi_req(struct fc_lport *lport,
                 }
                 break;
         case RPORT_ST_PRLI:
+        case RPORT_ST_RTV:
         case RPORT_ST_READY:
         case RPORT_ST_ADISC:
                 FC_RPORT_DBG(rdata, "Received PLOGI in logged-in state %d "
@@ -1255,11 +1376,14 @@ static void fc_rport_recv_plogi_req(struct fc_lport *lport,
                 /* XXX TBD - should reset */
                 break;
         case RPORT_ST_DELETE:
-        default:
-                FC_RPORT_DBG(rdata, "Received PLOGI in unexpected state %d\n",
-                             rdata->rp_state);
-                fc_frame_free(rx_fp);
-                goto out;
+        case RPORT_ST_LOGO:
+        case RPORT_ST_RESTART:
+                FC_RPORT_DBG(rdata, "Received PLOGI in state %s - send busy\n",
+                             fc_rport_state(rdata));
+                mutex_unlock(&rdata->rp_mutex);
+                rjt_data.reason = ELS_RJT_BUSY;
+                rjt_data.explan = ELS_EXPL_NONE;
+                goto reject;
         }
 
         /*
@@ -1295,10 +1419,10 @@ reject:
 }
 
 /**
- * fc_rport_recv_prli_req() - Handle incoming Process Login (PRLI) request
- * @rdata: private remote port data
- * @sp: current sequence in the PRLI exchange
- * @fp: PRLI request frame
+ * fc_rport_recv_prli_req() - Handler for process login (PRLI) requests
+ * @rdata: The remote port that sent the PRLI request
+ * @sp:    The sequence that the PRLI was on
+ * @rx_fp: The PRLI request frame
  *
  * Locking Note: The rport lock is exected to be held before calling
  * this function.
@@ -1402,7 +1526,7 @@ static void fc_rport_recv_prli_req(struct fc_rport_priv *rdata,
                                 break;
                         case FC_TYPE_FCP:
                                 fcp_parm = ntohl(rspp->spp_params);
-                                if (fcp_parm * FCP_SPPF_RETRY)
+                                if (fcp_parm & FCP_SPPF_RETRY)
                                         rdata->flags |= FC_RP_FLAGS_RETRY;
                                 rdata->supported_classes = FC_COS_CLASS3;
                                 if (fcp_parm & FCP_SPPF_INIT_FCN)
@@ -1452,10 +1576,10 @@ static void fc_rport_recv_prli_req(struct fc_rport_priv *rdata,
 }
 
 /**
- * fc_rport_recv_prlo_req() - Handle incoming Process Logout (PRLO) request
- * @rdata: private remote port data
- * @sp: current sequence in the PRLO exchange
- * @fp: PRLO request frame
+ * fc_rport_recv_prlo_req() - Handler for process logout (PRLO) requests
+ * @rdata: The remote port that sent the PRLO request
+ * @sp:    The sequence that the PRLO was on
+ * @fp:    The PRLO request frame
  *
  * Locking Note: The rport lock is exected to be held before calling
  * this function.
@@ -1482,10 +1606,10 @@ static void fc_rport_recv_prlo_req(struct fc_rport_priv *rdata,
 }
 
 /**
- * fc_rport_recv_logo_req() - Handle incoming Logout (LOGO) request
- * @lport: local port.
- * @sp: current sequence in the LOGO exchange
- * @fp: LOGO request frame
+ * fc_rport_recv_logo_req() - Handler for logout (LOGO) requests
+ * @lport: The local port that received the LOGO request
+ * @sp:    The sequence that the LOGO request was on
+ * @fp:    The LOGO request frame
  *
  * Locking Note: The rport lock is exected to be held before calling
  * this function.
@@ -1510,14 +1634,14 @@ static void fc_rport_recv_logo_req(struct fc_lport *lport,
                 FC_RPORT_DBG(rdata, "Received LOGO request while in state %s\n",
                              fc_rport_state(rdata));
 
+                fc_rport_enter_delete(rdata, RPORT_EV_LOGO);
+
                 /*
-                 * If the remote port was created due to discovery,
-                 * log back in.  It may have seen a stale RSCN about us.
+                 * If the remote port was created due to discovery, set state
+                 * to log back in.  It may have seen a stale RSCN about us.
                  */
-                if (rdata->rp_state != RPORT_ST_DELETE && rdata->disc_id)
-                        fc_rport_enter_plogi(rdata);
-                else
-                        fc_rport_enter_delete(rdata, RPORT_EV_LOGO);
+                if (rdata->disc_id)
+                        fc_rport_state_enter(rdata, RPORT_ST_RESTART);
                 mutex_unlock(&rdata->rp_mutex);
         } else
                 FC_RPORT_ID_DBG(lport, sid,
@@ -1526,11 +1650,18 @@ static void fc_rport_recv_logo_req(struct fc_lport *lport,
         fc_frame_free(fp);
 }
 
+/**
+ * fc_rport_flush_queue() - Flush the rport_event_queue
+ */
 static void fc_rport_flush_queue(void)
 {
         flush_workqueue(rport_event_queue);
 }
 
+/**
+ * fc_rport_init() - Initialize the remote port layer for a local port
+ * @lport: The local port to initialize the remote port layer for
+ */
 int fc_rport_init(struct fc_lport *lport)
 {
         if (!lport->tt.rport_lookup)
@@ -1558,25 +1689,33 @@ int fc_rport_init(struct fc_lport *lport)
 }
 EXPORT_SYMBOL(fc_rport_init);
 
-int fc_setup_rport(void)
+/**
+ * fc_setup_rport() - Initialize the rport_event_queue
+ */
+int fc_setup_rport()
 {
         rport_event_queue = create_singlethread_workqueue("fc_rport_eq");
         if (!rport_event_queue)
                 return -ENOMEM;
         return 0;
 }
-EXPORT_SYMBOL(fc_setup_rport);
 
-void fc_destroy_rport(void)
+/**
+ * fc_destroy_rport() - Destroy the rport_event_queue
+ */
+void fc_destroy_rport()
 {
         destroy_workqueue(rport_event_queue);
 }
-EXPORT_SYMBOL(fc_destroy_rport);
 
+/**
+ * fc_rport_terminate_io() - Stop all outstanding I/O on a remote port
+ * @rport: The remote port whose I/O should be terminated
+ */
 void fc_rport_terminate_io(struct fc_rport *rport)
 {
-        struct fc_rport_libfc_priv *rp = rport->dd_data;
-        struct fc_lport *lport = rp->local_port;
+        struct fc_rport_libfc_priv *rpriv = rport->dd_data;
+        struct fc_lport *lport = rpriv->local_port;
 
         lport->tt.exch_mgr_reset(lport, 0, rport->port_id);
         lport->tt.exch_mgr_reset(lport, rport->port_id, 0);
diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
index f1a4246f890c..633e09036357 100644
--- a/drivers/scsi/libiscsi.c
+++ b/drivers/scsi/libiscsi.c
@@ -25,6 +25,7 @@
 #include <linux/kfifo.h>
 #include <linux/delay.h>
 #include <linux/log2.h>
+#include <linux/slab.h>
 #include <asm/unaligned.h>
 #include <net/tcp.h>
 #include <scsi/scsi_cmnd.h>
@@ -266,6 +267,88 @@ static int iscsi_prep_bidi_ahs(struct iscsi_task *task)
 }
 
 /**
+ * iscsi_check_tmf_restrictions - check if a task is affected by TMF
+ * @task: iscsi task
+ * @opcode: opcode to check for
+ *
+ * During TMF a task has to be checked if it's affected.
+ * All unrelated I/O can be passed through, but I/O to the
+ * affected LUN should be restricted.
+ * If 'fast_abort' is set we won't be sending any I/O to the
+ * affected LUN.
+ * Otherwise the target is waiting for all TTTs to be completed,
+ * so we have to send all outstanding Data-Out PDUs to the target.
+ */
+static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode)
+{
+        struct iscsi_conn *conn = task->conn;
+        struct iscsi_tm *tmf = &conn->tmhdr;
+        unsigned int hdr_lun;
+
+        if (conn->tmf_state == TMF_INITIAL)
+                return 0;
+
+        if ((tmf->opcode & ISCSI_OPCODE_MASK) != ISCSI_OP_SCSI_TMFUNC)
+                return 0;
+
+        switch (ISCSI_TM_FUNC_VALUE(tmf)) {
+        case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET:
+                /*
+                 * Allow PDUs for unrelated LUNs
+                 */
+                hdr_lun = scsilun_to_int((struct scsi_lun *)tmf->lun);
+                if (hdr_lun != task->sc->device->lun)
+                        return 0;
+                /* fall through */
+        case ISCSI_TM_FUNC_TARGET_WARM_RESET:
+                /*
+                 * Fail all SCSI cmd PDUs
+                 */
+                if (opcode != ISCSI_OP_SCSI_DATA_OUT) {
+                        iscsi_conn_printk(KERN_INFO, conn,
+                                          "task [op %x/%x itt "
+                                          "0x%x/0x%x] "
+                                          "rejected.\n",
+                                          task->hdr->opcode, opcode,
+                                          task->itt, task->hdr_itt);
+                        return -EACCES;
+                }
+                /*
+                 * And also all data-out PDUs in response to R2T
+                 * if fast_abort is set.
+                 */
+                if (conn->session->fast_abort) {
+                        iscsi_conn_printk(KERN_INFO, conn,
+                                          "task [op %x/%x itt "
+                                          "0x%x/0x%x] fast abort.\n",
+                                          task->hdr->opcode, opcode,
+                                          task->itt, task->hdr_itt);
+                        return -EACCES;
+                }
+                break;
+        case ISCSI_TM_FUNC_ABORT_TASK:
+                /*
+                 * the caller has already checked if the task
+                 * they want to abort was in the pending queue so if
+                 * we are here the cmd pdu has gone out already, and
+                 * we will only hit this for data-outs
+                 */
+                if (opcode == ISCSI_OP_SCSI_DATA_OUT &&
+                    task->hdr_itt == tmf->rtt) {
+                        ISCSI_DBG_SESSION(conn->session,
+                                          "Preventing task %x/%x from sending "
+                                          "data-out due to abort task in "
+                                          "progress\n", task->itt,
+                                          task->hdr_itt);
+                        return -EACCES;
+                }
+                break;
+        }
+
+        return 0;
+}
+
+/**
  * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu
  * @task: iscsi task
  *
@@ -282,6 +365,10 @@ static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
         itt_t itt;
         int rc;
 
+        rc = iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_CMD);
+        if (rc)
+                return rc;
+
         if (conn->session->tt->alloc_pdu) {
                 rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD);
                 if (rc)
@@ -384,12 +471,12 @@ static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
 
         WARN_ON(hdrlength >= 256);
         hdr->hlength = hdrlength & 0xFF;
+        hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn);
 
         if (session->tt->init_task && session->tt->init_task(task))
                 return -EIO;
 
         task->state = ISCSI_TASK_RUNNING;
-        hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn);
         session->cmdsn++;
 
         conn->scsicmd_pdus_cnt++;
@@ -431,7 +518,7 @@ static void iscsi_free_task(struct iscsi_task *task)
         if (conn->login_task == task)
                 return;
 
-        __kfifo_put(session->cmdpool.queue, (void*)&task, sizeof(void*));
+        kfifo_in(&session->cmdpool.queue, (void*)&task, sizeof(void*));
 
         if (sc) {
                 task->sc = NULL;
@@ -577,12 +664,12 @@ static int iscsi_prep_mgmt_task(struct iscsi_conn *conn,
         struct iscsi_session *session = conn->session;
         struct iscsi_hdr *hdr = task->hdr;
         struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr;
+        uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK;
 
         if (conn->session->state == ISCSI_STATE_LOGGING_OUT)
                 return -ENOTCONN;
 
-        if (hdr->opcode != (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) &&
-            hdr->opcode != (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE))
+        if (opcode != ISCSI_OP_LOGIN && opcode != ISCSI_OP_TEXT)
                 nop->exp_statsn = cpu_to_be32(conn->exp_statsn);
         /*
          * pre-format CmdSN for outgoing PDU.
@@ -590,9 +677,12 @@ static int iscsi_prep_mgmt_task(struct iscsi_conn *conn,
         nop->cmdsn = cpu_to_be32(session->cmdsn);
         if (hdr->itt != RESERVED_ITT) {
                 /*
-                 * TODO: We always use immediate, so we never hit this.
+                 * TODO: We always use immediate for normal session pdus.
                  * If we start to send tmfs or nops as non-immediate then
                  * we should start checking the cmdsn numbers for mgmt tasks.
+                 *
+                 * During discovery sessions iscsid sends TEXT as non immediate,
+                 * but we always only send one PDU at a time.
                  */
                 if (conn->c_stage == ISCSI_CONN_STARTED &&
                     !(hdr->opcode & ISCSI_OP_IMMEDIATE)) {
@@ -620,29 +710,35 @@ __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
 {
         struct iscsi_session *session = conn->session;
         struct iscsi_host *ihost = shost_priv(session->host);
+        uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK;
         struct iscsi_task *task;
         itt_t itt;
 
         if (session->state == ISCSI_STATE_TERMINATE)
                 return NULL;
 
-        if (hdr->opcode == (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) ||
-            hdr->opcode == (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE))
+        if (opcode == ISCSI_OP_LOGIN || opcode == ISCSI_OP_TEXT) {
                 /*
                  * Login and Text are sent serially, in
                  * request-followed-by-response sequence.
                  * Same task can be used. Same ITT must be used.
                  * Note that login_task is preallocated at conn_create().
                  */
+                if (conn->login_task->state != ISCSI_TASK_FREE) {
+                        iscsi_conn_printk(KERN_ERR, conn, "Login/Text in "
+                                          "progress. Cannot start new task.\n");
+                        return NULL;
+                }
+
                 task = conn->login_task;
-        else {
+        } else {
                 if (session->state != ISCSI_STATE_LOGGED_IN)
                         return NULL;
 
                 BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE);
                 BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED);
 
-                if (!__kfifo_get(session->cmdpool.queue,
+                if (!kfifo_out(&session->cmdpool.queue,
                                  (void*)&task, sizeof(void*)))
                         return NULL;
         }
@@ -1357,6 +1453,7 @@ EXPORT_SYMBOL_GPL(iscsi_requeue_task);
  **/
 static int iscsi_data_xmit(struct iscsi_conn *conn)
 {
+        struct iscsi_task *task;
         int rc = 0;
 
         spin_lock_bh(&conn->session->lock);
@@ -1394,11 +1491,8 @@ check_mgmt:
 
         /* process pending command queue */
         while (!list_empty(&conn->cmdqueue)) {
-                if (conn->tmf_state == TMF_QUEUED)
-                        break;
-
-                conn->task = list_entry(conn->cmdqueue.next,
-                                         struct iscsi_task, running);
+                conn->task = list_entry(conn->cmdqueue.next, struct iscsi_task,
+                                        running);
                 list_del_init(&conn->task->running);
                 if (conn->session->state == ISCSI_STATE_LOGGING_OUT) {
                         fail_scsi_task(conn->task, DID_IMM_RETRY);
@@ -1406,7 +1500,7 @@ check_mgmt:
                 }
                 rc = iscsi_prep_scsi_cmd_pdu(conn->task);
                 if (rc) {
-                        if (rc == -ENOMEM) {
+                        if (rc == -ENOMEM || rc == -EACCES) {
                                 list_add_tail(&conn->task->running,
                                               &conn->cmdqueue);
                                 conn->task = NULL;
@@ -1428,17 +1522,18 @@ check_mgmt:
         }
 
         while (!list_empty(&conn->requeue)) {
-                if (conn->session->fast_abort && conn->tmf_state != TMF_INITIAL)
-                        break;
-
                 /*
                  * we always do fastlogout - conn stop code will clean up.
                  */
                 if (conn->session->state == ISCSI_STATE_LOGGING_OUT)
                         break;
 
-                conn->task = list_entry(conn->requeue.next,
-                                         struct iscsi_task, running);
+                task = list_entry(conn->requeue.next, struct iscsi_task,
+                                  running);
+                if (iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_DATA_OUT))
+                        break;
+
+                conn->task = task;
                 list_del_init(&conn->task->running);
                 conn->task->state = ISCSI_TASK_RUNNING;
                 rc = iscsi_xmit_task(conn);
@@ -1473,7 +1568,7 @@ static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn,
 {
         struct iscsi_task *task;
 
-        if (!__kfifo_get(conn->session->cmdpool.queue,
+        if (!kfifo_out(&conn->session->cmdpool.queue,
                          (void *) &task, sizeof(void *)))
                 return NULL;
 
@@ -1591,7 +1686,7 @@ int iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
         if (!ihost->workq) {
                 reason = iscsi_prep_scsi_cmd_pdu(task);
                 if (reason) {
-                        if (reason == -ENOMEM) {
+                        if (reason == -ENOMEM ||  reason == -EACCES) {
                                 reason = FAILURE_OOM;
                                 goto prepd_reject;
                         } else {
@@ -1643,9 +1738,21 @@ fault:
 }
 EXPORT_SYMBOL_GPL(iscsi_queuecommand);
 
-int iscsi_change_queue_depth(struct scsi_device *sdev, int depth)
+int iscsi_change_queue_depth(struct scsi_device *sdev, int depth, int reason)
 {
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
+        switch (reason) {
+        case SCSI_QDEPTH_DEFAULT:
+                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
+                break;
+        case SCSI_QDEPTH_QFULL:
+                scsi_track_queue_full(sdev, depth);
+                break;
+        case SCSI_QDEPTH_RAMP_UP:
+                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
+                break;
+        default:
+                return -EOPNOTSUPP;
+        }
         return sdev->queue_depth;
 }
 EXPORT_SYMBOL_GPL(iscsi_change_queue_depth);
@@ -1660,72 +1767,6 @@ int iscsi_target_alloc(struct scsi_target *starget)
 }
 EXPORT_SYMBOL_GPL(iscsi_target_alloc);
 
-void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session)
-{
-        struct iscsi_session *session = cls_session->dd_data;
-
-        spin_lock_bh(&session->lock);
-        if (session->state != ISCSI_STATE_LOGGED_IN) {
-                session->state = ISCSI_STATE_RECOVERY_FAILED;
-                if (session->leadconn)
-                        wake_up(&session->leadconn->ehwait);
-        }
-        spin_unlock_bh(&session->lock);
-}
-EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout);
-
-int iscsi_eh_target_reset(struct scsi_cmnd *sc)
-{
-        struct iscsi_cls_session *cls_session;
-        struct iscsi_session *session;
-        struct iscsi_conn *conn;
-
-        cls_session = starget_to_session(scsi_target(sc->device));
-        session = cls_session->dd_data;
-        conn = session->leadconn;
-
-        mutex_lock(&session->eh_mutex);
-        spin_lock_bh(&session->lock);
-        if (session->state == ISCSI_STATE_TERMINATE) {
-failed:
-                ISCSI_DBG_EH(session,
-                             "failing target reset: Could not log back into "
-                             "target [age %d]\n",
-                             session->age);
-                spin_unlock_bh(&session->lock);
-                mutex_unlock(&session->eh_mutex);
-                return FAILED;
-        }
-
-        spin_unlock_bh(&session->lock);
-        mutex_unlock(&session->eh_mutex);
-        /*
-         * we drop the lock here but the leadconn cannot be destoyed while
-         * we are in the scsi eh
-         */
-        iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
-
-        ISCSI_DBG_EH(session, "wait for relogin\n");
-        wait_event_interruptible(conn->ehwait,
-                                 session->state == ISCSI_STATE_TERMINATE ||
-                                 session->state == ISCSI_STATE_LOGGED_IN ||
-                                 session->state == ISCSI_STATE_RECOVERY_FAILED);
-        if (signal_pending(current))
-                flush_signals(current);
-
-        mutex_lock(&session->eh_mutex);
-        spin_lock_bh(&session->lock);
-        if (session->state == ISCSI_STATE_LOGGED_IN) {
-                ISCSI_DBG_EH(session,
-                             "target reset succeeded\n");
-        } else
-                goto failed;
-        spin_unlock_bh(&session->lock);
-        mutex_unlock(&session->eh_mutex);
-        return SUCCESS;
-}
-EXPORT_SYMBOL_GPL(iscsi_eh_target_reset);
-
 static void iscsi_tmf_timedout(unsigned long data)
 {
         struct iscsi_conn *conn = (struct iscsi_conn *)data;
@@ -1879,10 +1920,11 @@ static int iscsi_has_ping_timed_out(struct iscsi_conn *conn)
 static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
 {
         enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED;
-        struct iscsi_task *task = NULL;
+        struct iscsi_task *task = NULL, *running_task;
         struct iscsi_cls_session *cls_session;
         struct iscsi_session *session;
         struct iscsi_conn *conn;
+        int i;
 
         cls_session = starget_to_session(scsi_target(sc->device));
         session = cls_session->dd_data;
@@ -1907,8 +1949,15 @@ static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
         }
 
         task = (struct iscsi_task *)sc->SCp.ptr;
-        if (!task)
+        if (!task) {
+                /*
+                 * Raced with completion. Just reset timer, and let it
+                 * complete normally
+                 */
+                rc = BLK_EH_RESET_TIMER;
                 goto done;
+        }
+
         /*
          * If we have sent (at least queued to the network layer) a pdu or
          * recvd one for the task since the last timeout ask for
@@ -1916,10 +1965,10 @@ static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
          * we can check if it is the task or connection when we send the
          * nop as a ping.
          */
-        if (time_after_eq(task->last_xfer, task->last_timeout)) {
+        if (time_after(task->last_xfer, task->last_timeout)) {
                 ISCSI_DBG_EH(session, "Command making progress. Asking "
                              "scsi-ml for more time to complete. "
-                             "Last data recv at %lu. Last timeout was at "
+                             "Last data xfer at %lu. Last timeout was at "
                              "%lu\n.", task->last_xfer, task->last_timeout);
                 task->have_checked_conn = false;
                 rc = BLK_EH_RESET_TIMER;
@@ -1937,6 +1986,43 @@ static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
                 goto done;
         }
 
+        for (i = 0; i < conn->session->cmds_max; i++) {
+                running_task = conn->session->cmds[i];
+                if (!running_task->sc || running_task == task ||
+                     running_task->state != ISCSI_TASK_RUNNING)
+                        continue;
+
+                /*
+                 * Only check if cmds started before this one have made
+                 * progress, or this could never fail
+                 */
+                if (time_after(running_task->sc->jiffies_at_alloc,
+                               task->sc->jiffies_at_alloc))
+                        continue;
+
+                if (time_after(running_task->last_xfer, task->last_timeout)) {
+                        /*
+                         * This task has not made progress, but a task
+                         * started before us has transferred data since
+                         * we started/last-checked. We could be queueing
+                         * too many tasks or the LU is bad.
+                         *
+                         * If the device is bad the cmds ahead of us on
+                         * other devs will complete, and this loop will
+                         * eventually fail starting the scsi eh.
+                         */
+                        ISCSI_DBG_EH(session, "Command has not made progress "
+                                     "but commands ahead of it have. "
+                                     "Asking scsi-ml for more time to "
+                                     "complete. Our last xfer vs running task "
+                                     "last xfer %lu/%lu. Last check %lu.\n",
+                                     task->last_xfer, running_task->last_xfer,
+                                     task->last_timeout);
+                        rc = BLK_EH_RESET_TIMER;
+                        goto done;
+                }
+        }
+
         /* Assumes nop timeout is shorter than scsi cmd timeout */
         if (task->have_checked_conn)
                 goto done;
@@ -2108,6 +2194,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
                 spin_lock_bh(&session->lock);
                 fail_scsi_task(task, DID_ABORT);
                 conn->tmf_state = TMF_INITIAL;
+                memset(hdr, 0, sizeof(*hdr));
                 spin_unlock_bh(&session->lock);
                 iscsi_start_tx(conn);
                 goto success_unlocked;
@@ -2118,6 +2205,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
         case TMF_NOT_FOUND:
                 if (!sc->SCp.ptr) {
                         conn->tmf_state = TMF_INITIAL;
+                        memset(hdr, 0, sizeof(*hdr));
                         /* task completed before tmf abort response */
                         ISCSI_DBG_EH(session, "sc completed while abort in "
                                               "progress\n");
@@ -2212,6 +2300,7 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc)
         iscsi_suspend_tx(conn);
 
         spin_lock_bh(&session->lock);
+        memset(hdr, 0, sizeof(*hdr));
         fail_scsi_tasks(conn, sc->device->lun, DID_ERROR);
         conn->tmf_state = TMF_INITIAL;
         spin_unlock_bh(&session->lock);
@@ -2229,6 +2318,187 @@ done:
 }
 EXPORT_SYMBOL_GPL(iscsi_eh_device_reset);
 
+void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session)
+{
+        struct iscsi_session *session = cls_session->dd_data;
+
+        spin_lock_bh(&session->lock);
+        if (session->state != ISCSI_STATE_LOGGED_IN) {
+                session->state = ISCSI_STATE_RECOVERY_FAILED;
+                if (session->leadconn)
+                        wake_up(&session->leadconn->ehwait);
+        }
+        spin_unlock_bh(&session->lock);
+}
+EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout);
+
+/**
+ * iscsi_eh_session_reset - drop session and attempt relogin
+ * @sc: scsi command
+ *
+ * This function will wait for a relogin, session termination from
+ * userspace, or a recovery/replacement timeout.
+ */
+int iscsi_eh_session_reset(struct scsi_cmnd *sc)
+{
+        struct iscsi_cls_session *cls_session;
+        struct iscsi_session *session;
+        struct iscsi_conn *conn;
+
+        cls_session = starget_to_session(scsi_target(sc->device));
+        session = cls_session->dd_data;
+        conn = session->leadconn;
+
+        mutex_lock(&session->eh_mutex);
+        spin_lock_bh(&session->lock);
+        if (session->state == ISCSI_STATE_TERMINATE) {
+failed:
+                ISCSI_DBG_EH(session,
+                             "failing session reset: Could not log back into "
+                             "%s, %s [age %d]\n", session->targetname,
+                             conn->persistent_address, session->age);
+                spin_unlock_bh(&session->lock);
+                mutex_unlock(&session->eh_mutex);
+                return FAILED;
+        }
+
+        spin_unlock_bh(&session->lock);
+        mutex_unlock(&session->eh_mutex);
+        /*
+         * we drop the lock here but the leadconn cannot be destoyed while
+         * we are in the scsi eh
+         */
+        iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
+
+        ISCSI_DBG_EH(session, "wait for relogin\n");
+        wait_event_interruptible(conn->ehwait,
+                                 session->state == ISCSI_STATE_TERMINATE ||
+                                 session->state == ISCSI_STATE_LOGGED_IN ||
+                                 session->state == ISCSI_STATE_RECOVERY_FAILED);
+        if (signal_pending(current))
+                flush_signals(current);
+
+        mutex_lock(&session->eh_mutex);
+        spin_lock_bh(&session->lock);
+        if (session->state == ISCSI_STATE_LOGGED_IN) {
+                ISCSI_DBG_EH(session,
+                             "session reset succeeded for %s,%s\n",
+                             session->targetname, conn->persistent_address);
+        } else
+                goto failed;
+        spin_unlock_bh(&session->lock);
+        mutex_unlock(&session->eh_mutex);
+        return SUCCESS;
+}
+EXPORT_SYMBOL_GPL(iscsi_eh_session_reset);
+
+static void iscsi_prep_tgt_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr)
+{
+        memset(hdr, 0, sizeof(*hdr));
+        hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE;
+        hdr->flags = ISCSI_TM_FUNC_TARGET_WARM_RESET & ISCSI_FLAG_TM_FUNC_MASK;
+        hdr->flags |= ISCSI_FLAG_CMD_FINAL;
+        hdr->rtt = RESERVED_ITT;
+}
+
+/**
+ * iscsi_eh_target_reset - reset target
+ * @sc: scsi command
+ *
+ * This will attempt to send a warm target reset.
+ */
+int iscsi_eh_target_reset(struct scsi_cmnd *sc)
+{
+        struct iscsi_cls_session *cls_session;
+        struct iscsi_session *session;
+        struct iscsi_conn *conn;
+        struct iscsi_tm *hdr;
+        int rc = FAILED;
+
+        cls_session = starget_to_session(scsi_target(sc->device));
+        session = cls_session->dd_data;
+
+        ISCSI_DBG_EH(session, "tgt Reset [sc %p tgt %s]\n", sc,
+                     session->targetname);
+
+        mutex_lock(&session->eh_mutex);
+        spin_lock_bh(&session->lock);
+        /*
+         * Just check if we are not logged in. We cannot check for
+         * the phase because the reset could come from a ioctl.
+         */
+        if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN)
+                goto unlock;
+        conn = session->leadconn;
+
+        /* only have one tmf outstanding at a time */
+        if (conn->tmf_state != TMF_INITIAL)
+                goto unlock;
+        conn->tmf_state = TMF_QUEUED;
+
+        hdr = &conn->tmhdr;
+        iscsi_prep_tgt_reset_pdu(sc, hdr);
+
+        if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age,
+                                    session->tgt_reset_timeout)) {
+                rc = FAILED;
+                goto unlock;
+        }
+
+        switch (conn->tmf_state) {
+        case TMF_SUCCESS:
+                break;
+        case TMF_TIMEDOUT:
+                spin_unlock_bh(&session->lock);
+                iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
+                goto done;
+        default:
+                conn->tmf_state = TMF_INITIAL;
+                goto unlock;
+        }
+
+        rc = SUCCESS;
+        spin_unlock_bh(&session->lock);
+
+        iscsi_suspend_tx(conn);
+
+        spin_lock_bh(&session->lock);
+        memset(hdr, 0, sizeof(*hdr));
+        fail_scsi_tasks(conn, -1, DID_ERROR);
+        conn->tmf_state = TMF_INITIAL;
+        spin_unlock_bh(&session->lock);
+
+        iscsi_start_tx(conn);
+        goto done;
+
+unlock:
+        spin_unlock_bh(&session->lock);
+done:
+        ISCSI_DBG_EH(session, "tgt %s reset result = %s\n", session->targetname,
+                     rc == SUCCESS ? "SUCCESS" : "FAILED");
+        mutex_unlock(&session->eh_mutex);
+        return rc;
+}
+EXPORT_SYMBOL_GPL(iscsi_eh_target_reset);
+
+/**
+ * iscsi_eh_recover_target - reset target and possibly the session
+ * @sc: scsi command
+ *
+ * This will attempt to send a warm target reset. If that fails,
+ * we will escalate to ERL0 session recovery.
+ */
+int iscsi_eh_recover_target(struct scsi_cmnd *sc)
+{
+        int rc;
+
+        rc = iscsi_eh_target_reset(sc);
+        if (rc == FAILED)
+                rc = iscsi_eh_session_reset(sc);
+        return rc;
+}
+EXPORT_SYMBOL_GPL(iscsi_eh_recover_target);
+
 /*
  * Pre-allocate a pool of @max items of @item_size. By default, the pool
  * should be accessed via kfifo_{get,put} on q->queue.
@@ -2252,12 +2522,7 @@ iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size)
         if (q->pool == NULL)
                 return -ENOMEM;
 
-        q->queue = kfifo_init((void*)q->pool, max * sizeof(void*),
-                              GFP_KERNEL, NULL);
-        if (IS_ERR(q->queue)) {
-                q->queue = NULL;
-                goto enomem;
-        }
+        kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*));
 
         for (i = 0; i < max; i++) {
                 q->pool[i] = kzalloc(item_size, GFP_KERNEL);
@@ -2265,7 +2530,7 @@ iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size)
                         q->max = i;
                         goto enomem;
                 }
-                __kfifo_put(q->queue, (void*)&q->pool[i], sizeof(void*));
+                kfifo_in(&q->queue, (void*)&q->pool[i], sizeof(void*));
         }
 
         if (items) {
@@ -2288,7 +2553,6 @@ void iscsi_pool_free(struct iscsi_pool *q)
         for (i = 0; i < q->max; i++)
                 kfree(q->pool[i]);
         kfree(q->pool);
-        kfree(q->queue);
 }
 EXPORT_SYMBOL_GPL(iscsi_pool_free);
 
@@ -2495,6 +2759,7 @@ iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost,
         session->host = shost;
         session->state = ISCSI_STATE_FREE;
         session->fast_abort = 1;
+        session->tgt_reset_timeout = 30;
         session->lu_reset_timeout = 15;
         session->abort_timeout = 10;
         session->scsi_cmds_max = scsi_cmds;
@@ -2615,7 +2880,7 @@ iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size,
 
         /* allocate login_task used for the login/text sequences */
         spin_lock_bh(&session->lock);
-        if (!__kfifo_get(session->cmdpool.queue,
+        if (!kfifo_out(&session->cmdpool.queue,
                          (void*)&conn->login_task,
                          sizeof(void*))) {
                 spin_unlock_bh(&session->lock);
@@ -2635,7 +2900,7 @@ iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size,
         return cls_conn;
 
 login_task_data_alloc_fail:
-        __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task,
+        kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
                     sizeof(void*));
 login_task_alloc_fail:
         iscsi_destroy_conn(cls_conn);
@@ -2698,7 +2963,7 @@ void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn)
         free_pages((unsigned long) conn->data,
                    get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
         kfree(conn->persistent_address);
-        __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task,
+        kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
                     sizeof(void*));
         if (session->leadconn == conn)
                 session->leadconn = NULL;
@@ -2823,14 +3088,15 @@ static void iscsi_start_session_recovery(struct iscsi_session *session,
                 session->state = ISCSI_STATE_TERMINATE;
         else if (conn->stop_stage != STOP_CONN_RECOVER)
                 session->state = ISCSI_STATE_IN_RECOVERY;
+
+        old_stop_stage = conn->stop_stage;
+        conn->stop_stage = flag;
         spin_unlock_bh(&session->lock);
 
         del_timer_sync(&conn->transport_timer);
         iscsi_suspend_tx(conn);
 
         spin_lock_bh(&session->lock);
-        old_stop_stage = conn->stop_stage;
-        conn->stop_stage = flag;
         conn->c_stage = ISCSI_CONN_STOPPED;
         spin_unlock_bh(&session->lock);
 
@@ -2856,6 +3122,7 @@ static void iscsi_start_session_recovery(struct iscsi_session *session,
         spin_lock_bh(&session->lock);
         fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED);
         fail_mgmt_tasks(session, conn);
+        memset(&conn->tmhdr, 0, sizeof(conn->tmhdr));
         spin_unlock_bh(&session->lock);
         mutex_unlock(&session->eh_mutex);
 }
@@ -2932,6 +3199,9 @@ int iscsi_set_param(struct iscsi_cls_conn *cls_conn,
         case ISCSI_PARAM_LU_RESET_TMO:
                 sscanf(buf, "%d", &session->lu_reset_timeout);
                 break;
+        case ISCSI_PARAM_TGT_RESET_TMO:
+                sscanf(buf, "%d", &session->tgt_reset_timeout);
+                break;
         case ISCSI_PARAM_PING_TMO:
                 sscanf(buf, "%d", &conn->ping_timeout);
                 break;
@@ -3031,6 +3301,9 @@ int iscsi_session_get_param(struct iscsi_cls_session *cls_session,
         case ISCSI_PARAM_LU_RESET_TMO:
                 len = sprintf(buf, "%d\n", session->lu_reset_timeout);
                 break;
+        case ISCSI_PARAM_TGT_RESET_TMO:
+                len = sprintf(buf, "%d\n", session->tgt_reset_timeout);
+                break;
         case ISCSI_PARAM_INITIAL_R2T_EN:
                 len = sprintf(buf, "%d\n", session->initial_r2t_en);
                 break;
diff --git a/drivers/scsi/libiscsi_tcp.c b/drivers/scsi/libiscsi_tcp.c
index 2e0746d70303..5c92620292fb 100644
--- a/drivers/scsi/libiscsi_tcp.c
+++ b/drivers/scsi/libiscsi_tcp.c
@@ -29,6 +29,7 @@
 #include <linux/types.h>
 #include <linux/list.h>
 #include <linux/inet.h>
+#include <linux/slab.h>
 #include <linux/file.h>
 #include <linux/blkdev.h>
 #include <linux/crypto.h>
@@ -445,15 +446,15 @@ void iscsi_tcp_cleanup_task(struct iscsi_task *task)
                 return;
 
         /* flush task's r2t queues */
-        while (__kfifo_get(tcp_task->r2tqueue, (void*)&r2t, sizeof(void*))) {
-                __kfifo_put(tcp_task->r2tpool.queue, (void*)&r2t,
+        while (kfifo_out(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*))) {
+                kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
                             sizeof(void*));
                 ISCSI_DBG_TCP(task->conn, "pending r2t dropped\n");
         }
 
         r2t = tcp_task->r2t;
         if (r2t != NULL) {
-                __kfifo_put(tcp_task->r2tpool.queue, (void*)&r2t,
+                kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
                             sizeof(void*));
                 tcp_task->r2t = NULL;
         }
@@ -541,7 +542,7 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
                 return 0;
         }
 
-        rc = __kfifo_get(tcp_task->r2tpool.queue, (void*)&r2t, sizeof(void*));
+        rc = kfifo_out(&tcp_task->r2tpool.queue, (void*)&r2t, sizeof(void*));
         if (!rc) {
                 iscsi_conn_printk(KERN_ERR, conn, "Could not allocate R2T. "
                                   "Target has sent more R2Ts than it "
@@ -554,7 +555,7 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
         if (r2t->data_length == 0) {
                 iscsi_conn_printk(KERN_ERR, conn,
                                   "invalid R2T with zero data len\n");
-                __kfifo_put(tcp_task->r2tpool.queue, (void*)&r2t,
+                kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
                             sizeof(void*));
                 return ISCSI_ERR_DATALEN;
         }
@@ -570,7 +571,7 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
                                   "invalid R2T with data len %u at offset %u "
                                   "and total length %d\n", r2t->data_length,
                                   r2t->data_offset, scsi_out(task->sc)->length);
-                __kfifo_put(tcp_task->r2tpool.queue, (void*)&r2t,
+                kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
                             sizeof(void*));
                 return ISCSI_ERR_DATALEN;
         }
@@ -580,7 +581,7 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
         r2t->sent = 0;
 
         tcp_task->exp_datasn = r2tsn + 1;
-        __kfifo_put(tcp_task->r2tqueue, (void*)&r2t, sizeof(void*));
+        kfifo_in(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*));
         conn->r2t_pdus_cnt++;
 
         iscsi_requeue_task(task);
@@ -951,7 +952,7 @@ int iscsi_tcp_task_init(struct iscsi_task *task)
                 return conn->session->tt->init_pdu(task, 0, task->data_count);
         }
 
-        BUG_ON(__kfifo_len(tcp_task->r2tqueue));
+        BUG_ON(kfifo_len(&tcp_task->r2tqueue));
         tcp_task->exp_datasn = 0;
 
         /* Prepare PDU, optionally w/ immediate data */
@@ -982,7 +983,7 @@ static struct iscsi_r2t_info *iscsi_tcp_get_curr_r2t(struct iscsi_task *task)
                         if (r2t->data_length <= r2t->sent) {
                                 ISCSI_DBG_TCP(task->conn,
                                               "  done with r2t %p\n", r2t);
-                                __kfifo_put(tcp_task->r2tpool.queue,
+                                kfifo_in(&tcp_task->r2tpool.queue,
                                             (void *)&tcp_task->r2t,
                                             sizeof(void *));
                                 tcp_task->r2t = r2t = NULL;
@@ -990,9 +991,12 @@ static struct iscsi_r2t_info *iscsi_tcp_get_curr_r2t(struct iscsi_task *task)
                 }
 
                 if (r2t == NULL) {
-                        __kfifo_get(tcp_task->r2tqueue,
-                                    (void *)&tcp_task->r2t, sizeof(void *));
-                        r2t = tcp_task->r2t;
+                        if (kfifo_out(&tcp_task->r2tqueue,
+                            (void *)&tcp_task->r2t, sizeof(void *)) !=
+                            sizeof(void *))
+                                r2t = NULL;
+                        else
+                                r2t = tcp_task->r2t;
                 }
                 spin_unlock_bh(&session->lock);
         }
@@ -1004,7 +1008,7 @@ static struct iscsi_r2t_info *iscsi_tcp_get_curr_r2t(struct iscsi_task *task)
  * iscsi_tcp_task_xmit - xmit normal PDU task
  * @task: iscsi command task
  *
- * We're expected to return 0 when everything was transmitted succesfully,
+ * We're expected to return 0 when everything was transmitted successfully,
  * -EAGAIN if there's still data in the queue, or != 0 for any other kind
  * of error.
  */
@@ -1127,9 +1131,8 @@ int iscsi_tcp_r2tpool_alloc(struct iscsi_session *session)
                 }
 
                 /* R2T xmit queue */
-                tcp_task->r2tqueue = kfifo_alloc(
-                      session->max_r2t * 4 * sizeof(void*), GFP_KERNEL, NULL);
-                if (tcp_task->r2tqueue == ERR_PTR(-ENOMEM)) {
+                if (kfifo_alloc(&tcp_task->r2tqueue,
+                      session->max_r2t * 4 * sizeof(void*), GFP_KERNEL)) {
                         iscsi_pool_free(&tcp_task->r2tpool);
                         goto r2t_alloc_fail;
                 }
@@ -1142,7 +1145,7 @@ r2t_alloc_fail:
                 struct iscsi_task *task = session->cmds[i];
                 struct iscsi_tcp_task *tcp_task = task->dd_data;
 
-                kfifo_free(tcp_task->r2tqueue);
+                kfifo_free(&tcp_task->r2tqueue);
                 iscsi_pool_free(&tcp_task->r2tpool);
         }
         return -ENOMEM;
@@ -1157,7 +1160,7 @@ void iscsi_tcp_r2tpool_free(struct iscsi_session *session)
                 struct iscsi_task *task = session->cmds[i];
                 struct iscsi_tcp_task *tcp_task = task->dd_data;
 
-                kfifo_free(tcp_task->r2tqueue);
+                kfifo_free(&tcp_task->r2tqueue);
                 iscsi_pool_free(&tcp_task->r2tpool);
         }
 }
diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
index e15501170698..88f744672576 100644
--- a/drivers/scsi/libsas/sas_ata.c
+++ b/drivers/scsi/libsas/sas_ata.c
@@ -22,6 +22,7 @@
  */
 
 #include <linux/scatterlist.h>
+#include <linux/slab.h>
 
 #include <scsi/sas_ata.h>
 #include "sas_internal.h"
@@ -394,11 +395,15 @@ int sas_ata_init_host_and_port(struct domain_device *found_dev,
 void sas_ata_task_abort(struct sas_task *task)
 {
         struct ata_queued_cmd *qc = task->uldd_task;
+        struct request_queue *q = qc->scsicmd->device->request_queue;
         struct completion *waiting;
+        unsigned long flags;
 
         /* Bounce SCSI-initiated commands to the SCSI EH */
         if (qc->scsicmd) {
+                spin_lock_irqsave(q->queue_lock, flags);
                 blk_abort_request(qc->scsicmd->request);
+                spin_unlock_irqrestore(q->queue_lock, flags);
                 scsi_schedule_eh(qc->scsicmd->device->host);
                 return;
         }
diff --git a/drivers/scsi/libsas/sas_discover.c b/drivers/scsi/libsas/sas_discover.c
index facc5bfcf7db..f5831930df9b 100644
--- a/drivers/scsi/libsas/sas_discover.c
+++ b/drivers/scsi/libsas/sas_discover.c
@@ -23,6 +23,7 @@
  */
 
 #include <linux/scatterlist.h>
+#include <linux/slab.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_eh.h>
 #include "sas_internal.h"
diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c
index 33cf988c8c8a..c65af02dcfe8 100644
--- a/drivers/scsi/libsas/sas_expander.c
+++ b/drivers/scsi/libsas/sas_expander.c
@@ -24,6 +24,7 @@
 
 #include <linux/scatterlist.h>
 #include <linux/blkdev.h>
+#include <linux/slab.h>
 
 #include "sas_internal.h"
 
diff --git a/drivers/scsi/libsas/sas_host_smp.c b/drivers/scsi/libsas/sas_host_smp.c
index 1bc3b7567994..04ad8dd1a74c 100644
--- a/drivers/scsi/libsas/sas_host_smp.c
+++ b/drivers/scsi/libsas/sas_host_smp.c
@@ -10,6 +10,7 @@
  */
 #include <linux/scatterlist.h>
 #include <linux/blkdev.h>
+#include <linux/slab.h>
 
 #include "sas_internal.h"
 
diff --git a/drivers/scsi/libsas/sas_init.c b/drivers/scsi/libsas/sas_init.c
index 9cd5abe9e714..2dc55343f671 100644
--- a/drivers/scsi/libsas/sas_init.c
+++ b/drivers/scsi/libsas/sas_init.c
@@ -24,6 +24,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/device.h>
 #include <linux/spinlock.h>
diff --git a/drivers/scsi/libsas/sas_scsi_host.c b/drivers/scsi/libsas/sas_scsi_host.c
index 1c558d3bce18..822835055cef 100644
--- a/drivers/scsi/libsas/sas_scsi_host.c
+++ b/drivers/scsi/libsas/sas_scsi_host.c
@@ -44,6 +44,7 @@
 #include <linux/err.h>
 #include <linux/blkdev.h>
 #include <linux/freezer.h>
+#include <linux/gfp.h>
 #include <linux/scatterlist.h>
 #include <linux/libata.h>
 
@@ -820,10 +821,14 @@ void sas_slave_destroy(struct scsi_device *scsi_dev)
                 ata_port_disable(dev->sata_dev.ap);
 }
 
-int sas_change_queue_depth(struct scsi_device *scsi_dev, int new_depth)
+int sas_change_queue_depth(struct scsi_device *scsi_dev, int new_depth,
+                           int reason)
 {
         int res = min(new_depth, SAS_MAX_QD);
 
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
         if (scsi_dev->tagged_supported)
                 scsi_adjust_queue_depth(scsi_dev, scsi_get_tag_type(scsi_dev),
                                         res);
@@ -1025,6 +1030,8 @@ int __sas_task_abort(struct sas_task *task)
 void sas_task_abort(struct sas_task *task)
 {
         struct scsi_cmnd *sc = task->uldd_task;
+        struct request_queue *q = sc->device->request_queue;
+        unsigned long flags;
 
         /* Escape for libsas internal commands */
         if (!sc) {
@@ -1039,7 +1046,9 @@ void sas_task_abort(struct sas_task *task)
                 return;
         }
 
+        spin_lock_irqsave(q->queue_lock, flags);
         blk_abort_request(sc->request);
+        spin_unlock_irqrestore(q->queue_lock, flags);
         scsi_schedule_eh(sc->device->host);
 }
 
diff --git a/drivers/scsi/libsrp.c b/drivers/scsi/libsrp.c
index 9ad38e81e343..ff6a28ce9b69 100644
--- a/drivers/scsi/libsrp.c
+++ b/drivers/scsi/libsrp.c
@@ -1,5 +1,5 @@
 /*
- * SCSI RDAM Protocol lib functions
+ * SCSI RDMA Protocol lib functions
  *
  * Copyright (C) 2006 FUJITA Tomonori <tomof@acm.org>
  *
@@ -19,6 +19,7 @@
  * 02110-1301 USA
  */
 #include <linux/err.h>
+#include <linux/slab.h>
 #include <linux/kfifo.h>
 #include <linux/scatterlist.h>
 #include <linux/dma-mapping.h>
@@ -58,19 +59,15 @@ static int srp_iu_pool_alloc(struct srp_queue *q, size_t max,
                 goto free_pool;
 
         spin_lock_init(&q->lock);
-        q->queue = kfifo_init((void *) q->pool, max * sizeof(void *),
-                              GFP_KERNEL, &q->lock);
-        if (IS_ERR(q->queue))
-                goto free_item;
+        kfifo_init(&q->queue, (void *) q->pool, max * sizeof(void *));
 
         for (i = 0, iue = q->items; i < max; i++) {
-                __kfifo_put(q->queue, (void *) &iue, sizeof(void *));
+                kfifo_in(&q->queue, (void *) &iue, sizeof(void *));
                 iue->sbuf = ring[i];
                 iue++;
         }
         return 0;
 
-free_item:
         kfree(q->items);
 free_pool:
         kfree(q->pool);
@@ -167,7 +164,11 @@ struct iu_entry *srp_iu_get(struct srp_target *target)
 {
         struct iu_entry *iue = NULL;
 
-        kfifo_get(target->iu_queue.queue, (void *) &iue, sizeof(void *));
+        if (kfifo_out_locked(&target->iu_queue.queue, (void *) &iue,
+                sizeof(void *), &target->iu_queue.lock) != sizeof(void *)) {
+                        WARN_ONCE(1, "unexpected fifo state");
+                        return NULL;
+        }
         if (!iue)
                 return iue;
         iue->target = target;
@@ -179,7 +180,8 @@ EXPORT_SYMBOL_GPL(srp_iu_get);
 
 void srp_iu_put(struct iu_entry *iue)
 {
-        kfifo_put(iue->target->iu_queue.queue, (void *) &iue, sizeof(void *));
+        kfifo_in_locked(&iue->target->iu_queue.queue, (void *) &iue,
+                        sizeof(void *), &iue->target->iu_queue.lock);
 }
 EXPORT_SYMBOL_GPL(srp_iu_put);
 
@@ -327,7 +329,7 @@ int srp_transfer_data(struct scsi_cmnd *sc, struct srp_cmd *cmd,
         int offset, err = 0;
         u8 format;
 
-        offset = cmd->add_cdb_len * 4;
+        offset = cmd->add_cdb_len & ~3;
 
         dir = srp_cmd_direction(cmd);
         if (dir == DMA_FROM_DEVICE)
@@ -365,7 +367,7 @@ static int vscsis_data_length(struct srp_cmd *cmd, enum dma_data_direction dir)
 {
         struct srp_direct_buf *md;
         struct srp_indirect_buf *id;
-        int len = 0, offset = cmd->add_cdb_len * 4;
+        int len = 0, offset = cmd->add_cdb_len & ~3;
         u8 fmt;
 
         if (dir == DMA_TO_DEVICE)
@@ -439,6 +441,6 @@ int srp_cmd_queue(struct Scsi_Host *shost, struct srp_cmd *cmd, void *info,
 }
 EXPORT_SYMBOL_GPL(srp_cmd_queue);
 
-MODULE_DESCRIPTION("SCSI RDAM Protocol lib functions");
+MODULE_DESCRIPTION("SCSI RDMA Protocol lib functions");
 MODULE_AUTHOR("FUJITA Tomonori");
 MODULE_LICENSE("GPL");
diff --git a/drivers/scsi/lpfc/lpfc.h b/drivers/scsi/lpfc/lpfc.h
index aa10f7951634..565e16dd74fc 100644
--- a/drivers/scsi/lpfc/lpfc.h
+++ b/drivers/scsi/lpfc/lpfc.h
@@ -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-2010 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -37,6 +37,9 @@ struct lpfc_sli2_slim;
                                            the NameServer  before giving up. */
 #define LPFC_CMD_PER_LUN        3       /* max outstanding cmds per lun */
 #define LPFC_DEFAULT_SG_SEG_CNT 64      /* sg element count per scsi cmnd */
+#define LPFC_DEFAULT_MENLO_SG_SEG_CNT 128       /* sg element count per scsi
+                cmnd for menlo needs nearly twice as for firmware
+                downloads using bsg */
 #define LPFC_DEFAULT_PROT_SG_SEG_CNT 4096 /* sg protection elements count */
 #define LPFC_MAX_SG_SEG_CNT     4096    /* sg element count per scsi cmnd */
 #define LPFC_MAX_PROT_SG_SEG_CNT 4096   /* prot sg element count per scsi cmd*/
@@ -109,7 +112,8 @@ struct hbq_dmabuf {
         struct lpfc_dmabuf dbuf;
         uint32_t size;
         uint32_t tag;
-        struct lpfc_rcqe rcqe;
+        struct lpfc_cq_event cq_event;
+        unsigned long time_stamp;
 };
 
 /* Priority bit.  Set value to exceed low water mark in lpfc_mem. */
@@ -201,6 +205,7 @@ struct lpfc_stats {
         uint32_t elsRcvLIRR;
         uint32_t elsRcvRPS;
         uint32_t elsRcvRPL;
+        uint32_t elsRcvRRQ;
         uint32_t elsXmitFLOGI;
         uint32_t elsXmitFDISC;
         uint32_t elsXmitPLOGI;
@@ -289,8 +294,8 @@ struct lpfc_vport {
 
         uint16_t vpi;
         uint16_t vfi;
-        uint8_t vfi_state;
-#define LPFC_VFI_REGISTERED     0x1
+        uint8_t vpi_state;
+#define LPFC_VPI_REGISTERED     0x1
 
         uint32_t fc_flag;       /* FC flags */
 /* Several of these flags are HBA centric and should be moved to
@@ -313,6 +318,9 @@ struct lpfc_vport {
 #define FC_VPORT_NEEDS_REG_VPI  0x80000  /* Needs to have its vpi registered */
 #define FC_RSCN_DEFERRED        0x100000 /* A deferred RSCN being processed */
 #define FC_VPORT_NEEDS_INIT_VPI 0x200000 /* Need to INIT_VPI before FDISC */
+#define FC_VPORT_CVL_RCVD       0x400000 /* VLink failed due to CVL      */
+#define FC_VFI_REGISTERED       0x800000 /* VFI is registered */
+#define FC_FDISC_COMPLETED      0x1000000/* FDISC completed */
 
         uint32_t ct_flags;
 #define FC_CT_RFF_ID            0x1      /* RFF_ID accepted by switch */
@@ -405,6 +413,7 @@ struct lpfc_vport {
         uint8_t stat_data_enabled;
         uint8_t stat_data_blocked;
         struct list_head rcv_buffer_list;
+        unsigned long rcv_buffer_time_stamp;
         uint32_t vport_flag;
 #define STATIC_VPORT    1
 };
@@ -445,6 +454,8 @@ struct unsol_rcv_ct_ctx {
         uint32_t ctxt_id;
         uint32_t SID;
         uint32_t oxid;
+        uint32_t flags;
+#define UNSOL_VALID     0x00000001
 };
 
 struct lpfc_hba {
@@ -496,7 +507,10 @@ struct lpfc_hba {
                 (struct lpfc_hba *);
         void (*lpfc_stop_port)
                 (struct lpfc_hba *);
-
+        int (*lpfc_hba_init_link)
+                (struct lpfc_hba *);
+        int (*lpfc_hba_down_link)
+                (struct lpfc_hba *);
 
         /* SLI4 specific HBA data structure */
         struct lpfc_sli4_hba sli4_hba;
@@ -527,13 +541,16 @@ struct lpfc_hba {
 #define HBA_ERATT_HANDLED       0x1 /* This flag is set when eratt handled */
 #define DEFER_ERATT             0x2 /* Deferred error attention in progress */
 #define HBA_FCOE_SUPPORT        0x4 /* HBA function supports FCOE */
-#define HBA_RECEIVE_BUFFER      0x8 /* Rcv buffer posted to worker thread */
+#define HBA_SP_QUEUE_EVT        0x8 /* Slow-path qevt posted to worker thread*/
 #define HBA_POST_RECEIVE_BUFFER 0x10 /* Rcv buffers need to be posted */
 #define FCP_XRI_ABORT_EVENT     0x20
 #define ELS_XRI_ABORT_EVENT     0x40
 #define ASYNC_EVENT             0x80
 #define LINK_DISABLED           0x100 /* Link disabled by user */
 #define FCF_DISC_INPROGRESS     0x200 /* FCF discovery in progress */
+#define HBA_FIP_SUPPORT         0x400 /* FIP support in HBA */
+#define HBA_AER_ENABLED         0x800 /* AER enabled with HBA */
+        uint32_t fcp_ring_in_use; /* When polling test if intr-hndlr active*/
         struct lpfc_dmabuf slim2p;
 
         MAILBOX_t *mbox;
@@ -551,6 +568,7 @@ struct lpfc_hba {
         uint8_t fc_linkspeed;   /* Link speed after last READ_LA */
 
         uint32_t fc_eventTag;   /* event tag for link attention */
+        uint32_t link_events;
 
         /* These fields used to be binfo */
         uint32_t fc_pref_DID;   /* preferred D_ID */
@@ -604,8 +622,12 @@ struct lpfc_hba {
         uint32_t cfg_enable_hba_reset;
         uint32_t cfg_enable_hba_heartbeat;
         uint32_t cfg_enable_bg;
-        uint32_t cfg_enable_fip;
         uint32_t cfg_log_verbose;
+        uint32_t cfg_aer_support;
+        uint32_t cfg_suppress_link_up;
+#define LPFC_INITIALIZE_LINK              0     /* do normal init_link mbox */
+#define LPFC_DELAY_INIT_LINK              1     /* layered driver hold off */
+#define LPFC_DELAY_INIT_LINK_INDEFINITELY 2     /* wait, manual intervention */
 
         lpfc_vpd_t vpd;         /* vital product data */
 
@@ -783,10 +805,13 @@ struct lpfc_hba {
         uint16_t vlan_id;
         struct list_head fcf_conn_rec_list;
 
-        struct mutex ct_event_mutex; /* synchronize access to ct_ev_waiters */
+        spinlock_t ct_ev_lock; /* synchronize access to ct_ev_waiters */
         struct list_head ct_ev_waiters;
         struct unsol_rcv_ct_ctx ct_ctx[64];
         uint32_t ctx_idx;
+
+        uint8_t menlo_flag;     /* menlo generic flags */
+#define HBA_MENLO_SUPPORT       0x1 /* HBA supports menlo commands */
 };
 
 static inline struct Scsi_Host *
diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index e1a30a16a9fa..1849e33e68f9 100644
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -23,12 +23,15 @@
 #include <linux/delay.h>
 #include <linux/pci.h>
 #include <linux/interrupt.h>
+#include <linux/aer.h>
+#include <linux/gfp.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_tcq.h>
 #include <scsi/scsi_transport_fc.h>
+#include <scsi/fc/fc_fs.h>
 
 #include "lpfc_hw4.h"
 #include "lpfc_hw.h"
@@ -98,6 +101,28 @@ lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr,
         return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
 }
 
+/**
+ * lpfc_enable_fip_show - Return the fip mode of the HBA
+ * @dev: class unused variable.
+ * @attr: device attribute, not used.
+ * @buf: on return contains the module description text.
+ *
+ * Returns: size of formatted string.
+ **/
+static ssize_t
+lpfc_enable_fip_show(struct device *dev, struct device_attribute *attr,
+                       char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(dev);
+        struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
+        struct lpfc_hba   *phba = vport->phba;
+
+        if (phba->hba_flag & HBA_FIP_SUPPORT)
+                return snprintf(buf, PAGE_SIZE, "1\n");
+        else
+                return snprintf(buf, PAGE_SIZE, "0\n");
+}
+
 static ssize_t
 lpfc_bg_info_show(struct device *dev, struct device_attribute *attr,
                   char *buf)
@@ -458,6 +483,41 @@ lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
 }
 
 /**
+ * lpfc_link_state_store - Transition the link_state on an HBA port
+ * @dev: class device that is converted into a Scsi_host.
+ * @attr: device attribute, not used.
+ * @buf: one or more lpfc_polling_flags values.
+ * @count: not used.
+ *
+ * Returns:
+ * -EINVAL if the buffer is not "up" or "down"
+ * return from link state change function if non-zero
+ * length of the buf on success
+ **/
+static ssize_t
+lpfc_link_state_store(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct Scsi_Host  *shost = class_to_shost(dev);
+        struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
+        struct lpfc_hba   *phba = vport->phba;
+
+        int status = -EINVAL;
+
+        if ((strncmp(buf, "up", sizeof("up") - 1) == 0) &&
+                        (phba->link_state == LPFC_LINK_DOWN))
+                status = phba->lpfc_hba_init_link(phba);
+        else if ((strncmp(buf, "down", sizeof("down") - 1) == 0) &&
+                        (phba->link_state >= LPFC_LINK_UP))
+                status = phba->lpfc_hba_down_link(phba);
+
+        if (status == 0)
+                return strlen(buf);
+        else
+                return status;
+}
+
+/**
  * lpfc_num_discovered_ports_show - Return sum of mapped and unmapped vports
  * @dev: class device that is converted into a Scsi_host.
  * @attr: device attribute, not used.
@@ -654,7 +714,7 @@ lpfc_selective_reset(struct lpfc_hba *phba)
  * Notes:
  * Assumes any error from lpfc_selective_reset() will be negative.
  * If lpfc_selective_reset() returns zero then the length of the buffer
- * is returned which indicates succcess
+ * is returned which indicates success
  *
  * Returns:
  * -EINVAL if the buffer does not contain the string "selective"
@@ -762,9 +822,15 @@ lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
         } else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
                 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
         else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
-                status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
+                if (phba->sli_rev == LPFC_SLI_REV4)
+                        return -EINVAL;
+                else
+                        status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
         else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
-                status = lpfc_do_offline(phba, LPFC_EVT_KILL);
+                if (phba->sli_rev == LPFC_SLI_REV4)
+                        return -EINVAL;
+                else
+                        status = lpfc_do_offline(phba, LPFC_EVT_KILL);
         else
                 return -EINVAL;
 
@@ -1126,6 +1192,9 @@ lpfc_poll_store(struct device *dev, struct device_attribute *attr,
         if ((val & 0x3) != val)
                 return -EINVAL;
 
+        if (phba->sli_rev == LPFC_SLI_REV4)
+                val = 0;
+
         spin_lock_irq(&phba->hbalock);
 
         old_val = phba->cfg_poll;
@@ -1186,7 +1255,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
         struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
         struct lpfc_hba   *phba = vport->phba;\
-        int val = 0;\
+        uint val = 0;\
         val = phba->cfg_##attr;\
         return snprintf(buf, PAGE_SIZE, "%d\n",\
                         phba->cfg_##attr);\
@@ -1214,7 +1283,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
         struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
         struct lpfc_hba   *phba = vport->phba;\
-        int val = 0;\
+        uint val = 0;\
         val = phba->cfg_##attr;\
         return snprintf(buf, PAGE_SIZE, "%#x\n",\
                         phba->cfg_##attr);\
@@ -1241,7 +1310,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
  **/
 #define lpfc_param_init(attr, default, minval, maxval)  \
 static int \
-lpfc_##attr##_init(struct lpfc_hba *phba, int val) \
+lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \
 { \
         if (val >= minval && val <= maxval) {\
                 phba->cfg_##attr = val;\
@@ -1276,7 +1345,7 @@ lpfc_##attr##_init(struct lpfc_hba *phba, int val) \
  **/
 #define lpfc_param_set(attr, default, minval, maxval)   \
 static int \
-lpfc_##attr##_set(struct lpfc_hba *phba, int val) \
+lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
 { \
         if (val >= minval && val <= maxval) {\
                 phba->cfg_##attr = val;\
@@ -1317,7 +1386,7 @@ lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
         struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
         struct lpfc_hba   *phba = vport->phba;\
-        int val=0;\
+        uint val = 0;\
         if (!isdigit(buf[0]))\
                 return -EINVAL;\
         if (sscanf(buf, "%i", &val) != 1)\
@@ -1349,7 +1418,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
 { \
         struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
-        int val = 0;\
+        uint val = 0;\
         val = vport->cfg_##attr;\
         return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
 }
@@ -1376,7 +1445,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
 { \
         struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
-        int val = 0;\
+        uint val = 0;\
         val = vport->cfg_##attr;\
         return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
 }
@@ -1401,7 +1470,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
  **/
 #define lpfc_vport_param_init(attr, default, minval, maxval)    \
 static int \
-lpfc_##attr##_init(struct lpfc_vport *vport, int val) \
+lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \
 { \
         if (val >= minval && val <= maxval) {\
                 vport->cfg_##attr = val;\
@@ -1433,7 +1502,7 @@ lpfc_##attr##_init(struct lpfc_vport *vport, int val) \
  **/
 #define lpfc_vport_param_set(attr, default, minval, maxval)     \
 static int \
-lpfc_##attr##_set(struct lpfc_vport *vport, int val) \
+lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
 { \
         if (val >= minval && val <= maxval) {\
                 vport->cfg_##attr = val;\
@@ -1469,7 +1538,7 @@ lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
 { \
         struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
-        int val=0;\
+        uint val = 0;\
         if (!isdigit(buf[0]))\
                 return -EINVAL;\
         if (sscanf(buf, "%i", &val) != 1)\
@@ -1482,22 +1551,22 @@ lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
 
 
 #define LPFC_ATTR(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_param_init(name, defval, minval, maxval)
 
 #define LPFC_ATTR_R(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_param_show(name)\
 lpfc_param_init(name, defval, minval, maxval)\
 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 
 #define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_param_show(name)\
 lpfc_param_init(name, defval, minval, maxval)\
@@ -1507,16 +1576,16 @@ static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
                    lpfc_##name##_show, lpfc_##name##_store)
 
 #define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_param_hex_show(name)\
 lpfc_param_init(name, defval, minval, maxval)\
 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 
 #define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_param_hex_show(name)\
 lpfc_param_init(name, defval, minval, maxval)\
@@ -1526,22 +1595,22 @@ static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
                    lpfc_##name##_show, lpfc_##name##_store)
 
 #define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_vport_param_init(name, defval, minval, maxval)
 
 #define LPFC_VPORT_ATTR_R(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_vport_param_show(name)\
 lpfc_vport_param_init(name, defval, minval, maxval)\
 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 
 #define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_vport_param_show(name)\
 lpfc_vport_param_init(name, defval, minval, maxval)\
@@ -1551,16 +1620,16 @@ static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
                    lpfc_##name##_show, lpfc_##name##_store)
 
 #define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_vport_param_hex_show(name)\
 lpfc_vport_param_init(name, defval, minval, maxval)\
 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 
 #define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_vport_param_hex_show(name)\
 lpfc_vport_param_init(name, defval, minval, maxval)\
@@ -1581,7 +1650,8 @@ static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
 static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
 static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
 static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
-static DEVICE_ATTR(link_state, S_IRUGO, lpfc_link_state_show, NULL);
+static DEVICE_ATTR(link_state, S_IRUGO | S_IWUSR, lpfc_link_state_show,
+                lpfc_link_state_store);
 static DEVICE_ATTR(option_rom_version, S_IRUGO,
                    lpfc_option_rom_version_show, NULL);
 static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
@@ -1589,6 +1659,7 @@ static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
 static DEVICE_ATTR(menlo_mgmt_mode, S_IRUGO, lpfc_mlomgmt_show, NULL);
 static DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
 static DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show, NULL);
+static DEVICE_ATTR(lpfc_enable_fip, S_IRUGO, lpfc_enable_fip_show, NULL);
 static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
                    lpfc_board_mode_show, lpfc_board_mode_store);
 static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
@@ -1863,6 +1934,17 @@ static DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO,
                          lpfc_enable_npiv_show, NULL);
 
 /*
+# lpfc_suppress_link_up:  Bring link up at initialization
+#            0x0  = bring link up (issue MBX_INIT_LINK)
+#            0x1  = do NOT bring link up at initialization(MBX_INIT_LINK)
+#            0x2  = never bring up link
+# Default value is 0.
+*/
+LPFC_ATTR_R(suppress_link_up, LPFC_INITIALIZE_LINK, LPFC_INITIALIZE_LINK,
+                LPFC_DELAY_INIT_LINK_INDEFINITELY,
+                "Suppress Link Up at initialization");
+
+/*
 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
 # until the timer expires. Value range is [0,255]. Default value is 30.
 */
@@ -1887,8 +1969,7 @@ lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
 {
         struct Scsi_Host  *shost = class_to_shost(dev);
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
-        int val = 0;
-        val = vport->cfg_devloss_tmo;
+
         return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo);
 }
 
@@ -2759,6 +2840,196 @@ static DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR,
                 lpfc_link_speed_show, lpfc_link_speed_store);
 
 /*
+# lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER)
+#       0  = aer disabled or not supported
+#       1  = aer supported and enabled (default)
+# Value range is [0,1]. Default value is 1.
+*/
+
+/**
+ * lpfc_aer_support_store - Set the adapter for aer support
+ *
+ * @dev: class device that is converted into a Scsi_host.
+ * @attr: device attribute, not used.
+ * @buf: containing the string "selective".
+ * @count: unused variable.
+ *
+ * Description:
+ * If the val is 1 and currently the device's AER capability was not
+ * enabled, invoke the kernel's enable AER helper routine, trying to
+ * enable the device's AER capability. If the helper routine enabling
+ * AER returns success, update the device's cfg_aer_support flag to
+ * indicate AER is supported by the device; otherwise, if the device
+ * AER capability is already enabled to support AER, then do nothing.
+ *
+ * If the val is 0 and currently the device's AER support was enabled,
+ * invoke the kernel's disable AER helper routine. After that, update
+ * the device's cfg_aer_support flag to indicate AER is not supported
+ * by the device; otherwise, if the device AER capability is already
+ * disabled from supporting AER, then do nothing.
+ *
+ * Returns:
+ * length of the buf on success if val is in range the intended mode
+ * is supported.
+ * -EINVAL if val out of range or intended mode is not supported.
+ **/
+static ssize_t
+lpfc_aer_support_store(struct device *dev, struct device_attribute *attr,
+                       const char *buf, size_t count)
+{
+        struct Scsi_Host *shost = class_to_shost(dev);
+        struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        int val = 0, rc = -EINVAL;
+
+        /* AER not supported on OC devices yet */
+        if (phba->pci_dev_grp == LPFC_PCI_DEV_OC)
+                return -EPERM;
+        if (!isdigit(buf[0]))
+                return -EINVAL;
+        if (sscanf(buf, "%i", &val) != 1)
+                return -EINVAL;
+
+        switch (val) {
+        case 0:
+                if (phba->hba_flag & HBA_AER_ENABLED) {
+                        rc = pci_disable_pcie_error_reporting(phba->pcidev);
+                        if (!rc) {
+                                spin_lock_irq(&phba->hbalock);
+                                phba->hba_flag &= ~HBA_AER_ENABLED;
+                                spin_unlock_irq(&phba->hbalock);
+                                phba->cfg_aer_support = 0;
+                                rc = strlen(buf);
+                        } else
+                                rc = -EPERM;
+                } else {
+                        phba->cfg_aer_support = 0;
+                        rc = strlen(buf);
+                }
+                break;
+        case 1:
+                if (!(phba->hba_flag & HBA_AER_ENABLED)) {
+                        rc = pci_enable_pcie_error_reporting(phba->pcidev);
+                        if (!rc) {
+                                spin_lock_irq(&phba->hbalock);
+                                phba->hba_flag |= HBA_AER_ENABLED;
+                                spin_unlock_irq(&phba->hbalock);
+                                phba->cfg_aer_support = 1;
+                                rc = strlen(buf);
+                        } else
+                                 rc = -EPERM;
+                } else {
+                        phba->cfg_aer_support = 1;
+                        rc = strlen(buf);
+                }
+                break;
+        default:
+                rc = -EINVAL;
+                break;
+        }
+        return rc;
+}
+
+static int lpfc_aer_support = 1;
+module_param(lpfc_aer_support, int, 1);
+MODULE_PARM_DESC(lpfc_aer_support, "Enable PCIe device AER support");
+lpfc_param_show(aer_support)
+
+/**
+ * lpfc_aer_support_init - Set the initial adapters aer support flag
+ * @phba: lpfc_hba pointer.
+ * @val: link speed value.
+ *
+ * Description:
+ * If val is in a valid range [0,1], then set the adapter's initial
+ * cfg_aer_support field. It will be up to the driver's probe_one
+ * routine to determine whether the device's AER support can be set
+ * or not.
+ *
+ * Notes:
+ * If the value is not in range log a kernel error message, and
+ * choose the default value of setting AER support and return.
+ *
+ * Returns:
+ * zero if val saved.
+ * -EINVAL val out of range
+ **/
+static int
+lpfc_aer_support_init(struct lpfc_hba *phba, int val)
+{
+        /* AER not supported on OC devices yet */
+        if (phba->pci_dev_grp == LPFC_PCI_DEV_OC) {
+                phba->cfg_aer_support = 0;
+                return -EPERM;
+        }
+
+        if (val == 0 || val == 1) {
+                phba->cfg_aer_support = val;
+                return 0;
+        }
+        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                        "2712 lpfc_aer_support attribute value %d out "
+                        "of range, allowed values are 0|1, setting it "
+                        "to default value of 1\n", val);
+        /* By default, try to enable AER on a device */
+        phba->cfg_aer_support = 1;
+        return -EINVAL;
+}
+
+static DEVICE_ATTR(lpfc_aer_support, S_IRUGO | S_IWUSR,
+                   lpfc_aer_support_show, lpfc_aer_support_store);
+
+/**
+ * lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device
+ * @dev: class device that is converted into a Scsi_host.
+ * @attr: device attribute, not used.
+ * @buf: containing the string "selective".
+ * @count: unused variable.
+ *
+ * Description:
+ * If the @buf contains 1 and the device currently has the AER support
+ * enabled, then invokes the kernel AER helper routine
+ * pci_cleanup_aer_uncorrect_error_status to clean up the uncorrectable
+ * error status register.
+ *
+ * Notes:
+ *
+ * Returns:
+ * -EINVAL if the buf does not contain the 1 or the device is not currently
+ * enabled with the AER support.
+ **/
+static ssize_t
+lpfc_aer_cleanup_state(struct device *dev, struct device_attribute *attr,
+                       const char *buf, size_t count)
+{
+        struct Scsi_Host  *shost = class_to_shost(dev);
+        struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
+        struct lpfc_hba   *phba = vport->phba;
+        int val, rc = -1;
+
+        /* AER not supported on OC devices yet */
+        if (phba->pci_dev_grp == LPFC_PCI_DEV_OC)
+                return -EPERM;
+        if (!isdigit(buf[0]))
+                return -EINVAL;
+        if (sscanf(buf, "%i", &val) != 1)
+                return -EINVAL;
+        if (val != 1)
+                return -EINVAL;
+
+        if (phba->hba_flag & HBA_AER_ENABLED)
+                rc = pci_cleanup_aer_uncorrect_error_status(phba->pcidev);
+
+        if (rc == 0)
+                return strlen(buf);
+        else
+                return -EPERM;
+}
+
+static DEVICE_ATTR(lpfc_aer_state_cleanup, S_IWUSR, NULL,
+                   lpfc_aer_cleanup_state);
+
+/*
 # lpfc_fcp_class:  Determines FC class to use for the FCP protocol.
 # Value range is [2,3]. Default value is 3.
 */
@@ -2846,7 +3117,7 @@ LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary "
 # identifies what rctl value to configure the additional ring for.
 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data).
 */
-LPFC_ATTR_R(multi_ring_rctl, FC_UNSOL_DATA, 1,
+LPFC_ATTR_R(multi_ring_rctl, FC_RCTL_DD_UNSOL_DATA, 1,
              255, "Identifies RCTL for additional ring configuration");
 
 /*
@@ -2854,7 +3125,7 @@ LPFC_ATTR_R(multi_ring_rctl, FC_UNSOL_DATA, 1,
 # identifies what type value to configure the additional ring for.
 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP).
 */
-LPFC_ATTR_R(multi_ring_type, FC_LLC_SNAP, 1,
+LPFC_ATTR_R(multi_ring_type, FC_TYPE_IP, 1,
              255, "Identifies TYPE for additional ring configuration");
 
 /*
@@ -2890,12 +3161,12 @@ LPFC_ATTR_RW(poll_tmo, 10, 1, 255,
 /*
 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
 #               support this feature
-#       0  = MSI disabled (default)
+#       0  = MSI disabled
 #       1  = MSI enabled
-#       2  = MSI-X enabled
-# Value range is [0,2]. Default value is 0.
+#       2  = MSI-X enabled (default)
+# Value range is [0,2]. Default value is 2.
 */
-LPFC_ATTR_R(use_msi, 0, 0, 2, "Use Message Signaled Interrupts (1) or "
+LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
             "MSI-X (2), if possible");
 
 /*
@@ -2947,15 +3218,6 @@ LPFC_ATTR_R(enable_hba_heartbeat, 1, 0, 1, "Enable HBA Heartbeat.");
 LPFC_ATTR_R(enable_bg, 0, 0, 1, "Enable BlockGuard Support");
 
 /*
-# lpfc_enable_fip: When set, FIP is required to start discovery. If not
-# set, the driver will add an FCF record manually if the port has no
-# FCF records available and start discovery.
-# Value range is [0,1]. Default value is 1 (enabled)
-*/
-LPFC_ATTR_RW(enable_fip, 0, 0, 1, "Enable FIP Discovery");
-
-
-/*
 # lpfc_prot_mask: i
 #       - Bit mask of host protection capabilities used to register with the
 #         SCSI mid-layer
@@ -3013,6 +3275,7 @@ struct device_attribute *lpfc_hba_attrs[] = {
         &dev_attr_num_discovered_ports,
         &dev_attr_menlo_mgmt_mode,
         &dev_attr_lpfc_drvr_version,
+        &dev_attr_lpfc_enable_fip,
         &dev_attr_lpfc_temp_sensor,
         &dev_attr_lpfc_log_verbose,
         &dev_attr_lpfc_lun_queue_depth,
@@ -3020,7 +3283,6 @@ struct device_attribute *lpfc_hba_attrs[] = {
         &dev_attr_lpfc_peer_port_login,
         &dev_attr_lpfc_nodev_tmo,
         &dev_attr_lpfc_devloss_tmo,
-        &dev_attr_lpfc_enable_fip,
         &dev_attr_lpfc_fcp_class,
         &dev_attr_lpfc_use_adisc,
         &dev_attr_lpfc_ack0,
@@ -3061,6 +3323,9 @@ struct device_attribute *lpfc_hba_attrs[] = {
         &dev_attr_lpfc_max_scsicmpl_time,
         &dev_attr_lpfc_stat_data_ctrl,
         &dev_attr_lpfc_prot_sg_seg_cnt,
+        &dev_attr_lpfc_aer_support,
+        &dev_attr_lpfc_aer_state_cleanup,
+        &dev_attr_lpfc_suppress_link_up,
         NULL,
 };
 
@@ -3073,7 +3338,6 @@ struct device_attribute *lpfc_vport_attrs[] = {
         &dev_attr_lpfc_lun_queue_depth,
         &dev_attr_lpfc_nodev_tmo,
         &dev_attr_lpfc_devloss_tmo,
-        &dev_attr_lpfc_enable_fip,
         &dev_attr_lpfc_hba_queue_depth,
         &dev_attr_lpfc_peer_port_login,
         &dev_attr_lpfc_restrict_login,
@@ -3147,7 +3411,7 @@ sysfs_ctlreg_write(struct kobject *kobj, struct bin_attribute *bin_attr,
  * sysfs_ctlreg_read - Read method for reading from ctlreg
  * @kobj: kernel kobject that contains the kernel class device.
  * @bin_attr: kernel attributes passed to us.
- * @buf: if succesful contains the data from the adapter IOREG space.
+ * @buf: if successful contains the data from the adapter IOREG space.
  * @off: offset into buffer to beginning of data.
  * @count: bytes to transfer.
  *
@@ -3815,7 +4079,11 @@ lpfc_get_stats(struct Scsi_Host *shost)
         hs->invalid_crc_count -= lso->invalid_crc_count;
         hs->error_frames -= lso->error_frames;
 
-        if (phba->fc_topology == TOPOLOGY_LOOP) {
+        if (phba->hba_flag & HBA_FCOE_SUPPORT) {
+                hs->lip_count = -1;
+                hs->nos_count = (phba->link_events >> 1);
+                hs->nos_count -= lso->link_events;
+        } else if (phba->fc_topology == TOPOLOGY_LOOP) {
                 hs->lip_count = (phba->fc_eventTag >> 1);
                 hs->lip_count -= lso->link_events;
                 hs->nos_count = -1;
@@ -3906,7 +4174,10 @@ lpfc_reset_stats(struct Scsi_Host *shost)
         lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
         lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
         lso->error_frames = pmb->un.varRdLnk.crcCnt;
-        lso->link_events = (phba->fc_eventTag >> 1);
+        if (phba->hba_flag & HBA_FCOE_SUPPORT)
+                lso->link_events = (phba->link_events >> 1);
+        else
+                lso->link_events = (phba->fc_eventTag >> 1);
 
         psli->stats_start = get_seconds();
 
@@ -4222,15 +4493,18 @@ lpfc_get_cfgparam(struct lpfc_hba *phba)
         lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
         lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
         lpfc_enable_bg_init(phba, lpfc_enable_bg);
+        if (phba->sli_rev == LPFC_SLI_REV4)
+                phba->cfg_poll = 0;
+        else
         phba->cfg_poll = lpfc_poll;
         phba->cfg_soft_wwnn = 0L;
         phba->cfg_soft_wwpn = 0L;
         lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
         lpfc_prot_sg_seg_cnt_init(phba, lpfc_prot_sg_seg_cnt);
         lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
-        lpfc_enable_fip_init(phba, lpfc_enable_fip);
         lpfc_hba_log_verbose_init(phba, lpfc_log_verbose);
-
+        lpfc_aer_support_init(phba, lpfc_aer_support);
+        lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up);
         return;
 }
 
diff --git a/drivers/scsi/lpfc/lpfc_bsg.c b/drivers/scsi/lpfc/lpfc_bsg.c
index da6bf5aac9dd..d62b3e467926 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.c
+++ b/drivers/scsi/lpfc/lpfc_bsg.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2009 Emulex.  All rights reserved.                *
+ * Copyright (C) 2009-2010 Emulex.  All rights reserved.                *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -21,17 +21,21 @@
 #include <linux/interrupt.h>
 #include <linux/mempool.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_transport_fc.h>
 #include <scsi/scsi_bsg_fc.h>
+#include <scsi/fc/fc_fs.h>
 
 #include "lpfc_hw4.h"
 #include "lpfc_hw.h"
 #include "lpfc_sli.h"
 #include "lpfc_sli4.h"
 #include "lpfc_nl.h"
+#include "lpfc_bsg.h"
 #include "lpfc_disc.h"
 #include "lpfc_scsi.h"
 #include "lpfc.h"
@@ -40,14 +44,196 @@
 #include "lpfc_vport.h"
 #include "lpfc_version.h"
 
+struct lpfc_bsg_event {
+        struct list_head node;
+        struct kref kref;
+        wait_queue_head_t wq;
+
+        /* Event type and waiter identifiers */
+        uint32_t type_mask;
+        uint32_t req_id;
+        uint32_t reg_id;
+
+        /* next two flags are here for the auto-delete logic */
+        unsigned long wait_time_stamp;
+        int waiting;
+
+        /* seen and not seen events */
+        struct list_head events_to_get;
+        struct list_head events_to_see;
+
+        /* job waiting for this event to finish */
+        struct fc_bsg_job *set_job;
+};
+
+struct lpfc_bsg_iocb {
+        struct lpfc_iocbq *cmdiocbq;
+        struct lpfc_iocbq *rspiocbq;
+        struct lpfc_dmabuf *bmp;
+        struct lpfc_nodelist *ndlp;
+
+        /* job waiting for this iocb to finish */
+        struct fc_bsg_job *set_job;
+};
+
+struct lpfc_bsg_mbox {
+        LPFC_MBOXQ_t *pmboxq;
+        MAILBOX_t *mb;
+
+        /* job waiting for this mbox command to finish */
+        struct fc_bsg_job *set_job;
+};
+
+#define MENLO_DID 0x0000FC0E
+
+struct lpfc_bsg_menlo {
+        struct lpfc_iocbq *cmdiocbq;
+        struct lpfc_iocbq *rspiocbq;
+        struct lpfc_dmabuf *bmp;
+
+        /* job waiting for this iocb to finish */
+        struct fc_bsg_job *set_job;
+};
+
+#define TYPE_EVT        1
+#define TYPE_IOCB       2
+#define TYPE_MBOX       3
+#define TYPE_MENLO      4
+struct bsg_job_data {
+        uint32_t type;
+        union {
+                struct lpfc_bsg_event *evt;
+                struct lpfc_bsg_iocb iocb;
+                struct lpfc_bsg_mbox mbox;
+                struct lpfc_bsg_menlo menlo;
+        } context_un;
+};
+
+struct event_data {
+        struct list_head node;
+        uint32_t type;
+        uint32_t immed_dat;
+        void *data;
+        uint32_t len;
+};
+
+#define BUF_SZ_4K 4096
+#define SLI_CT_ELX_LOOPBACK 0x10
+
+enum ELX_LOOPBACK_CMD {
+        ELX_LOOPBACK_XRI_SETUP,
+        ELX_LOOPBACK_DATA,
+};
+
+#define ELX_LOOPBACK_HEADER_SZ \
+        (size_t)(&((struct lpfc_sli_ct_request *)NULL)->un)
+
+struct lpfc_dmabufext {
+        struct lpfc_dmabuf dma;
+        uint32_t size;
+        uint32_t flag;
+};
+
+/**
+ * lpfc_bsg_send_mgmt_cmd_cmp - lpfc_bsg_send_mgmt_cmd's completion handler
+ * @phba: Pointer to HBA context object.
+ * @cmdiocbq: Pointer to command iocb.
+ * @rspiocbq: Pointer to response iocb.
+ *
+ * This function is the completion handler for iocbs issued using
+ * lpfc_bsg_send_mgmt_cmd function. This function is called by the
+ * ring event handler function without any lock held. This function
+ * can be called from both worker thread context and interrupt
+ * context. This function also can be called from another thread which
+ * cleans up the SLI layer objects.
+ * This function copies the contents of the response iocb to the
+ * response iocb memory object provided by the caller of
+ * lpfc_sli_issue_iocb_wait and then wakes up the thread which
+ * sleeps for the iocb completion.
+ **/
+static void
+lpfc_bsg_send_mgmt_cmd_cmp(struct lpfc_hba *phba,
+                        struct lpfc_iocbq *cmdiocbq,
+                        struct lpfc_iocbq *rspiocbq)
+{
+        unsigned long iflags;
+        struct bsg_job_data *dd_data;
+        struct fc_bsg_job *job;
+        IOCB_t *rsp;
+        struct lpfc_dmabuf *bmp;
+        struct lpfc_nodelist *ndlp;
+        struct lpfc_bsg_iocb *iocb;
+        unsigned long flags;
+        int rc = 0;
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        dd_data = cmdiocbq->context1;
+        if (!dd_data) {
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                return;
+        }
+
+        iocb = &dd_data->context_un.iocb;
+        job = iocb->set_job;
+        job->dd_data = NULL; /* so timeout handler does not reply */
+
+        spin_lock_irqsave(&phba->hbalock, iflags);
+        cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
+        if (cmdiocbq->context2 && rspiocbq)
+                memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
+                       &rspiocbq->iocb, sizeof(IOCB_t));
+        spin_unlock_irqrestore(&phba->hbalock, iflags);
+
+        bmp = iocb->bmp;
+        rspiocbq = iocb->rspiocbq;
+        rsp = &rspiocbq->iocb;
+        ndlp = iocb->ndlp;
+
+        pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
+                     job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
+                     job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+
+        if (rsp->ulpStatus) {
+                if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
+                        switch (rsp->un.ulpWord[4] & 0xff) {
+                        case IOERR_SEQUENCE_TIMEOUT:
+                                rc = -ETIMEDOUT;
+                                break;
+                        case IOERR_INVALID_RPI:
+                                rc = -EFAULT;
+                                break;
+                        default:
+                                rc = -EACCES;
+                                break;
+                        }
+                } else
+                        rc = -EACCES;
+        } else
+                job->reply->reply_payload_rcv_len =
+                        rsp->un.genreq64.bdl.bdeSize;
+
+        lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
+        lpfc_sli_release_iocbq(phba, rspiocbq);
+        lpfc_sli_release_iocbq(phba, cmdiocbq);
+        lpfc_nlp_put(ndlp);
+        kfree(bmp);
+        kfree(dd_data);
+        /* make error code available to userspace */
+        job->reply->result = rc;
+        /* complete the job back to userspace */
+        job->job_done(job);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+        return;
+}
+
 /**
- * lpfc_bsg_rport_ct - send a CT command from a bsg request
+ * lpfc_bsg_send_mgmt_cmd - send a CT command from a bsg request
  * @job: fc_bsg_job to handle
- */
+ **/
 static int
-lpfc_bsg_rport_ct(struct fc_bsg_job *job)
+lpfc_bsg_send_mgmt_cmd(struct fc_bsg_job *job)
 {
-        struct Scsi_Host *shost = job->shost;
         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
         struct lpfc_hba *phba = vport->phba;
         struct lpfc_rport_data *rdata = job->rport->dd_data;
@@ -64,57 +250,60 @@ lpfc_bsg_rport_ct(struct fc_bsg_job *job)
         struct scatterlist *sgel = NULL;
         int numbde;
         dma_addr_t busaddr;
+        struct bsg_job_data *dd_data;
+        uint32_t creg_val;
         int rc = 0;
 
         /* in case no data is transferred */
         job->reply->reply_payload_rcv_len = 0;
 
+        /* allocate our bsg tracking structure */
+        dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+        if (!dd_data) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2733 Failed allocation of dd_data\n");
+                rc = -ENOMEM;
+                goto no_dd_data;
+        }
+
         if (!lpfc_nlp_get(ndlp)) {
-                job->reply->result = -ENODEV;
-                return 0;
+                rc = -ENODEV;
+                goto no_ndlp;
+        }
+
+        bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
+        if (!bmp) {
+                rc = -ENOMEM;
+                goto free_ndlp;
         }
 
         if (ndlp->nlp_flag & NLP_ELS_SND_MASK) {
                 rc = -ENODEV;
-                goto free_ndlp_exit;
+                goto free_bmp;
         }
 
-        spin_lock_irq(shost->host_lock);
         cmdiocbq = lpfc_sli_get_iocbq(phba);
         if (!cmdiocbq) {
                 rc = -ENOMEM;
-                spin_unlock_irq(shost->host_lock);
-                goto free_ndlp_exit;
+                goto free_bmp;
         }
-        cmd = &cmdiocbq->iocb;
 
+        cmd = &cmdiocbq->iocb;
         rspiocbq = lpfc_sli_get_iocbq(phba);
         if (!rspiocbq) {
                 rc = -ENOMEM;
                 goto free_cmdiocbq;
         }
-        spin_unlock_irq(shost->host_lock);
 
         rsp = &rspiocbq->iocb;
-
-        bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
-        if (!bmp) {
-                rc = -ENOMEM;
-                spin_lock_irq(shost->host_lock);
-                goto free_rspiocbq;
-        }
-
-        spin_lock_irq(shost->host_lock);
         bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
         if (!bmp->virt) {
                 rc = -ENOMEM;
-                goto free_bmp;
+                goto free_rspiocbq;
         }
-        spin_unlock_irq(shost->host_lock);
 
         INIT_LIST_HEAD(&bmp->list);
         bpl = (struct ulp_bde64 *) bmp->virt;
-
         request_nseg = pci_map_sg(phba->pcidev, job->request_payload.sg_list,
                                   job->request_payload.sg_cnt, DMA_TO_DEVICE);
         for_each_sg(job->request_payload.sg_list, sgel, request_nseg, numbde) {
@@ -148,86 +337,160 @@ lpfc_bsg_rport_ct(struct fc_bsg_job *job)
         cmd->ulpCommand = CMD_GEN_REQUEST64_CR;
         cmd->un.genreq64.w5.hcsw.Fctl = (SI | LA);
         cmd->un.genreq64.w5.hcsw.Dfctl = 0;
-        cmd->un.genreq64.w5.hcsw.Rctl = FC_UNSOL_CTL;
-        cmd->un.genreq64.w5.hcsw.Type = FC_COMMON_TRANSPORT_ULP;
+        cmd->un.genreq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CTL;
+        cmd->un.genreq64.w5.hcsw.Type = FC_TYPE_CT;
         cmd->ulpBdeCount = 1;
         cmd->ulpLe = 1;
         cmd->ulpClass = CLASS3;
         cmd->ulpContext = ndlp->nlp_rpi;
         cmd->ulpOwner = OWN_CHIP;
         cmdiocbq->vport = phba->pport;
-        cmdiocbq->context1 = NULL;
-        cmdiocbq->context2 = NULL;
+        cmdiocbq->context3 = bmp;
         cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
-
         timeout = phba->fc_ratov * 2;
-        job->dd_data = cmdiocbq;
-
-        rc = lpfc_sli_issue_iocb_wait(phba, LPFC_ELS_RING, cmdiocbq, rspiocbq,
-                                        timeout + LPFC_DRVR_TIMEOUT);
-
-        if (rc != IOCB_TIMEDOUT) {
-                pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
-                             job->request_payload.sg_cnt, DMA_TO_DEVICE);
-                pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
-                             job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        cmd->ulpTimeout = timeout;
+
+        cmdiocbq->iocb_cmpl = lpfc_bsg_send_mgmt_cmd_cmp;
+        cmdiocbq->context1 = dd_data;
+        cmdiocbq->context2 = rspiocbq;
+        dd_data->type = TYPE_IOCB;
+        dd_data->context_un.iocb.cmdiocbq = cmdiocbq;
+        dd_data->context_un.iocb.rspiocbq = rspiocbq;
+        dd_data->context_un.iocb.set_job = job;
+        dd_data->context_un.iocb.bmp = bmp;
+        dd_data->context_un.iocb.ndlp = ndlp;
+
+        if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
+                creg_val = readl(phba->HCregaddr);
+                creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
+                writel(creg_val, phba->HCregaddr);
+                readl(phba->HCregaddr); /* flush */
         }
 
-        if (rc == IOCB_TIMEDOUT) {
-                lpfc_sli_release_iocbq(phba, rspiocbq);
-                rc = -EACCES;
-                goto free_ndlp_exit;
-        }
+        rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq, 0);
 
-        if (rc != IOCB_SUCCESS) {
-                rc = -EACCES;
-                goto free_outdmp;
-        }
+        if (rc == IOCB_SUCCESS)
+                return 0; /* done for now */
 
-        if (rsp->ulpStatus) {
-                if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
-                        switch (rsp->un.ulpWord[4] & 0xff) {
-                        case IOERR_SEQUENCE_TIMEOUT:
-                                rc = -ETIMEDOUT;
-                                break;
-                        case IOERR_INVALID_RPI:
-                                rc = -EFAULT;
-                                break;
-                        default:
-                                rc = -EACCES;
-                                break;
-                        }
-                        goto free_outdmp;
-                }
-        } else
-                job->reply->reply_payload_rcv_len =
-                        rsp->un.genreq64.bdl.bdeSize;
+        /* iocb failed so cleanup */
+        pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
+                     job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
+                     job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
 
-free_outdmp:
-        spin_lock_irq(shost->host_lock);
         lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
-free_bmp:
-        kfree(bmp);
+
 free_rspiocbq:
         lpfc_sli_release_iocbq(phba, rspiocbq);
 free_cmdiocbq:
         lpfc_sli_release_iocbq(phba, cmdiocbq);
-        spin_unlock_irq(shost->host_lock);
-free_ndlp_exit:
+free_bmp:
+        kfree(bmp);
+free_ndlp:
         lpfc_nlp_put(ndlp);
+no_ndlp:
+        kfree(dd_data);
+no_dd_data:
+        /* make error code available to userspace */
+        job->reply->result = rc;
+        job->dd_data = NULL;
+        return rc;
+}
 
+/**
+ * lpfc_bsg_rport_els_cmp - lpfc_bsg_rport_els's completion handler
+ * @phba: Pointer to HBA context object.
+ * @cmdiocbq: Pointer to command iocb.
+ * @rspiocbq: Pointer to response iocb.
+ *
+ * This function is the completion handler for iocbs issued using
+ * lpfc_bsg_rport_els_cmp function. This function is called by the
+ * ring event handler function without any lock held. This function
+ * can be called from both worker thread context and interrupt
+ * context. This function also can be called from other thread which
+ * cleans up the SLI layer objects.
+ * This function copies the contents of the response iocb to the
+ * response iocb memory object provided by the caller of
+ * lpfc_sli_issue_iocb_wait and then wakes up the thread which
+ * sleeps for the iocb completion.
+ **/
+static void
+lpfc_bsg_rport_els_cmp(struct lpfc_hba *phba,
+                        struct lpfc_iocbq *cmdiocbq,
+                        struct lpfc_iocbq *rspiocbq)
+{
+        struct bsg_job_data *dd_data;
+        struct fc_bsg_job *job;
+        IOCB_t *rsp;
+        struct lpfc_nodelist *ndlp;
+        struct lpfc_dmabuf *pbuflist = NULL;
+        struct fc_bsg_ctels_reply *els_reply;
+        uint8_t *rjt_data;
+        unsigned long flags;
+        int rc = 0;
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        dd_data = cmdiocbq->context1;
+        /* normal completion and timeout crossed paths, already done */
+        if (!dd_data) {
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                return;
+        }
+
+        cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
+        if (cmdiocbq->context2 && rspiocbq)
+                memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
+                       &rspiocbq->iocb, sizeof(IOCB_t));
+
+        job = dd_data->context_un.iocb.set_job;
+        cmdiocbq = dd_data->context_un.iocb.cmdiocbq;
+        rspiocbq = dd_data->context_un.iocb.rspiocbq;
+        rsp = &rspiocbq->iocb;
+        ndlp = dd_data->context_un.iocb.ndlp;
+
+        pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
+                     job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
+                     job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+
+        if (job->reply->result == -EAGAIN)
+                rc = -EAGAIN;
+        else if (rsp->ulpStatus == IOSTAT_SUCCESS)
+                job->reply->reply_payload_rcv_len =
+                        rsp->un.elsreq64.bdl.bdeSize;
+        else if (rsp->ulpStatus == IOSTAT_LS_RJT) {
+                job->reply->reply_payload_rcv_len =
+                        sizeof(struct fc_bsg_ctels_reply);
+                /* LS_RJT data returned in word 4 */
+                rjt_data = (uint8_t *)&rsp->un.ulpWord[4];
+                els_reply = &job->reply->reply_data.ctels_reply;
+                els_reply->status = FC_CTELS_STATUS_REJECT;
+                els_reply->rjt_data.action = rjt_data[3];
+                els_reply->rjt_data.reason_code = rjt_data[2];
+                els_reply->rjt_data.reason_explanation = rjt_data[1];
+                els_reply->rjt_data.vendor_unique = rjt_data[0];
+        } else
+                rc = -EIO;
+
+        pbuflist = (struct lpfc_dmabuf *) cmdiocbq->context3;
+        lpfc_mbuf_free(phba, pbuflist->virt, pbuflist->phys);
+        lpfc_sli_release_iocbq(phba, rspiocbq);
+        lpfc_sli_release_iocbq(phba, cmdiocbq);
+        lpfc_nlp_put(ndlp);
+        kfree(dd_data);
         /* make error code available to userspace */
         job->reply->result = rc;
+        job->dd_data = NULL;
         /* complete the job back to userspace */
         job->job_done(job);
-
-        return 0;
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+        return;
 }
 
 /**
  * lpfc_bsg_rport_els - send an ELS command from a bsg request
  * @job: fc_bsg_job to handle
- */
+ **/
 static int
 lpfc_bsg_rport_els(struct fc_bsg_job *job)
 {
@@ -235,7 +498,6 @@ lpfc_bsg_rport_els(struct fc_bsg_job *job)
         struct lpfc_hba *phba = vport->phba;
         struct lpfc_rport_data *rdata = job->rport->dd_data;
         struct lpfc_nodelist *ndlp = rdata->pnode;
-
         uint32_t elscmd;
         uint32_t cmdsize;
         uint32_t rspsize;
@@ -247,20 +509,30 @@ lpfc_bsg_rport_els(struct fc_bsg_job *job)
         struct lpfc_dmabuf *prsp;
         struct lpfc_dmabuf *pbuflist = NULL;
         struct ulp_bde64 *bpl;
-        int iocb_status;
         int request_nseg;
         int reply_nseg;
         struct scatterlist *sgel = NULL;
         int numbde;
         dma_addr_t busaddr;
+        struct bsg_job_data *dd_data;
+        uint32_t creg_val;
         int rc = 0;
 
         /* in case no data is transferred */
         job->reply->reply_payload_rcv_len = 0;
 
+        /* allocate our bsg tracking structure */
+        dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+        if (!dd_data) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2735 Failed allocation of dd_data\n");
+                rc = -ENOMEM;
+                goto no_dd_data;
+        }
+
         if (!lpfc_nlp_get(ndlp)) {
                 rc = -ENODEV;
-                goto out;
+                goto free_dd_data;
         }
 
         elscmd = job->request->rqst_data.r_els.els_code;
@@ -270,24 +542,24 @@ lpfc_bsg_rport_els(struct fc_bsg_job *job)
         if (!rspiocbq) {
                 lpfc_nlp_put(ndlp);
                 rc = -ENOMEM;
-                goto out;
+                goto free_dd_data;
         }
 
         rsp = &rspiocbq->iocb;
         rpi = ndlp->nlp_rpi;
 
-        cmdiocbq = lpfc_prep_els_iocb(phba->pport, 1, cmdsize, 0, ndlp,
+        cmdiocbq = lpfc_prep_els_iocb(vport, 1, cmdsize, 0, ndlp,
                                       ndlp->nlp_DID, elscmd);
-
         if (!cmdiocbq) {
-                lpfc_sli_release_iocbq(phba, rspiocbq);
-                return -EIO;
+                rc = -EIO;
+                goto free_rspiocbq;
         }
 
-        job->dd_data = cmdiocbq;
+        /* prep els iocb set context1 to the ndlp, context2 to the command
+         * dmabuf, context3 holds the data dmabuf
+         */
         pcmd = (struct lpfc_dmabuf *) cmdiocbq->context2;
         prsp = (struct lpfc_dmabuf *) pcmd->list.next;
-
         lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
         kfree(pcmd);
         lpfc_mbuf_free(phba, prsp->virt, prsp->phys);
@@ -299,7 +571,6 @@ lpfc_bsg_rport_els(struct fc_bsg_job *job)
 
         request_nseg = pci_map_sg(phba->pcidev, job->request_payload.sg_list,
                                   job->request_payload.sg_cnt, DMA_TO_DEVICE);
-
         for_each_sg(job->request_payload.sg_list, sgel, request_nseg, numbde) {
                 busaddr = sg_dma_address(sgel);
                 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
@@ -321,7 +592,6 @@ lpfc_bsg_rport_els(struct fc_bsg_job *job)
                 bpl->addrHigh = cpu_to_le32(putPaddrHigh(busaddr));
                 bpl++;
         }
-
         cmdiocbq->iocb.un.elsreq64.bdl.bdeSize =
                 (request_nseg + reply_nseg) * sizeof(struct ulp_bde64);
         cmdiocbq->iocb.ulpContext = rpi;
@@ -329,102 +599,62 @@ lpfc_bsg_rport_els(struct fc_bsg_job *job)
         cmdiocbq->context1 = NULL;
         cmdiocbq->context2 = NULL;
 
-        iocb_status = lpfc_sli_issue_iocb_wait(phba, LPFC_ELS_RING, cmdiocbq,
-                                        rspiocbq, (phba->fc_ratov * 2)
-                                               + LPFC_DRVR_TIMEOUT);
-
-        /* release the new ndlp once the iocb completes */
-        lpfc_nlp_put(ndlp);
-        if (iocb_status != IOCB_TIMEDOUT) {
-                pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
-                             job->request_payload.sg_cnt, DMA_TO_DEVICE);
-                pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
-                             job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        cmdiocbq->iocb_cmpl = lpfc_bsg_rport_els_cmp;
+        cmdiocbq->context1 = dd_data;
+        cmdiocbq->context2 = rspiocbq;
+        dd_data->type = TYPE_IOCB;
+        dd_data->context_un.iocb.cmdiocbq = cmdiocbq;
+        dd_data->context_un.iocb.rspiocbq = rspiocbq;
+        dd_data->context_un.iocb.set_job = job;
+        dd_data->context_un.iocb.bmp = NULL;;
+        dd_data->context_un.iocb.ndlp = ndlp;
+
+        if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
+                creg_val = readl(phba->HCregaddr);
+                creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
+                writel(creg_val, phba->HCregaddr);
+                readl(phba->HCregaddr); /* flush */
         }
+        rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq, 0);
+        lpfc_nlp_put(ndlp);
+        if (rc == IOCB_SUCCESS)
+                return 0; /* done for now */
 
-        if (iocb_status == IOCB_SUCCESS) {
-                if (rsp->ulpStatus == IOSTAT_SUCCESS) {
-                        job->reply->reply_payload_rcv_len =
-                                rsp->un.elsreq64.bdl.bdeSize;
-                        rc = 0;
-                } else if (rsp->ulpStatus == IOSTAT_LS_RJT) {
-                        struct fc_bsg_ctels_reply *els_reply;
-                        /* LS_RJT data returned in word 4 */
-                        uint8_t *rjt_data = (uint8_t *)&rsp->un.ulpWord[4];
-
-                        els_reply = &job->reply->reply_data.ctels_reply;
-                        job->reply->result = 0;
-                        els_reply->status = FC_CTELS_STATUS_REJECT;
-                        els_reply->rjt_data.action = rjt_data[0];
-                        els_reply->rjt_data.reason_code = rjt_data[1];
-                        els_reply->rjt_data.reason_explanation = rjt_data[2];
-                        els_reply->rjt_data.vendor_unique = rjt_data[3];
-                } else
-                        rc = -EIO;
-        } else
-                rc = -EIO;
+        pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
+                     job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
+                     job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
 
-        if (iocb_status != IOCB_TIMEDOUT)
-                lpfc_els_free_iocb(phba, cmdiocbq);
+        lpfc_mbuf_free(phba, pbuflist->virt, pbuflist->phys);
+
+        lpfc_sli_release_iocbq(phba, cmdiocbq);
 
+free_rspiocbq:
         lpfc_sli_release_iocbq(phba, rspiocbq);
 
-out:
+free_dd_data:
+        kfree(dd_data);
+
+no_dd_data:
         /* make error code available to userspace */
         job->reply->result = rc;
-        /* complete the job back to userspace */
-        job->job_done(job);
-
-        return 0;
-}
-
-struct lpfc_ct_event {
-        struct list_head node;
-        int ref;
-        wait_queue_head_t wq;
-
-        /* Event type and waiter identifiers */
-        uint32_t type_mask;
-        uint32_t req_id;
-        uint32_t reg_id;
-
-        /* next two flags are here for the auto-delete logic */
-        unsigned long wait_time_stamp;
-        int waiting;
-
-        /* seen and not seen events */
-        struct list_head events_to_get;
-        struct list_head events_to_see;
-};
-
-struct event_data {
-        struct list_head node;
-        uint32_t type;
-        uint32_t immed_dat;
-        void *data;
-        uint32_t len;
-};
-
-static struct lpfc_ct_event *
-lpfc_ct_event_new(int ev_reg_id, uint32_t ev_req_id)
-{
-        struct lpfc_ct_event *evt = kzalloc(sizeof(*evt), GFP_KERNEL);
-        if (!evt)
-                return NULL;
-
-        INIT_LIST_HEAD(&evt->events_to_get);
-        INIT_LIST_HEAD(&evt->events_to_see);
-        evt->req_id = ev_req_id;
-        evt->reg_id = ev_reg_id;
-        evt->wait_time_stamp = jiffies;
-        init_waitqueue_head(&evt->wq);
-
-        return evt;
+        job->dd_data = NULL;
+        return rc;
 }
 
+/**
+ * lpfc_bsg_event_free - frees an allocated event structure
+ * @kref: Pointer to a kref.
+ *
+ * Called from kref_put. Back cast the kref into an event structure address.
+ * Free any events to get, delete associated nodes, free any events to see,
+ * free any data then free the event itself.
+ **/
 static void
-lpfc_ct_event_free(struct lpfc_ct_event *evt)
+lpfc_bsg_event_free(struct kref *kref)
 {
+        struct lpfc_bsg_event *evt = container_of(kref, struct lpfc_bsg_event,
+                                                  kref);
         struct event_data *ed;
 
         list_del(&evt->node);
@@ -446,25 +676,82 @@ lpfc_ct_event_free(struct lpfc_ct_event *evt)
         kfree(evt);
 }
 
+/**
+ * lpfc_bsg_event_ref - increments the kref for an event
+ * @evt: Pointer to an event structure.
+ **/
 static inline void
-lpfc_ct_event_ref(struct lpfc_ct_event *evt)
+lpfc_bsg_event_ref(struct lpfc_bsg_event *evt)
 {
-        evt->ref++;
+        kref_get(&evt->kref);
 }
 
+/**
+ * lpfc_bsg_event_unref - Uses kref_put to free an event structure
+ * @evt: Pointer to an event structure.
+ **/
 static inline void
-lpfc_ct_event_unref(struct lpfc_ct_event *evt)
+lpfc_bsg_event_unref(struct lpfc_bsg_event *evt)
 {
-        if (--evt->ref < 0)
-                lpfc_ct_event_free(evt);
+        kref_put(&evt->kref, lpfc_bsg_event_free);
 }
 
-#define SLI_CT_ELX_LOOPBACK 0x10
+/**
+ * lpfc_bsg_event_new - allocate and initialize a event structure
+ * @ev_mask: Mask of events.
+ * @ev_reg_id: Event reg id.
+ * @ev_req_id: Event request id.
+ **/
+static struct lpfc_bsg_event *
+lpfc_bsg_event_new(uint32_t ev_mask, int ev_reg_id, uint32_t ev_req_id)
+{
+        struct lpfc_bsg_event *evt = kzalloc(sizeof(*evt), GFP_KERNEL);
 
-enum ELX_LOOPBACK_CMD {
-        ELX_LOOPBACK_XRI_SETUP,
-        ELX_LOOPBACK_DATA,
-};
+        if (!evt)
+                return NULL;
+
+        INIT_LIST_HEAD(&evt->events_to_get);
+        INIT_LIST_HEAD(&evt->events_to_see);
+        evt->type_mask = ev_mask;
+        evt->req_id = ev_req_id;
+        evt->reg_id = ev_reg_id;
+        evt->wait_time_stamp = jiffies;
+        init_waitqueue_head(&evt->wq);
+        kref_init(&evt->kref);
+        return evt;
+}
+
+/**
+ * diag_cmd_data_free - Frees an lpfc dma buffer extension
+ * @phba: Pointer to HBA context object.
+ * @mlist: Pointer to an lpfc dma buffer extension.
+ **/
+static int
+diag_cmd_data_free(struct lpfc_hba *phba, struct lpfc_dmabufext *mlist)
+{
+        struct lpfc_dmabufext *mlast;
+        struct pci_dev *pcidev;
+        struct list_head head, *curr, *next;
+
+        if ((!mlist) || (!lpfc_is_link_up(phba) &&
+                (phba->link_flag & LS_LOOPBACK_MODE))) {
+                return 0;
+        }
+
+        pcidev = phba->pcidev;
+        list_add_tail(&head, &mlist->dma.list);
+
+        list_for_each_safe(curr, next, &head) {
+                mlast = list_entry(curr, struct lpfc_dmabufext , dma.list);
+                if (mlast->dma.virt)
+                        dma_free_coherent(&pcidev->dev,
+                                          mlast->size,
+                                          mlast->dma.virt,
+                                          mlast->dma.phys);
+                kfree(mlast);
+        }
+        return 0;
+}
 
 /**
  * lpfc_bsg_ct_unsol_event - process an unsolicited CT command
@@ -473,9 +760,9 @@ enum ELX_LOOPBACK_CMD {
  * @piocbq:
  *
  * This function is called when an unsolicited CT command is received.  It
- * forwards the event to any processes registerd to receive CT events.
- */
-void
+ * forwards the event to any processes registered to receive CT events.
+ **/
+int
 lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                         struct lpfc_iocbq *piocbq)
 {
@@ -483,7 +770,7 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
         uint32_t cmd;
         uint32_t len;
         struct lpfc_dmabuf *dmabuf = NULL;
-        struct lpfc_ct_event *evt;
+        struct lpfc_bsg_event *evt;
         struct event_data *evt_dat = NULL;
         struct lpfc_iocbq *iocbq;
         size_t offset = 0;
@@ -495,6 +782,9 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
         struct lpfc_dmabuf *bdeBuf2 = piocbq->context3;
         struct lpfc_hbq_entry *hbqe;
         struct lpfc_sli_ct_request *ct_req;
+        struct fc_bsg_job *job = NULL;
+        unsigned long flags;
+        int size = 0;
 
         INIT_LIST_HEAD(&head);
         list_add_tail(&head, &piocbq->list);
@@ -503,6 +793,10 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
             piocbq->iocb.un.cont64[0].tus.f.bdeSize == 0)
                 goto error_ct_unsol_exit;
 
+        if (phba->link_state == LPFC_HBA_ERROR ||
+                (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE)))
+                goto error_ct_unsol_exit;
+
         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)
                 dmabuf = bdeBuf1;
         else {
@@ -510,7 +804,8 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                                     piocbq->iocb.un.cont64[0].addrLow);
                 dmabuf = lpfc_sli_ringpostbuf_get(phba, pring, dma_addr);
         }
-
+        if (dmabuf == NULL)
+                goto error_ct_unsol_exit;
         ct_req = (struct lpfc_sli_ct_request *)dmabuf->virt;
         evt_req_id = ct_req->FsType;
         cmd = ct_req->CommandResponse.bits.CmdRsp;
@@ -518,24 +813,24 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
         if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED))
                 lpfc_sli_ringpostbuf_put(phba, pring, dmabuf);
 
-        mutex_lock(&phba->ct_event_mutex);
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
         list_for_each_entry(evt, &phba->ct_ev_waiters, node) {
-                if (evt->req_id != evt_req_id)
+                if (!(evt->type_mask & FC_REG_CT_EVENT) ||
+                        evt->req_id != evt_req_id)
                         continue;
 
-                lpfc_ct_event_ref(evt);
-
+                lpfc_bsg_event_ref(evt);
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
                 evt_dat = kzalloc(sizeof(*evt_dat), GFP_KERNEL);
-                if (!evt_dat) {
-                        lpfc_ct_event_unref(evt);
+                if (evt_dat == NULL) {
+                        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+                        lpfc_bsg_event_unref(evt);
                         lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
                                         "2614 Memory allocation failed for "
                                         "CT event\n");
                         break;
                 }
 
-                mutex_unlock(&phba->ct_event_mutex);
-
                 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
                         /* take accumulated byte count from the last iocbq */
                         iocbq = list_entry(head.prev, typeof(*iocbq), list);
@@ -549,25 +844,25 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                 }
 
                 evt_dat->data = kzalloc(evt_dat->len, GFP_KERNEL);
-                if (!evt_dat->data) {
+                if (evt_dat->data == NULL) {
                         lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
                                         "2615 Memory allocation failed for "
                                         "CT event data, size %d\n",
                                         evt_dat->len);
                         kfree(evt_dat);
-                        mutex_lock(&phba->ct_event_mutex);
-                        lpfc_ct_event_unref(evt);
-                        mutex_unlock(&phba->ct_event_mutex);
+                        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+                        lpfc_bsg_event_unref(evt);
+                        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
                         goto error_ct_unsol_exit;
                 }
 
                 list_for_each_entry(iocbq, &head, list) {
+                        size = 0;
                         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
                                 bdeBuf1 = iocbq->context2;
                                 bdeBuf2 = iocbq->context3;
                         }
                         for (i = 0; i < iocbq->iocb.ulpBdeCount; i++) {
-                                int size = 0;
                                 if (phba->sli3_options &
                                     LPFC_SLI3_HBQ_ENABLED) {
                                         if (i == 0) {
@@ -600,9 +895,11 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                                                 iocbq);
                                         kfree(evt_dat->data);
                                         kfree(evt_dat);
-                                        mutex_lock(&phba->ct_event_mutex);
-                                        lpfc_ct_event_unref(evt);
-                                        mutex_unlock(&phba->ct_event_mutex);
+                                        spin_lock_irqsave(&phba->ct_ev_lock,
+                                                flags);
+                                        lpfc_bsg_event_unref(evt);
+                                        spin_unlock_irqrestore(
+                                                &phba->ct_ev_lock, flags);
                                         goto error_ct_unsol_exit;
                                 }
                                 memcpy((char *)(evt_dat->data) + offset,
@@ -615,15 +912,24 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                                                                  dmabuf);
                                 } else {
                                         switch (cmd) {
+                                        case ELX_LOOPBACK_DATA:
+                                                diag_cmd_data_free(phba,
+                                                (struct lpfc_dmabufext *)
+                                                        dmabuf);
+                                                break;
                                         case ELX_LOOPBACK_XRI_SETUP:
-                                                if (!(phba->sli3_options &
-                                                      LPFC_SLI3_HBQ_ENABLED))
+                                                if ((phba->sli_rev ==
+                                                        LPFC_SLI_REV2) ||
+                                                        (phba->sli3_options &
+                                                        LPFC_SLI3_HBQ_ENABLED
+                                                        )) {
+                                                        lpfc_in_buf_free(phba,
+                                                                        dmabuf);
+                                                } else {
                                                         lpfc_post_buffer(phba,
                                                                          pring,
                                                                          1);
-                                                else
-                                                        lpfc_in_buf_free(phba,
-                                                                        dmabuf);
+                                                }
                                                 break;
                                         default:
                                                 if (!(phba->sli3_options &
@@ -637,7 +943,7 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                         }
                 }
 
-                mutex_lock(&phba->ct_event_mutex);
+                spin_lock_irqsave(&phba->ct_ev_lock, flags);
                 if (phba->sli_rev == LPFC_SLI_REV4) {
                         evt_dat->immed_dat = phba->ctx_idx;
                         phba->ctx_idx = (phba->ctx_idx + 1) % 64;
@@ -650,122 +956,144 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
 
                 evt_dat->type = FC_REG_CT_EVENT;
                 list_add(&evt_dat->node, &evt->events_to_see);
-                wake_up_interruptible(&evt->wq);
-                lpfc_ct_event_unref(evt);
-                if (evt_req_id == SLI_CT_ELX_LOOPBACK)
+                if (evt_req_id == SLI_CT_ELX_LOOPBACK) {
+                        wake_up_interruptible(&evt->wq);
+                        lpfc_bsg_event_unref(evt);
                         break;
+                }
+
+                list_move(evt->events_to_see.prev, &evt->events_to_get);
+                lpfc_bsg_event_unref(evt);
+
+                job = evt->set_job;
+                evt->set_job = NULL;
+                if (job) {
+                        job->reply->reply_payload_rcv_len = size;
+                        /* make error code available to userspace */
+                        job->reply->result = 0;
+                        job->dd_data = NULL;
+                        /* complete the job back to userspace */
+                        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                        job->job_done(job);
+                        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+                }
         }
-        mutex_unlock(&phba->ct_event_mutex);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
 
 error_ct_unsol_exit:
         if (!list_empty(&head))
                 list_del(&head);
-
-        return;
+        if (evt_req_id == SLI_CT_ELX_LOOPBACK)
+                return 0;
+        return 1;
 }
 
 /**
- * lpfc_bsg_set_event - process a SET_EVENT bsg vendor command
+ * lpfc_bsg_hba_set_event - process a SET_EVENT bsg vendor command
  * @job: SET_EVENT fc_bsg_job
- */
+ **/
 static int
-lpfc_bsg_set_event(struct fc_bsg_job *job)
+lpfc_bsg_hba_set_event(struct fc_bsg_job *job)
 {
         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
         struct lpfc_hba *phba = vport->phba;
         struct set_ct_event *event_req;
-        struct lpfc_ct_event *evt;
+        struct lpfc_bsg_event *evt;
         int rc = 0;
+        struct bsg_job_data *dd_data = NULL;
+        uint32_t ev_mask;
+        unsigned long flags;
 
         if (job->request_len <
             sizeof(struct fc_bsg_request) + sizeof(struct set_ct_event)) {
                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
                                 "2612 Received SET_CT_EVENT below minimum "
                                 "size\n");
-                return -EINVAL;
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+        if (dd_data == NULL) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2734 Failed allocation of dd_data\n");
+                rc = -ENOMEM;
+                goto job_error;
         }
 
         event_req = (struct set_ct_event *)
                 job->request->rqst_data.h_vendor.vendor_cmd;
-
-        mutex_lock(&phba->ct_event_mutex);
+        ev_mask = ((uint32_t)(unsigned long)event_req->type_mask &
+                                FC_REG_EVENT_MASK);
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
         list_for_each_entry(evt, &phba->ct_ev_waiters, node) {
                 if (evt->reg_id == event_req->ev_reg_id) {
-                        lpfc_ct_event_ref(evt);
+                        lpfc_bsg_event_ref(evt);
                         evt->wait_time_stamp = jiffies;
                         break;
                 }
         }
-        mutex_unlock(&phba->ct_event_mutex);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
 
         if (&evt->node == &phba->ct_ev_waiters) {
                 /* no event waiting struct yet - first call */
-                evt = lpfc_ct_event_new(event_req->ev_reg_id,
+                evt = lpfc_bsg_event_new(ev_mask, event_req->ev_reg_id,
                                         event_req->ev_req_id);
                 if (!evt) {
                         lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
                                         "2617 Failed allocation of event "
                                         "waiter\n");
-                        return -ENOMEM;
+                        rc = -ENOMEM;
+                        goto job_error;
                 }
 
-                mutex_lock(&phba->ct_event_mutex);
+                spin_lock_irqsave(&phba->ct_ev_lock, flags);
                 list_add(&evt->node, &phba->ct_ev_waiters);
-                lpfc_ct_event_ref(evt);
-                mutex_unlock(&phba->ct_event_mutex);
+                lpfc_bsg_event_ref(evt);
+                evt->wait_time_stamp = jiffies;
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
         }
 
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
         evt->waiting = 1;
-        if (wait_event_interruptible(evt->wq,
-                                     !list_empty(&evt->events_to_see))) {
-                mutex_lock(&phba->ct_event_mutex);
-                lpfc_ct_event_unref(evt); /* release ref */
-                lpfc_ct_event_unref(evt); /* delete */
-                mutex_unlock(&phba->ct_event_mutex);
-                rc = -EINTR;
-                goto set_event_out;
-        }
-
-        evt->wait_time_stamp = jiffies;
-        evt->waiting = 0;
-
-        mutex_lock(&phba->ct_event_mutex);
-        list_move(evt->events_to_see.prev, &evt->events_to_get);
-        lpfc_ct_event_unref(evt); /* release ref */
-        mutex_unlock(&phba->ct_event_mutex);
-
-set_event_out:
-        /* set_event carries no reply payload */
-        job->reply->reply_payload_rcv_len = 0;
-        /* make error code available to userspace */
-        job->reply->result = rc;
-        /* complete the job back to userspace */
-        job->job_done(job);
-
-        return 0;
+        dd_data->type = TYPE_EVT;
+        dd_data->context_un.evt = evt;
+        evt->set_job = job; /* for unsolicited command */
+        job->dd_data = dd_data; /* for fc transport timeout callback*/
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+        return 0; /* call job done later */
+
+job_error:
+        if (dd_data != NULL)
+                kfree(dd_data);
+
+        job->dd_data = NULL;
+        return rc;
 }
 
 /**
- * lpfc_bsg_get_event - process a GET_EVENT bsg vendor command
+ * lpfc_bsg_hba_get_event - process a GET_EVENT bsg vendor command
  * @job: GET_EVENT fc_bsg_job
- */
+ **/
 static int
-lpfc_bsg_get_event(struct fc_bsg_job *job)
+lpfc_bsg_hba_get_event(struct fc_bsg_job *job)
 {
         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
         struct lpfc_hba *phba = vport->phba;
         struct get_ct_event *event_req;
         struct get_ct_event_reply *event_reply;
-        struct lpfc_ct_event *evt;
+        struct lpfc_bsg_event *evt;
         struct event_data *evt_dat = NULL;
-        int rc = 0;
+        unsigned long flags;
+        uint32_t rc = 0;
 
         if (job->request_len <
             sizeof(struct fc_bsg_request) + sizeof(struct get_ct_event)) {
                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
                                 "2613 Received GET_CT_EVENT request below "
                                 "minimum size\n");
-                return -EINVAL;
+                rc = -EINVAL;
+                goto job_error;
         }
 
         event_req = (struct get_ct_event *)
@@ -773,13 +1101,12 @@ lpfc_bsg_get_event(struct fc_bsg_job *job)
 
         event_reply = (struct get_ct_event_reply *)
                 job->reply->reply_data.vendor_reply.vendor_rsp;
-
-        mutex_lock(&phba->ct_event_mutex);
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
         list_for_each_entry(evt, &phba->ct_ev_waiters, node) {
                 if (evt->reg_id == event_req->ev_reg_id) {
                         if (list_empty(&evt->events_to_get))
                                 break;
-                        lpfc_ct_event_ref(evt);
+                        lpfc_bsg_event_ref(evt);
                         evt->wait_time_stamp = jiffies;
                         evt_dat = list_entry(evt->events_to_get.prev,
                                              struct event_data, node);
@@ -787,84 +1114,1904 @@ lpfc_bsg_get_event(struct fc_bsg_job *job)
                         break;
                 }
         }
-        mutex_unlock(&phba->ct_event_mutex);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
 
-        if (!evt_dat) {
+        /* The app may continue to ask for event data until it gets
+         * an error indicating that there isn't anymore
+         */
+        if (evt_dat == NULL) {
                 job->reply->reply_payload_rcv_len = 0;
                 rc = -ENOENT;
-                goto error_get_event_exit;
+                goto job_error;
         }
 
-        if (evt_dat->len > job->reply_payload.payload_len) {
-                evt_dat->len = job->reply_payload.payload_len;
-                        lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
-                                        "2618 Truncated event data at %d "
-                                        "bytes\n",
-                                        job->reply_payload.payload_len);
+        if (evt_dat->len > job->request_payload.payload_len) {
+                evt_dat->len = job->request_payload.payload_len;
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2618 Truncated event data at %d "
+                                "bytes\n",
+                                job->request_payload.payload_len);
         }
 
+        event_reply->type = evt_dat->type;
         event_reply->immed_data = evt_dat->immed_dat;
-
         if (evt_dat->len > 0)
                 job->reply->reply_payload_rcv_len =
-                        sg_copy_from_buffer(job->reply_payload.sg_list,
-                                            job->reply_payload.sg_cnt,
+                        sg_copy_from_buffer(job->request_payload.sg_list,
+                                            job->request_payload.sg_cnt,
                                             evt_dat->data, evt_dat->len);
         else
                 job->reply->reply_payload_rcv_len = 0;
-        rc = 0;
 
-        if (evt_dat)
+        if (evt_dat) {
                 kfree(evt_dat->data);
-        kfree(evt_dat);
-        mutex_lock(&phba->ct_event_mutex);
-        lpfc_ct_event_unref(evt);
-        mutex_unlock(&phba->ct_event_mutex);
+                kfree(evt_dat);
+        }
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        lpfc_bsg_event_unref(evt);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+        job->dd_data = NULL;
+        job->reply->result = 0;
+        job->job_done(job);
+        return 0;
+
+job_error:
+        job->dd_data = NULL;
+        job->reply->result = rc;
+        return rc;
+}
+
+/**
+ * lpfc_issue_ct_rsp_cmp - lpfc_issue_ct_rsp's completion handler
+ * @phba: Pointer to HBA context object.
+ * @cmdiocbq: Pointer to command iocb.
+ * @rspiocbq: Pointer to response iocb.
+ *
+ * This function is the completion handler for iocbs issued using
+ * lpfc_issue_ct_rsp_cmp function. This function is called by the
+ * ring event handler function without any lock held. This function
+ * can be called from both worker thread context and interrupt
+ * context. This function also can be called from other thread which
+ * cleans up the SLI layer objects.
+ * This function copy the contents of the response iocb to the
+ * response iocb memory object provided by the caller of
+ * lpfc_sli_issue_iocb_wait and then wakes up the thread which
+ * sleeps for the iocb completion.
+ **/
+static void
+lpfc_issue_ct_rsp_cmp(struct lpfc_hba *phba,
+                        struct lpfc_iocbq *cmdiocbq,
+                        struct lpfc_iocbq *rspiocbq)
+{
+        struct bsg_job_data *dd_data;
+        struct fc_bsg_job *job;
+        IOCB_t *rsp;
+        struct lpfc_dmabuf *bmp;
+        struct lpfc_nodelist *ndlp;
+        unsigned long flags;
+        int rc = 0;
 
-error_get_event_exit:
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        dd_data = cmdiocbq->context1;
+        /* normal completion and timeout crossed paths, already done */
+        if (!dd_data) {
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                return;
+        }
+
+        job = dd_data->context_un.iocb.set_job;
+        bmp = dd_data->context_un.iocb.bmp;
+        rsp = &rspiocbq->iocb;
+        ndlp = dd_data->context_un.iocb.ndlp;
+
+        pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
+                     job->request_payload.sg_cnt, DMA_TO_DEVICE);
+
+        if (rsp->ulpStatus) {
+                if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
+                        switch (rsp->un.ulpWord[4] & 0xff) {
+                        case IOERR_SEQUENCE_TIMEOUT:
+                                rc = -ETIMEDOUT;
+                                break;
+                        case IOERR_INVALID_RPI:
+                                rc = -EFAULT;
+                                break;
+                        default:
+                                rc = -EACCES;
+                                break;
+                        }
+                } else
+                        rc = -EACCES;
+        } else
+                job->reply->reply_payload_rcv_len =
+                        rsp->un.genreq64.bdl.bdeSize;
+
+        lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
+        lpfc_sli_release_iocbq(phba, cmdiocbq);
+        lpfc_nlp_put(ndlp);
+        kfree(bmp);
+        kfree(dd_data);
         /* make error code available to userspace */
         job->reply->result = rc;
+        job->dd_data = NULL;
         /* complete the job back to userspace */
         job->job_done(job);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+        return;
+}
 
+/**
+ * lpfc_issue_ct_rsp - issue a ct response
+ * @phba: Pointer to HBA context object.
+ * @job: Pointer to the job object.
+ * @tag: tag index value into the ports context exchange array.
+ * @bmp: Pointer to a dma buffer descriptor.
+ * @num_entry: Number of enties in the bde.
+ **/
+static int
+lpfc_issue_ct_rsp(struct lpfc_hba *phba, struct fc_bsg_job *job, uint32_t tag,
+                  struct lpfc_dmabuf *bmp, int num_entry)
+{
+        IOCB_t *icmd;
+        struct lpfc_iocbq *ctiocb = NULL;
+        int rc = 0;
+        struct lpfc_nodelist *ndlp = NULL;
+        struct bsg_job_data *dd_data;
+        uint32_t creg_val;
+
+        /* allocate our bsg tracking structure */
+        dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+        if (!dd_data) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2736 Failed allocation of dd_data\n");
+                rc = -ENOMEM;
+                goto no_dd_data;
+        }
+
+        /* Allocate buffer for  command iocb */
+        ctiocb = lpfc_sli_get_iocbq(phba);
+        if (!ctiocb) {
+                rc = ENOMEM;
+                goto no_ctiocb;
+        }
+
+        icmd = &ctiocb->iocb;
+        icmd->un.xseq64.bdl.ulpIoTag32 = 0;
+        icmd->un.xseq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
+        icmd->un.xseq64.bdl.addrLow = putPaddrLow(bmp->phys);
+        icmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
+        icmd->un.xseq64.bdl.bdeSize = (num_entry * sizeof(struct ulp_bde64));
+        icmd->un.xseq64.w5.hcsw.Fctl = (LS | LA);
+        icmd->un.xseq64.w5.hcsw.Dfctl = 0;
+        icmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_DD_SOL_CTL;
+        icmd->un.xseq64.w5.hcsw.Type = FC_TYPE_CT;
+
+        /* Fill in rest of iocb */
+        icmd->ulpCommand = CMD_XMIT_SEQUENCE64_CX;
+        icmd->ulpBdeCount = 1;
+        icmd->ulpLe = 1;
+        icmd->ulpClass = CLASS3;
+        if (phba->sli_rev == LPFC_SLI_REV4) {
+                /* Do not issue unsol response if oxid not marked as valid */
+                if (!(phba->ct_ctx[tag].flags & UNSOL_VALID)) {
+                        rc = IOCB_ERROR;
+                        goto issue_ct_rsp_exit;
+                }
+                icmd->ulpContext = phba->ct_ctx[tag].oxid;
+                ndlp = lpfc_findnode_did(phba->pport, phba->ct_ctx[tag].SID);
+                if (!ndlp) {
+                        lpfc_printf_log(phba, KERN_WARNING, LOG_ELS,
+                                 "2721 ndlp null for oxid %x SID %x\n",
+                                        icmd->ulpContext,
+                                        phba->ct_ctx[tag].SID);
+                        rc = IOCB_ERROR;
+                        goto issue_ct_rsp_exit;
+                }
+                icmd->un.ulpWord[3] = ndlp->nlp_rpi;
+                /* The exchange is done, mark the entry as invalid */
+                phba->ct_ctx[tag].flags &= ~UNSOL_VALID;
+        } else
+                icmd->ulpContext = (ushort) tag;
+
+        icmd->ulpTimeout = phba->fc_ratov * 2;
+
+        /* Xmit CT response on exchange <xid> */
+        lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
+                        "2722 Xmit CT response on exchange x%x Data: x%x x%x\n",
+                        icmd->ulpContext, icmd->ulpIoTag, phba->link_state);
+
+        ctiocb->iocb_cmpl = NULL;
+        ctiocb->iocb_flag |= LPFC_IO_LIBDFC;
+        ctiocb->vport = phba->pport;
+        ctiocb->context3 = bmp;
+
+        ctiocb->iocb_cmpl = lpfc_issue_ct_rsp_cmp;
+        ctiocb->context1 = dd_data;
+        ctiocb->context2 = NULL;
+        dd_data->type = TYPE_IOCB;
+        dd_data->context_un.iocb.cmdiocbq = ctiocb;
+        dd_data->context_un.iocb.rspiocbq = NULL;
+        dd_data->context_un.iocb.set_job = job;
+        dd_data->context_un.iocb.bmp = bmp;
+        dd_data->context_un.iocb.ndlp = ndlp;
+
+        if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
+                creg_val = readl(phba->HCregaddr);
+                creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
+                writel(creg_val, phba->HCregaddr);
+                readl(phba->HCregaddr); /* flush */
+        }
+
+        rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, ctiocb, 0);
+
+        if (rc == IOCB_SUCCESS)
+                return 0; /* done for now */
+
+issue_ct_rsp_exit:
+        lpfc_sli_release_iocbq(phba, ctiocb);
+no_ctiocb:
+        kfree(dd_data);
+no_dd_data:
         return rc;
 }
 
 /**
+ * lpfc_bsg_send_mgmt_rsp - process a SEND_MGMT_RESP bsg vendor command
+ * @job: SEND_MGMT_RESP fc_bsg_job
+ **/
+static int
+lpfc_bsg_send_mgmt_rsp(struct fc_bsg_job *job)
+{
+        struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        struct send_mgmt_resp *mgmt_resp = (struct send_mgmt_resp *)
+                job->request->rqst_data.h_vendor.vendor_cmd;
+        struct ulp_bde64 *bpl;
+        struct lpfc_dmabuf *bmp = NULL;
+        struct scatterlist *sgel = NULL;
+        int request_nseg;
+        int numbde;
+        dma_addr_t busaddr;
+        uint32_t tag = mgmt_resp->tag;
+        unsigned long reqbfrcnt =
+                        (unsigned long)job->request_payload.payload_len;
+        int rc = 0;
+
+        /* in case no data is transferred */
+        job->reply->reply_payload_rcv_len = 0;
+
+        if (!reqbfrcnt || (reqbfrcnt > (80 * BUF_SZ_4K))) {
+                rc = -ERANGE;
+                goto send_mgmt_rsp_exit;
+        }
+
+        bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
+        if (!bmp) {
+                rc = -ENOMEM;
+                goto send_mgmt_rsp_exit;
+        }
+
+        bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
+        if (!bmp->virt) {
+                rc = -ENOMEM;
+                goto send_mgmt_rsp_free_bmp;
+        }
+
+        INIT_LIST_HEAD(&bmp->list);
+        bpl = (struct ulp_bde64 *) bmp->virt;
+        request_nseg = pci_map_sg(phba->pcidev, job->request_payload.sg_list,
+                                  job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        for_each_sg(job->request_payload.sg_list, sgel, request_nseg, numbde) {
+                busaddr = sg_dma_address(sgel);
+                bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
+                bpl->tus.f.bdeSize = sg_dma_len(sgel);
+                bpl->tus.w = cpu_to_le32(bpl->tus.w);
+                bpl->addrLow = cpu_to_le32(putPaddrLow(busaddr));
+                bpl->addrHigh = cpu_to_le32(putPaddrHigh(busaddr));
+                bpl++;
+        }
+
+        rc = lpfc_issue_ct_rsp(phba, job, tag, bmp, request_nseg);
+
+        if (rc == IOCB_SUCCESS)
+                return 0; /* done for now */
+
+        /* TBD need to handle a timeout */
+        pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
+                          job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        rc = -EACCES;
+        lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
+
+send_mgmt_rsp_free_bmp:
+        kfree(bmp);
+send_mgmt_rsp_exit:
+        /* make error code available to userspace */
+        job->reply->result = rc;
+        job->dd_data = NULL;
+        return rc;
+}
+
+/**
+ * lpfc_bsg_diag_mode - process a LPFC_BSG_VENDOR_DIAG_MODE bsg vendor command
+ * @job: LPFC_BSG_VENDOR_DIAG_MODE
+ *
+ * This function is responsible for placing a port into diagnostic loopback
+ * mode in order to perform a diagnostic loopback test.
+ * All new scsi requests are blocked, a small delay is used to allow the
+ * scsi requests to complete then the link is brought down. If the link is
+ * is placed in loopback mode then scsi requests are again allowed
+ * so the scsi mid-layer doesn't give up on the port.
+ * All of this is done in-line.
+ */
+static int
+lpfc_bsg_diag_mode(struct fc_bsg_job *job)
+{
+        struct Scsi_Host *shost = job->shost;
+        struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        struct diag_mode_set *loopback_mode;
+        struct lpfc_sli *psli = &phba->sli;
+        struct lpfc_sli_ring *pring = &psli->ring[LPFC_FCP_RING];
+        uint32_t link_flags;
+        uint32_t timeout;
+        struct lpfc_vport **vports;
+        LPFC_MBOXQ_t *pmboxq;
+        int mbxstatus;
+        int i = 0;
+        int rc = 0;
+
+        /* no data to return just the return code */
+        job->reply->reply_payload_rcv_len = 0;
+
+        if (job->request_len <
+            sizeof(struct fc_bsg_request) + sizeof(struct diag_mode_set)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2738 Received DIAG MODE request below minimum "
+                                "size\n");
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        loopback_mode = (struct diag_mode_set *)
+                job->request->rqst_data.h_vendor.vendor_cmd;
+        link_flags = loopback_mode->type;
+        timeout = loopback_mode->timeout;
+
+        if ((phba->link_state == LPFC_HBA_ERROR) ||
+            (psli->sli_flag & LPFC_BLOCK_MGMT_IO) ||
+            (!(psli->sli_flag & LPFC_SLI_ACTIVE))) {
+                rc = -EACCES;
+                goto job_error;
+        }
+
+        pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmboxq) {
+                rc = -ENOMEM;
+                goto job_error;
+        }
+
+        vports = lpfc_create_vport_work_array(phba);
+        if (vports) {
+                for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
+                        shost = lpfc_shost_from_vport(vports[i]);
+                        scsi_block_requests(shost);
+                }
+
+                lpfc_destroy_vport_work_array(phba, vports);
+        } else {
+                shost = lpfc_shost_from_vport(phba->pport);
+                scsi_block_requests(shost);
+        }
+
+        while (pring->txcmplq_cnt) {
+                if (i++ > 500)  /* wait up to 5 seconds */
+                        break;
+
+                msleep(10);
+        }
+
+        memset((void *)pmboxq, 0, sizeof(LPFC_MBOXQ_t));
+        pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
+        pmboxq->u.mb.mbxOwner = OWN_HOST;
+
+        mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO);
+
+        if ((mbxstatus == MBX_SUCCESS) && (pmboxq->u.mb.mbxStatus == 0)) {
+                /* wait for link down before proceeding */
+                i = 0;
+                while (phba->link_state != LPFC_LINK_DOWN) {
+                        if (i++ > timeout) {
+                                rc = -ETIMEDOUT;
+                                goto loopback_mode_exit;
+                        }
+
+                        msleep(10);
+                }
+
+                memset((void *)pmboxq, 0, sizeof(LPFC_MBOXQ_t));
+                if (link_flags == INTERNAL_LOOP_BACK)
+                        pmboxq->u.mb.un.varInitLnk.link_flags = FLAGS_LOCAL_LB;
+                else
+                        pmboxq->u.mb.un.varInitLnk.link_flags =
+                                FLAGS_TOPOLOGY_MODE_LOOP;
+
+                pmboxq->u.mb.mbxCommand = MBX_INIT_LINK;
+                pmboxq->u.mb.mbxOwner = OWN_HOST;
+
+                mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
+                                                     LPFC_MBOX_TMO);
+
+                if ((mbxstatus != MBX_SUCCESS) || (pmboxq->u.mb.mbxStatus))
+                        rc = -ENODEV;
+                else {
+                        phba->link_flag |= LS_LOOPBACK_MODE;
+                        /* wait for the link attention interrupt */
+                        msleep(100);
+
+                        i = 0;
+                        while (phba->link_state != LPFC_HBA_READY) {
+                                if (i++ > timeout) {
+                                        rc = -ETIMEDOUT;
+                                        break;
+                                }
+
+                                msleep(10);
+                        }
+                }
+
+        } else
+                rc = -ENODEV;
+
+loopback_mode_exit:
+        vports = lpfc_create_vport_work_array(phba);
+        if (vports) {
+                for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
+                        shost = lpfc_shost_from_vport(vports[i]);
+                        scsi_unblock_requests(shost);
+                }
+                lpfc_destroy_vport_work_array(phba, vports);
+        } else {
+                shost = lpfc_shost_from_vport(phba->pport);
+                scsi_unblock_requests(shost);
+        }
+
+        /*
+         * Let SLI layer release mboxq if mbox command completed after timeout.
+         */
+        if (mbxstatus != MBX_TIMEOUT)
+                mempool_free(pmboxq, phba->mbox_mem_pool);
+
+job_error:
+        /* make error code available to userspace */
+        job->reply->result = rc;
+        /* complete the job back to userspace if no error */
+        if (rc == 0)
+                job->job_done(job);
+        return rc;
+}
+
+/**
+ * lpfcdiag_loop_self_reg - obtains a remote port login id
+ * @phba: Pointer to HBA context object
+ * @rpi: Pointer to a remote port login id
+ *
+ * This function obtains a remote port login id so the diag loopback test
+ * can send and receive its own unsolicited CT command.
+ **/
+static int lpfcdiag_loop_self_reg(struct lpfc_hba *phba, uint16_t * rpi)
+{
+        LPFC_MBOXQ_t *mbox;
+        struct lpfc_dmabuf *dmabuff;
+        int status;
+
+        mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mbox)
+                return ENOMEM;
+
+        status = lpfc_reg_rpi(phba, 0, phba->pport->fc_myDID,
+                                (uint8_t *)&phba->pport->fc_sparam, mbox, 0);
+        if (status) {
+                mempool_free(mbox, phba->mbox_mem_pool);
+                return ENOMEM;
+        }
+
+        dmabuff = (struct lpfc_dmabuf *) mbox->context1;
+        mbox->context1 = NULL;
+        status = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
+
+        if ((status != MBX_SUCCESS) || (mbox->u.mb.mbxStatus)) {
+                lpfc_mbuf_free(phba, dmabuff->virt, dmabuff->phys);
+                kfree(dmabuff);
+                if (status != MBX_TIMEOUT)
+                        mempool_free(mbox, phba->mbox_mem_pool);
+                return ENODEV;
+        }
+
+        *rpi = mbox->u.mb.un.varWords[0];
+
+        lpfc_mbuf_free(phba, dmabuff->virt, dmabuff->phys);
+        kfree(dmabuff);
+        mempool_free(mbox, phba->mbox_mem_pool);
+        return 0;
+}
+
+/**
+ * lpfcdiag_loop_self_unreg - unregs from the rpi
+ * @phba: Pointer to HBA context object
+ * @rpi: Remote port login id
+ *
+ * This function unregisters the rpi obtained in lpfcdiag_loop_self_reg
+ **/
+static int lpfcdiag_loop_self_unreg(struct lpfc_hba *phba, uint16_t rpi)
+{
+        LPFC_MBOXQ_t *mbox;
+        int status;
+
+        /* Allocate mboxq structure */
+        mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (mbox == NULL)
+                return ENOMEM;
+
+        lpfc_unreg_login(phba, 0, rpi, mbox);
+        status = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
+
+        if ((status != MBX_SUCCESS) || (mbox->u.mb.mbxStatus)) {
+                if (status != MBX_TIMEOUT)
+                        mempool_free(mbox, phba->mbox_mem_pool);
+                return EIO;
+        }
+
+        mempool_free(mbox, phba->mbox_mem_pool);
+        return 0;
+}
+
+/**
+ * lpfcdiag_loop_get_xri - obtains the transmit and receive ids
+ * @phba: Pointer to HBA context object
+ * @rpi: Remote port login id
+ * @txxri: Pointer to transmit exchange id
+ * @rxxri: Pointer to response exchabge id
+ *
+ * This function obtains the transmit and receive ids required to send
+ * an unsolicited ct command with a payload. A special lpfc FsType and CmdRsp
+ * flags are used to the unsolicted response handler is able to process
+ * the ct command sent on the same port.
+ **/
+static int lpfcdiag_loop_get_xri(struct lpfc_hba *phba, uint16_t rpi,
+                         uint16_t *txxri, uint16_t * rxxri)
+{
+        struct lpfc_bsg_event *evt;
+        struct lpfc_iocbq *cmdiocbq, *rspiocbq;
+        IOCB_t *cmd, *rsp;
+        struct lpfc_dmabuf *dmabuf;
+        struct ulp_bde64 *bpl = NULL;
+        struct lpfc_sli_ct_request *ctreq = NULL;
+        int ret_val = 0;
+        unsigned long flags;
+
+        *txxri = 0;
+        *rxxri = 0;
+        evt = lpfc_bsg_event_new(FC_REG_CT_EVENT, current->pid,
+                                SLI_CT_ELX_LOOPBACK);
+        if (!evt)
+                return ENOMEM;
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        list_add(&evt->node, &phba->ct_ev_waiters);
+        lpfc_bsg_event_ref(evt);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+
+        cmdiocbq = lpfc_sli_get_iocbq(phba);
+        rspiocbq = lpfc_sli_get_iocbq(phba);
+
+        dmabuf = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
+        if (dmabuf) {
+                dmabuf->virt = lpfc_mbuf_alloc(phba, 0, &dmabuf->phys);
+                INIT_LIST_HEAD(&dmabuf->list);
+                bpl = (struct ulp_bde64 *) dmabuf->virt;
+                memset(bpl, 0, sizeof(*bpl));
+                ctreq = (struct lpfc_sli_ct_request *)(bpl + 1);
+                bpl->addrHigh =
+                        le32_to_cpu(putPaddrHigh(dmabuf->phys + sizeof(*bpl)));
+                bpl->addrLow =
+                        le32_to_cpu(putPaddrLow(dmabuf->phys + sizeof(*bpl)));
+                bpl->tus.f.bdeFlags = 0;
+                bpl->tus.f.bdeSize = ELX_LOOPBACK_HEADER_SZ;
+                bpl->tus.w = le32_to_cpu(bpl->tus.w);
+        }
+
+        if (cmdiocbq == NULL || rspiocbq == NULL ||
+            dmabuf == NULL || bpl == NULL || ctreq == NULL) {
+                ret_val = ENOMEM;
+                goto err_get_xri_exit;
+        }
+
+        cmd = &cmdiocbq->iocb;
+        rsp = &rspiocbq->iocb;
+
+        memset(ctreq, 0, ELX_LOOPBACK_HEADER_SZ);
+
+        ctreq->RevisionId.bits.Revision = SLI_CT_REVISION;
+        ctreq->RevisionId.bits.InId = 0;
+        ctreq->FsType = SLI_CT_ELX_LOOPBACK;
+        ctreq->FsSubType = 0;
+        ctreq->CommandResponse.bits.CmdRsp = ELX_LOOPBACK_XRI_SETUP;
+        ctreq->CommandResponse.bits.Size = 0;
+
+
+        cmd->un.xseq64.bdl.addrHigh = putPaddrHigh(dmabuf->phys);
+        cmd->un.xseq64.bdl.addrLow = putPaddrLow(dmabuf->phys);
+        cmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
+        cmd->un.xseq64.bdl.bdeSize = sizeof(*bpl);
+
+        cmd->un.xseq64.w5.hcsw.Fctl = LA;
+        cmd->un.xseq64.w5.hcsw.Dfctl = 0;
+        cmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CTL;
+        cmd->un.xseq64.w5.hcsw.Type = FC_TYPE_CT;
+
+        cmd->ulpCommand = CMD_XMIT_SEQUENCE64_CR;
+        cmd->ulpBdeCount = 1;
+        cmd->ulpLe = 1;
+        cmd->ulpClass = CLASS3;
+        cmd->ulpContext = rpi;
+
+        cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
+        cmdiocbq->vport = phba->pport;
+
+        ret_val = lpfc_sli_issue_iocb_wait(phba, LPFC_ELS_RING, cmdiocbq,
+                                rspiocbq,
+                                (phba->fc_ratov * 2)
+                                + LPFC_DRVR_TIMEOUT);
+        if (ret_val)
+                goto err_get_xri_exit;
+
+        *txxri =  rsp->ulpContext;
+
+        evt->waiting = 1;
+        evt->wait_time_stamp = jiffies;
+        ret_val = wait_event_interruptible_timeout(
+                evt->wq, !list_empty(&evt->events_to_see),
+                ((phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT) * HZ);
+        if (list_empty(&evt->events_to_see))
+                ret_val = (ret_val) ? EINTR : ETIMEDOUT;
+        else {
+                ret_val = IOCB_SUCCESS;
+                spin_lock_irqsave(&phba->ct_ev_lock, flags);
+                list_move(evt->events_to_see.prev, &evt->events_to_get);
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                *rxxri = (list_entry(evt->events_to_get.prev,
+                                     typeof(struct event_data),
+                                     node))->immed_dat;
+        }
+        evt->waiting = 0;
+
+err_get_xri_exit:
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        lpfc_bsg_event_unref(evt); /* release ref */
+        lpfc_bsg_event_unref(evt); /* delete */
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+
+        if (dmabuf) {
+                if (dmabuf->virt)
+                        lpfc_mbuf_free(phba, dmabuf->virt, dmabuf->phys);
+                kfree(dmabuf);
+        }
+
+        if (cmdiocbq && (ret_val != IOCB_TIMEDOUT))
+                lpfc_sli_release_iocbq(phba, cmdiocbq);
+        if (rspiocbq)
+                lpfc_sli_release_iocbq(phba, rspiocbq);
+        return ret_val;
+}
+
+/**
+ * diag_cmd_data_alloc - fills in a bde struct with dma buffers
+ * @phba: Pointer to HBA context object
+ * @bpl: Pointer to 64 bit bde structure
+ * @size: Number of bytes to process
+ * @nocopydata: Flag to copy user data into the allocated buffer
+ *
+ * This function allocates page size buffers and populates an lpfc_dmabufext.
+ * If allowed the user data pointed to with indataptr is copied into the kernel
+ * memory. The chained list of page size buffers is returned.
+ **/
+static struct lpfc_dmabufext *
+diag_cmd_data_alloc(struct lpfc_hba *phba,
+                   struct ulp_bde64 *bpl, uint32_t size,
+                   int nocopydata)
+{
+        struct lpfc_dmabufext *mlist = NULL;
+        struct lpfc_dmabufext *dmp;
+        int cnt, offset = 0, i = 0;
+        struct pci_dev *pcidev;
+
+        pcidev = phba->pcidev;
+
+        while (size) {
+                /* We get chunks of 4K */
+                if (size > BUF_SZ_4K)
+                        cnt = BUF_SZ_4K;
+                else
+                        cnt = size;
+
+                /* allocate struct lpfc_dmabufext buffer header */
+                dmp = kmalloc(sizeof(struct lpfc_dmabufext), GFP_KERNEL);
+                if (!dmp)
+                        goto out;
+
+                INIT_LIST_HEAD(&dmp->dma.list);
+
+                /* Queue it to a linked list */
+                if (mlist)
+                        list_add_tail(&dmp->dma.list, &mlist->dma.list);
+                else
+                        mlist = dmp;
+
+                /* allocate buffer */
+                dmp->dma.virt = dma_alloc_coherent(&pcidev->dev,
+                                                   cnt,
+                                                   &(dmp->dma.phys),
+                                                   GFP_KERNEL);
+
+                if (!dmp->dma.virt)
+                        goto out;
+
+                dmp->size = cnt;
+
+                if (nocopydata) {
+                        bpl->tus.f.bdeFlags = 0;
+                        pci_dma_sync_single_for_device(phba->pcidev,
+                                dmp->dma.phys, LPFC_BPL_SIZE, PCI_DMA_TODEVICE);
+
+                } else {
+                        memset((uint8_t *)dmp->dma.virt, 0, cnt);
+                        bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
+                }
+
+                /* build buffer ptr list for IOCB */
+                bpl->addrLow = le32_to_cpu(putPaddrLow(dmp->dma.phys));
+                bpl->addrHigh = le32_to_cpu(putPaddrHigh(dmp->dma.phys));
+                bpl->tus.f.bdeSize = (ushort) cnt;
+                bpl->tus.w = le32_to_cpu(bpl->tus.w);
+                bpl++;
+
+                i++;
+                offset += cnt;
+                size -= cnt;
+        }
+
+        mlist->flag = i;
+        return mlist;
+out:
+        diag_cmd_data_free(phba, mlist);
+        return NULL;
+}
+
+/**
+ * lpfcdiag_loop_post_rxbufs - post the receive buffers for an unsol CT cmd
+ * @phba: Pointer to HBA context object
+ * @rxxri: Receive exchange id
+ * @len: Number of data bytes
+ *
+ * This function allocates and posts a data buffer of sufficient size to recieve
+ * an unsolicted CT command.
+ **/
+static int lpfcdiag_loop_post_rxbufs(struct lpfc_hba *phba, uint16_t rxxri,
+                             size_t len)
+{
+        struct lpfc_sli *psli = &phba->sli;
+        struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
+        struct lpfc_iocbq *cmdiocbq;
+        IOCB_t *cmd = NULL;
+        struct list_head head, *curr, *next;
+        struct lpfc_dmabuf *rxbmp;
+        struct lpfc_dmabuf *dmp;
+        struct lpfc_dmabuf *mp[2] = {NULL, NULL};
+        struct ulp_bde64 *rxbpl = NULL;
+        uint32_t num_bde;
+        struct lpfc_dmabufext *rxbuffer = NULL;
+        int ret_val = 0;
+        int i = 0;
+
+        cmdiocbq = lpfc_sli_get_iocbq(phba);
+        rxbmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
+        if (rxbmp != NULL) {
+                rxbmp->virt = lpfc_mbuf_alloc(phba, 0, &rxbmp->phys);
+                INIT_LIST_HEAD(&rxbmp->list);
+                rxbpl = (struct ulp_bde64 *) rxbmp->virt;
+                rxbuffer = diag_cmd_data_alloc(phba, rxbpl, len, 0);
+        }
+
+        if (!cmdiocbq || !rxbmp || !rxbpl || !rxbuffer) {
+                ret_val = ENOMEM;
+                goto err_post_rxbufs_exit;
+        }
+
+        /* Queue buffers for the receive exchange */
+        num_bde = (uint32_t)rxbuffer->flag;
+        dmp = &rxbuffer->dma;
+
+        cmd = &cmdiocbq->iocb;
+        i = 0;
+
+        INIT_LIST_HEAD(&head);
+        list_add_tail(&head, &dmp->list);
+        list_for_each_safe(curr, next, &head) {
+                mp[i] = list_entry(curr, struct lpfc_dmabuf, list);
+                list_del(curr);
+
+                if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
+                        mp[i]->buffer_tag = lpfc_sli_get_buffer_tag(phba);
+                        cmd->un.quexri64cx.buff.bde.addrHigh =
+                                putPaddrHigh(mp[i]->phys);
+                        cmd->un.quexri64cx.buff.bde.addrLow =
+                                putPaddrLow(mp[i]->phys);
+                        cmd->un.quexri64cx.buff.bde.tus.f.bdeSize =
+                                ((struct lpfc_dmabufext *)mp[i])->size;
+                        cmd->un.quexri64cx.buff.buffer_tag = mp[i]->buffer_tag;
+                        cmd->ulpCommand = CMD_QUE_XRI64_CX;
+                        cmd->ulpPU = 0;
+                        cmd->ulpLe = 1;
+                        cmd->ulpBdeCount = 1;
+                        cmd->unsli3.que_xri64cx_ext_words.ebde_count = 0;
+
+                } else {
+                        cmd->un.cont64[i].addrHigh = putPaddrHigh(mp[i]->phys);
+                        cmd->un.cont64[i].addrLow = putPaddrLow(mp[i]->phys);
+                        cmd->un.cont64[i].tus.f.bdeSize =
+                                ((struct lpfc_dmabufext *)mp[i])->size;
+                                        cmd->ulpBdeCount = ++i;
+
+                        if ((--num_bde > 0) && (i < 2))
+                                continue;
+
+                        cmd->ulpCommand = CMD_QUE_XRI_BUF64_CX;
+                        cmd->ulpLe = 1;
+                }
+
+                cmd->ulpClass = CLASS3;
+                cmd->ulpContext = rxxri;
+
+                ret_val = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq, 0);
+
+                if (ret_val == IOCB_ERROR) {
+                        diag_cmd_data_free(phba,
+                                (struct lpfc_dmabufext *)mp[0]);
+                        if (mp[1])
+                                diag_cmd_data_free(phba,
+                                          (struct lpfc_dmabufext *)mp[1]);
+                        dmp = list_entry(next, struct lpfc_dmabuf, list);
+                        ret_val = EIO;
+                        goto err_post_rxbufs_exit;
+                }
+
+                lpfc_sli_ringpostbuf_put(phba, pring, mp[0]);
+                if (mp[1]) {
+                        lpfc_sli_ringpostbuf_put(phba, pring, mp[1]);
+                        mp[1] = NULL;
+                }
+
+                /* The iocb was freed by lpfc_sli_issue_iocb */
+                cmdiocbq = lpfc_sli_get_iocbq(phba);
+                if (!cmdiocbq) {
+                        dmp = list_entry(next, struct lpfc_dmabuf, list);
+                        ret_val = EIO;
+                        goto err_post_rxbufs_exit;
+                }
+
+                cmd = &cmdiocbq->iocb;
+                i = 0;
+        }
+        list_del(&head);
+
+err_post_rxbufs_exit:
+
+        if (rxbmp) {
+                if (rxbmp->virt)
+                        lpfc_mbuf_free(phba, rxbmp->virt, rxbmp->phys);
+                kfree(rxbmp);
+        }
+
+        if (cmdiocbq)
+                lpfc_sli_release_iocbq(phba, cmdiocbq);
+        return ret_val;
+}
+
+/**
+ * lpfc_bsg_diag_test - with a port in loopback issues a Ct cmd to itself
+ * @job: LPFC_BSG_VENDOR_DIAG_TEST fc_bsg_job
+ *
+ * This function receives a user data buffer to be transmitted and received on
+ * the same port, the link must be up and in loopback mode prior
+ * to being called.
+ * 1. A kernel buffer is allocated to copy the user data into.
+ * 2. The port registers with "itself".
+ * 3. The transmit and receive exchange ids are obtained.
+ * 4. The receive exchange id is posted.
+ * 5. A new els loopback event is created.
+ * 6. The command and response iocbs are allocated.
+ * 7. The cmd iocb FsType is set to elx loopback and the CmdRsp to looppback.
+ *
+ * This function is meant to be called n times while the port is in loopback
+ * so it is the apps responsibility to issue a reset to take the port out
+ * of loopback mode.
+ **/
+static int
+lpfc_bsg_diag_test(struct fc_bsg_job *job)
+{
+        struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        struct diag_mode_test *diag_mode;
+        struct lpfc_bsg_event *evt;
+        struct event_data *evdat;
+        struct lpfc_sli *psli = &phba->sli;
+        uint32_t size;
+        uint32_t full_size;
+        size_t segment_len = 0, segment_offset = 0, current_offset = 0;
+        uint16_t rpi;
+        struct lpfc_iocbq *cmdiocbq, *rspiocbq;
+        IOCB_t *cmd, *rsp;
+        struct lpfc_sli_ct_request *ctreq;
+        struct lpfc_dmabuf *txbmp;
+        struct ulp_bde64 *txbpl = NULL;
+        struct lpfc_dmabufext *txbuffer = NULL;
+        struct list_head head;
+        struct lpfc_dmabuf  *curr;
+        uint16_t txxri, rxxri;
+        uint32_t num_bde;
+        uint8_t *ptr = NULL, *rx_databuf = NULL;
+        int rc = 0;
+        unsigned long flags;
+        void *dataout = NULL;
+        uint32_t total_mem;
+
+        /* in case no data is returned return just the return code */
+        job->reply->reply_payload_rcv_len = 0;
+
+        if (job->request_len <
+            sizeof(struct fc_bsg_request) + sizeof(struct diag_mode_test)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2739 Received DIAG TEST request below minimum "
+                                "size\n");
+                rc = -EINVAL;
+                goto loopback_test_exit;
+        }
+
+        if (job->request_payload.payload_len !=
+                job->reply_payload.payload_len) {
+                rc = -EINVAL;
+                goto loopback_test_exit;
+        }
+
+        diag_mode = (struct diag_mode_test *)
+                job->request->rqst_data.h_vendor.vendor_cmd;
+
+        if ((phba->link_state == LPFC_HBA_ERROR) ||
+            (psli->sli_flag & LPFC_BLOCK_MGMT_IO) ||
+            (!(psli->sli_flag & LPFC_SLI_ACTIVE))) {
+                rc = -EACCES;
+                goto loopback_test_exit;
+        }
+
+        if (!lpfc_is_link_up(phba) || !(phba->link_flag & LS_LOOPBACK_MODE)) {
+                rc = -EACCES;
+                goto loopback_test_exit;
+        }
+
+        size = job->request_payload.payload_len;
+        full_size = size + ELX_LOOPBACK_HEADER_SZ; /* plus the header */
+
+        if ((size == 0) || (size > 80 * BUF_SZ_4K)) {
+                rc = -ERANGE;
+                goto loopback_test_exit;
+        }
+
+        if (size >= BUF_SZ_4K) {
+                /*
+                 * Allocate memory for ioctl data. If buffer is bigger than 64k,
+                 * then we allocate 64k and re-use that buffer over and over to
+                 * xfer the whole block. This is because Linux kernel has a
+                 * problem allocating more than 120k of kernel space memory. Saw
+                 * problem with GET_FCPTARGETMAPPING...
+                 */
+                if (size <= (64 * 1024))
+                        total_mem = size;
+                else
+                        total_mem = 64 * 1024;
+        } else
+                /* Allocate memory for ioctl data */
+                total_mem = BUF_SZ_4K;
+
+        dataout = kmalloc(total_mem, GFP_KERNEL);
+        if (dataout == NULL) {
+                rc = -ENOMEM;
+                goto loopback_test_exit;
+        }
+
+        ptr = dataout;
+        ptr += ELX_LOOPBACK_HEADER_SZ;
+        sg_copy_to_buffer(job->request_payload.sg_list,
+                                job->request_payload.sg_cnt,
+                                ptr, size);
+
+        rc = lpfcdiag_loop_self_reg(phba, &rpi);
+        if (rc) {
+                rc = -ENOMEM;
+                goto loopback_test_exit;
+        }
+
+        rc = lpfcdiag_loop_get_xri(phba, rpi, &txxri, &rxxri);
+        if (rc) {
+                lpfcdiag_loop_self_unreg(phba, rpi);
+                rc = -ENOMEM;
+                goto loopback_test_exit;
+        }
+
+        rc = lpfcdiag_loop_post_rxbufs(phba, rxxri, full_size);
+        if (rc) {
+                lpfcdiag_loop_self_unreg(phba, rpi);
+                rc = -ENOMEM;
+                goto loopback_test_exit;
+        }
+
+        evt = lpfc_bsg_event_new(FC_REG_CT_EVENT, current->pid,
+                                SLI_CT_ELX_LOOPBACK);
+        if (!evt) {
+                lpfcdiag_loop_self_unreg(phba, rpi);
+                rc = -ENOMEM;
+                goto loopback_test_exit;
+        }
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        list_add(&evt->node, &phba->ct_ev_waiters);
+        lpfc_bsg_event_ref(evt);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+
+        cmdiocbq = lpfc_sli_get_iocbq(phba);
+        rspiocbq = lpfc_sli_get_iocbq(phba);
+        txbmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
+
+        if (txbmp) {
+                txbmp->virt = lpfc_mbuf_alloc(phba, 0, &txbmp->phys);
+                INIT_LIST_HEAD(&txbmp->list);
+                txbpl = (struct ulp_bde64 *) txbmp->virt;
+                if (txbpl)
+                        txbuffer = diag_cmd_data_alloc(phba,
+                                                        txbpl, full_size, 0);
+        }
+
+        if (!cmdiocbq || !rspiocbq || !txbmp || !txbpl || !txbuffer) {
+                rc = -ENOMEM;
+                goto err_loopback_test_exit;
+        }
+
+        cmd = &cmdiocbq->iocb;
+        rsp = &rspiocbq->iocb;
+
+        INIT_LIST_HEAD(&head);
+        list_add_tail(&head, &txbuffer->dma.list);
+        list_for_each_entry(curr, &head, list) {
+                segment_len = ((struct lpfc_dmabufext *)curr)->size;
+                if (current_offset == 0) {
+                        ctreq = curr->virt;
+                        memset(ctreq, 0, ELX_LOOPBACK_HEADER_SZ);
+                        ctreq->RevisionId.bits.Revision = SLI_CT_REVISION;
+                        ctreq->RevisionId.bits.InId = 0;
+                        ctreq->FsType = SLI_CT_ELX_LOOPBACK;
+                        ctreq->FsSubType = 0;
+                        ctreq->CommandResponse.bits.CmdRsp = ELX_LOOPBACK_DATA;
+                        ctreq->CommandResponse.bits.Size   = size;
+                        segment_offset = ELX_LOOPBACK_HEADER_SZ;
+                } else
+                        segment_offset = 0;
+
+                BUG_ON(segment_offset >= segment_len);
+                memcpy(curr->virt + segment_offset,
+                        ptr + current_offset,
+                        segment_len - segment_offset);
+
+                current_offset += segment_len - segment_offset;
+                BUG_ON(current_offset > size);
+        }
+        list_del(&head);
+
+        /* Build the XMIT_SEQUENCE iocb */
+
+        num_bde = (uint32_t)txbuffer->flag;
+
+        cmd->un.xseq64.bdl.addrHigh = putPaddrHigh(txbmp->phys);
+        cmd->un.xseq64.bdl.addrLow = putPaddrLow(txbmp->phys);
+        cmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
+        cmd->un.xseq64.bdl.bdeSize = (num_bde * sizeof(struct ulp_bde64));
+
+        cmd->un.xseq64.w5.hcsw.Fctl = (LS | LA);
+        cmd->un.xseq64.w5.hcsw.Dfctl = 0;
+        cmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CTL;
+        cmd->un.xseq64.w5.hcsw.Type = FC_TYPE_CT;
+
+        cmd->ulpCommand = CMD_XMIT_SEQUENCE64_CX;
+        cmd->ulpBdeCount = 1;
+        cmd->ulpLe = 1;
+        cmd->ulpClass = CLASS3;
+        cmd->ulpContext = txxri;
+
+        cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
+        cmdiocbq->vport = phba->pport;
+
+        rc = lpfc_sli_issue_iocb_wait(phba, LPFC_ELS_RING, cmdiocbq, rspiocbq,
+                                      (phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT);
+
+        if ((rc != IOCB_SUCCESS) || (rsp->ulpStatus != IOCB_SUCCESS)) {
+                rc = -EIO;
+                goto err_loopback_test_exit;
+        }
+
+        evt->waiting = 1;
+        rc = wait_event_interruptible_timeout(
+                evt->wq, !list_empty(&evt->events_to_see),
+                ((phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT) * HZ);
+        evt->waiting = 0;
+        if (list_empty(&evt->events_to_see))
+                rc = (rc) ? -EINTR : -ETIMEDOUT;
+        else {
+                spin_lock_irqsave(&phba->ct_ev_lock, flags);
+                list_move(evt->events_to_see.prev, &evt->events_to_get);
+                evdat = list_entry(evt->events_to_get.prev,
+                                   typeof(*evdat), node);
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                rx_databuf = evdat->data;
+                if (evdat->len != full_size) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
+                                "1603 Loopback test did not receive expected "
+                                "data length. actual length 0x%x expected "
+                                "length 0x%x\n",
+                                evdat->len, full_size);
+                        rc = -EIO;
+                } else if (rx_databuf == NULL)
+                        rc = -EIO;
+                else {
+                        rc = IOCB_SUCCESS;
+                        /* skip over elx loopback header */
+                        rx_databuf += ELX_LOOPBACK_HEADER_SZ;
+                        job->reply->reply_payload_rcv_len =
+                                sg_copy_from_buffer(job->reply_payload.sg_list,
+                                                    job->reply_payload.sg_cnt,
+                                                    rx_databuf, size);
+                        job->reply->reply_payload_rcv_len = size;
+                }
+        }
+
+err_loopback_test_exit:
+        lpfcdiag_loop_self_unreg(phba, rpi);
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        lpfc_bsg_event_unref(evt); /* release ref */
+        lpfc_bsg_event_unref(evt); /* delete */
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+
+        if (cmdiocbq != NULL)
+                lpfc_sli_release_iocbq(phba, cmdiocbq);
+
+        if (rspiocbq != NULL)
+                lpfc_sli_release_iocbq(phba, rspiocbq);
+
+        if (txbmp != NULL) {
+                if (txbpl != NULL) {
+                        if (txbuffer != NULL)
+                                diag_cmd_data_free(phba, txbuffer);
+                        lpfc_mbuf_free(phba, txbmp->virt, txbmp->phys);
+                }
+                kfree(txbmp);
+        }
+
+loopback_test_exit:
+        kfree(dataout);
+        /* make error code available to userspace */
+        job->reply->result = rc;
+        job->dd_data = NULL;
+        /* complete the job back to userspace if no error */
+        if (rc == 0)
+                job->job_done(job);
+        return rc;
+}
+
+/**
+ * lpfc_bsg_get_dfc_rev - process a GET_DFC_REV bsg vendor command
+ * @job: GET_DFC_REV fc_bsg_job
+ **/
+static int
+lpfc_bsg_get_dfc_rev(struct fc_bsg_job *job)
+{
+        struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        struct get_mgmt_rev *event_req;
+        struct get_mgmt_rev_reply *event_reply;
+        int rc = 0;
+
+        if (job->request_len <
+            sizeof(struct fc_bsg_request) + sizeof(struct get_mgmt_rev)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2740 Received GET_DFC_REV request below "
+                                "minimum size\n");
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        event_req = (struct get_mgmt_rev *)
+                job->request->rqst_data.h_vendor.vendor_cmd;
+
+        event_reply = (struct get_mgmt_rev_reply *)
+                job->reply->reply_data.vendor_reply.vendor_rsp;
+
+        if (job->reply_len <
+            sizeof(struct fc_bsg_request) + sizeof(struct get_mgmt_rev_reply)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2741 Received GET_DFC_REV reply below "
+                                "minimum size\n");
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        event_reply->info.a_Major = MANAGEMENT_MAJOR_REV;
+        event_reply->info.a_Minor = MANAGEMENT_MINOR_REV;
+job_error:
+        job->reply->result = rc;
+        if (rc == 0)
+                job->job_done(job);
+        return rc;
+}
+
+/**
+ * lpfc_bsg_wake_mbox_wait - lpfc_bsg_issue_mbox mbox completion handler
+ * @phba: Pointer to HBA context object.
+ * @pmboxq: Pointer to mailbox command.
+ *
+ * This is completion handler function for mailbox commands issued from
+ * lpfc_bsg_issue_mbox function. This function is called by the
+ * mailbox event handler function with no lock held. This function
+ * will wake up thread waiting on the wait queue pointed by context1
+ * of the mailbox.
+ **/
+void
+lpfc_bsg_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
+{
+        struct bsg_job_data *dd_data;
+        MAILBOX_t *pmb;
+        MAILBOX_t *mb;
+        struct fc_bsg_job *job;
+        uint32_t size;
+        unsigned long flags;
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        dd_data = pmboxq->context1;
+        if (!dd_data) {
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                return;
+        }
+
+        pmb = &dd_data->context_un.mbox.pmboxq->u.mb;
+        mb = dd_data->context_un.mbox.mb;
+        job = dd_data->context_un.mbox.set_job;
+        memcpy(mb, pmb, sizeof(*pmb));
+        size = job->request_payload.payload_len;
+        job->reply->reply_payload_rcv_len =
+                sg_copy_from_buffer(job->reply_payload.sg_list,
+                                job->reply_payload.sg_cnt,
+                                mb, size);
+        job->reply->result = 0;
+        dd_data->context_un.mbox.set_job = NULL;
+        job->dd_data = NULL;
+        job->job_done(job);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+        mempool_free(dd_data->context_un.mbox.pmboxq, phba->mbox_mem_pool);
+        kfree(mb);
+        kfree(dd_data);
+        return;
+}
+
+/**
+ * lpfc_bsg_check_cmd_access - test for a supported mailbox command
+ * @phba: Pointer to HBA context object.
+ * @mb: Pointer to a mailbox object.
+ * @vport: Pointer to a vport object.
+ *
+ * Some commands require the port to be offline, some may not be called from
+ * the application.
+ **/
+static int lpfc_bsg_check_cmd_access(struct lpfc_hba *phba,
+        MAILBOX_t *mb, struct lpfc_vport *vport)
+{
+        /* return negative error values for bsg job */
+        switch (mb->mbxCommand) {
+        /* Offline only */
+        case MBX_INIT_LINK:
+        case MBX_DOWN_LINK:
+        case MBX_CONFIG_LINK:
+        case MBX_CONFIG_RING:
+        case MBX_RESET_RING:
+        case MBX_UNREG_LOGIN:
+        case MBX_CLEAR_LA:
+        case MBX_DUMP_CONTEXT:
+        case MBX_RUN_DIAGS:
+        case MBX_RESTART:
+        case MBX_SET_MASK:
+                if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
+                        lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2743 Command 0x%x is illegal in on-line "
+                                "state\n",
+                                mb->mbxCommand);
+                        return -EPERM;
+                }
+        case MBX_WRITE_NV:
+        case MBX_WRITE_VPARMS:
+        case MBX_LOAD_SM:
+        case MBX_READ_NV:
+        case MBX_READ_CONFIG:
+        case MBX_READ_RCONFIG:
+        case MBX_READ_STATUS:
+        case MBX_READ_XRI:
+        case MBX_READ_REV:
+        case MBX_READ_LNK_STAT:
+        case MBX_DUMP_MEMORY:
+        case MBX_DOWN_LOAD:
+        case MBX_UPDATE_CFG:
+        case MBX_KILL_BOARD:
+        case MBX_LOAD_AREA:
+        case MBX_LOAD_EXP_ROM:
+        case MBX_BEACON:
+        case MBX_DEL_LD_ENTRY:
+        case MBX_SET_DEBUG:
+        case MBX_WRITE_WWN:
+        case MBX_SLI4_CONFIG:
+        case MBX_READ_EVENT_LOG_STATUS:
+        case MBX_WRITE_EVENT_LOG:
+        case MBX_PORT_CAPABILITIES:
+        case MBX_PORT_IOV_CONTROL:
+                break;
+        case MBX_SET_VARIABLE:
+                lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+                        "1226 mbox: set_variable 0x%x, 0x%x\n",
+                        mb->un.varWords[0],
+                        mb->un.varWords[1]);
+                if ((mb->un.varWords[0] == SETVAR_MLOMNT)
+                        && (mb->un.varWords[1] == 1)) {
+                        phba->wait_4_mlo_maint_flg = 1;
+                } else if (mb->un.varWords[0] == SETVAR_MLORST) {
+                        phba->link_flag &= ~LS_LOOPBACK_MODE;
+                        phba->fc_topology = TOPOLOGY_PT_PT;
+                }
+                break;
+        case MBX_RUN_BIU_DIAG64:
+        case MBX_READ_EVENT_LOG:
+        case MBX_READ_SPARM64:
+        case MBX_READ_LA:
+        case MBX_READ_LA64:
+        case MBX_REG_LOGIN:
+        case MBX_REG_LOGIN64:
+        case MBX_CONFIG_PORT:
+        case MBX_RUN_BIU_DIAG:
+        default:
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                        "2742 Unknown Command 0x%x\n",
+                        mb->mbxCommand);
+                return -EPERM;
+        }
+
+        return 0; /* ok */
+}
+
+/**
+ * lpfc_bsg_issue_mbox - issues a mailbox command on behalf of an app
+ * @phba: Pointer to HBA context object.
+ * @mb: Pointer to a mailbox object.
+ * @vport: Pointer to a vport object.
+ *
+ * Allocate a tracking object, mailbox command memory, get a mailbox
+ * from the mailbox pool, copy the caller mailbox command.
+ *
+ * If offline and the sli is active we need to poll for the command (port is
+ * being reset) and com-plete the job, otherwise issue the mailbox command and
+ * let our completion handler finish the command.
+ **/
+static uint32_t
+lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
+        struct lpfc_vport *vport)
+{
+        LPFC_MBOXQ_t *pmboxq;
+        MAILBOX_t *pmb;
+        MAILBOX_t *mb;
+        struct bsg_job_data *dd_data;
+        uint32_t size;
+        int rc = 0;
+
+        /* allocate our bsg tracking structure */
+        dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+        if (!dd_data) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2727 Failed allocation of dd_data\n");
+                return -ENOMEM;
+        }
+
+        mb = kzalloc(PAGE_SIZE, GFP_KERNEL);
+        if (!mb) {
+                kfree(dd_data);
+                return -ENOMEM;
+        }
+
+        pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmboxq) {
+                kfree(dd_data);
+                kfree(mb);
+                return -ENOMEM;
+        }
+
+        size = job->request_payload.payload_len;
+        job->reply->reply_payload_rcv_len =
+                sg_copy_to_buffer(job->request_payload.sg_list,
+                                job->request_payload.sg_cnt,
+                                mb, size);
+
+        rc = lpfc_bsg_check_cmd_access(phba, mb, vport);
+        if (rc != 0) {
+                kfree(dd_data);
+                kfree(mb);
+                mempool_free(pmboxq, phba->mbox_mem_pool);
+                return rc; /* must be negative */
+        }
+
+        memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
+        pmb = &pmboxq->u.mb;
+        memcpy(pmb, mb, sizeof(*pmb));
+        pmb->mbxOwner = OWN_HOST;
+        pmboxq->context1 = NULL;
+        pmboxq->vport = vport;
+
+        if ((vport->fc_flag & FC_OFFLINE_MODE) ||
+            (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE))) {
+                rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
+                if (rc != MBX_SUCCESS) {
+                        if (rc != MBX_TIMEOUT) {
+                                kfree(dd_data);
+                                kfree(mb);
+                                mempool_free(pmboxq, phba->mbox_mem_pool);
+                        }
+                        return  (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV;
+                }
+
+                memcpy(mb, pmb, sizeof(*pmb));
+                job->reply->reply_payload_rcv_len =
+                        sg_copy_from_buffer(job->reply_payload.sg_list,
+                                        job->reply_payload.sg_cnt,
+                                        mb, size);
+                kfree(dd_data);
+                kfree(mb);
+                mempool_free(pmboxq, phba->mbox_mem_pool);
+                /* not waiting mbox already done */
+                return 0;
+        }
+
+        /* setup wake call as IOCB callback */
+        pmboxq->mbox_cmpl = lpfc_bsg_wake_mbox_wait;
+        /* setup context field to pass wait_queue pointer to wake function */
+        pmboxq->context1 = dd_data;
+        dd_data->type = TYPE_MBOX;
+        dd_data->context_un.mbox.pmboxq = pmboxq;
+        dd_data->context_un.mbox.mb = mb;
+        dd_data->context_un.mbox.set_job = job;
+        job->dd_data = dd_data;
+        rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
+        if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
+                kfree(dd_data);
+                kfree(mb);
+                mempool_free(pmboxq, phba->mbox_mem_pool);
+                return -EIO;
+        }
+
+        return 1;
+}
+
+/**
+ * lpfc_bsg_mbox_cmd - process an fc bsg LPFC_BSG_VENDOR_MBOX command
+ * @job: MBOX fc_bsg_job for LPFC_BSG_VENDOR_MBOX.
+ **/
+static int
+lpfc_bsg_mbox_cmd(struct fc_bsg_job *job)
+{
+        struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        int rc = 0;
+
+        /* in case no data is transferred */
+        job->reply->reply_payload_rcv_len = 0;
+        if (job->request_len <
+            sizeof(struct fc_bsg_request) + sizeof(struct dfc_mbox_req)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2737 Received MBOX_REQ request below "
+                                "minimum size\n");
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        if (job->request_payload.payload_len != PAGE_SIZE) {
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
+                rc = -EAGAIN;
+                goto job_error;
+        }
+
+        rc = lpfc_bsg_issue_mbox(phba, job, vport);
+
+job_error:
+        if (rc == 0) {
+                /* job done */
+                job->reply->result = 0;
+                job->dd_data = NULL;
+                job->job_done(job);
+        } else if (rc == 1)
+                /* job submitted, will complete later*/
+                rc = 0; /* return zero, no error */
+        else {
+                /* some error occurred */
+                job->reply->result = rc;
+                job->dd_data = NULL;
+        }
+
+        return rc;
+}
+
+/**
+ * lpfc_bsg_menlo_cmd_cmp - lpfc_menlo_cmd completion handler
+ * @phba: Pointer to HBA context object.
+ * @cmdiocbq: Pointer to command iocb.
+ * @rspiocbq: Pointer to response iocb.
+ *
+ * This function is the completion handler for iocbs issued using
+ * lpfc_menlo_cmd function. This function is called by the
+ * ring event handler function without any lock held. This function
+ * can be called from both worker thread context and interrupt
+ * context. This function also can be called from another thread which
+ * cleans up the SLI layer objects.
+ * This function copies the contents of the response iocb to the
+ * response iocb memory object provided by the caller of
+ * lpfc_sli_issue_iocb_wait and then wakes up the thread which
+ * sleeps for the iocb completion.
+ **/
+static void
+lpfc_bsg_menlo_cmd_cmp(struct lpfc_hba *phba,
+                        struct lpfc_iocbq *cmdiocbq,
+                        struct lpfc_iocbq *rspiocbq)
+{
+        struct bsg_job_data *dd_data;
+        struct fc_bsg_job *job;
+        IOCB_t *rsp;
+        struct lpfc_dmabuf *bmp;
+        struct lpfc_bsg_menlo *menlo;
+        unsigned long flags;
+        struct menlo_response *menlo_resp;
+        int rc = 0;
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        dd_data = cmdiocbq->context1;
+        if (!dd_data) {
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                return;
+        }
+
+        menlo = &dd_data->context_un.menlo;
+        job = menlo->set_job;
+        job->dd_data = NULL; /* so timeout handler does not reply */
+
+        spin_lock_irqsave(&phba->hbalock, flags);
+        cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
+        if (cmdiocbq->context2 && rspiocbq)
+                memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
+                       &rspiocbq->iocb, sizeof(IOCB_t));
+        spin_unlock_irqrestore(&phba->hbalock, flags);
+
+        bmp = menlo->bmp;
+        rspiocbq = menlo->rspiocbq;
+        rsp = &rspiocbq->iocb;
+
+        pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
+                     job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
+                     job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+
+        /* always return the xri, this would be used in the case
+         * of a menlo download to allow the data to be sent as a continuation
+         * of the exchange.
+         */
+        menlo_resp = (struct menlo_response *)
+                job->reply->reply_data.vendor_reply.vendor_rsp;
+        menlo_resp->xri = rsp->ulpContext;
+        if (rsp->ulpStatus) {
+                if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
+                        switch (rsp->un.ulpWord[4] & 0xff) {
+                        case IOERR_SEQUENCE_TIMEOUT:
+                                rc = -ETIMEDOUT;
+                                break;
+                        case IOERR_INVALID_RPI:
+                                rc = -EFAULT;
+                                break;
+                        default:
+                                rc = -EACCES;
+                                break;
+                        }
+                } else
+                        rc = -EACCES;
+        } else
+                job->reply->reply_payload_rcv_len =
+                        rsp->un.genreq64.bdl.bdeSize;
+
+        lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
+        lpfc_sli_release_iocbq(phba, rspiocbq);
+        lpfc_sli_release_iocbq(phba, cmdiocbq);
+        kfree(bmp);
+        kfree(dd_data);
+        /* make error code available to userspace */
+        job->reply->result = rc;
+        /* complete the job back to userspace */
+        job->job_done(job);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+        return;
+}
+
+/**
+ * lpfc_menlo_cmd - send an ioctl for menlo hardware
+ * @job: fc_bsg_job to handle
+ *
+ * This function issues a gen request 64 CR ioctl for all menlo cmd requests,
+ * all the command completions will return the xri for the command.
+ * For menlo data requests a gen request 64 CX is used to continue the exchange
+ * supplied in the menlo request header xri field.
+ **/
+static int
+lpfc_menlo_cmd(struct fc_bsg_job *job)
+{
+        struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        struct lpfc_iocbq *cmdiocbq, *rspiocbq;
+        IOCB_t *cmd, *rsp;
+        int rc = 0;
+        struct menlo_command *menlo_cmd;
+        struct menlo_response *menlo_resp;
+        struct lpfc_dmabuf *bmp = NULL;
+        int request_nseg;
+        int reply_nseg;
+        struct scatterlist *sgel = NULL;
+        int numbde;
+        dma_addr_t busaddr;
+        struct bsg_job_data *dd_data;
+        struct ulp_bde64 *bpl = NULL;
+
+        /* in case no data is returned return just the return code */
+        job->reply->reply_payload_rcv_len = 0;
+
+        if (job->request_len <
+            sizeof(struct fc_bsg_request) +
+                sizeof(struct menlo_command)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2784 Received MENLO_CMD request below "
+                                "minimum size\n");
+                rc = -ERANGE;
+                goto no_dd_data;
+        }
+
+        if (job->reply_len <
+            sizeof(struct fc_bsg_request) + sizeof(struct menlo_response)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2785 Received MENLO_CMD reply below "
+                                "minimum size\n");
+                rc = -ERANGE;
+                goto no_dd_data;
+        }
+
+        if (!(phba->menlo_flag & HBA_MENLO_SUPPORT)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2786 Adapter does not support menlo "
+                                "commands\n");
+                rc = -EPERM;
+                goto no_dd_data;
+        }
+
+        menlo_cmd = (struct menlo_command *)
+                job->request->rqst_data.h_vendor.vendor_cmd;
+
+        menlo_resp = (struct menlo_response *)
+                job->reply->reply_data.vendor_reply.vendor_rsp;
+
+        /* allocate our bsg tracking structure */
+        dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+        if (!dd_data) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2787 Failed allocation of dd_data\n");
+                rc = -ENOMEM;
+                goto no_dd_data;
+        }
+
+        bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
+        if (!bmp) {
+                rc = -ENOMEM;
+                goto free_dd;
+        }
+
+        cmdiocbq = lpfc_sli_get_iocbq(phba);
+        if (!cmdiocbq) {
+                rc = -ENOMEM;
+                goto free_bmp;
+        }
+
+        rspiocbq = lpfc_sli_get_iocbq(phba);
+        if (!rspiocbq) {
+                rc = -ENOMEM;
+                goto free_cmdiocbq;
+        }
+
+        rsp = &rspiocbq->iocb;
+
+        bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
+        if (!bmp->virt) {
+                rc = -ENOMEM;
+                goto free_rspiocbq;
+        }
+
+        INIT_LIST_HEAD(&bmp->list);
+        bpl = (struct ulp_bde64 *) bmp->virt;
+        request_nseg = pci_map_sg(phba->pcidev, job->request_payload.sg_list,
+                                  job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        for_each_sg(job->request_payload.sg_list, sgel, request_nseg, numbde) {
+                busaddr = sg_dma_address(sgel);
+                bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
+                bpl->tus.f.bdeSize = sg_dma_len(sgel);
+                bpl->tus.w = cpu_to_le32(bpl->tus.w);
+                bpl->addrLow = cpu_to_le32(putPaddrLow(busaddr));
+                bpl->addrHigh = cpu_to_le32(putPaddrHigh(busaddr));
+                bpl++;
+        }
+
+        reply_nseg = pci_map_sg(phba->pcidev, job->reply_payload.sg_list,
+                                job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        for_each_sg(job->reply_payload.sg_list, sgel, reply_nseg, numbde) {
+                busaddr = sg_dma_address(sgel);
+                bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
+                bpl->tus.f.bdeSize = sg_dma_len(sgel);
+                bpl->tus.w = cpu_to_le32(bpl->tus.w);
+                bpl->addrLow = cpu_to_le32(putPaddrLow(busaddr));
+                bpl->addrHigh = cpu_to_le32(putPaddrHigh(busaddr));
+                bpl++;
+        }
+
+        cmd = &cmdiocbq->iocb;
+        cmd->un.genreq64.bdl.ulpIoTag32 = 0;
+        cmd->un.genreq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
+        cmd->un.genreq64.bdl.addrLow = putPaddrLow(bmp->phys);
+        cmd->un.genreq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
+        cmd->un.genreq64.bdl.bdeSize =
+            (request_nseg + reply_nseg) * sizeof(struct ulp_bde64);
+        cmd->un.genreq64.w5.hcsw.Fctl = (SI | LA);
+        cmd->un.genreq64.w5.hcsw.Dfctl = 0;
+        cmd->un.genreq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CMD;
+        cmd->un.genreq64.w5.hcsw.Type = MENLO_TRANSPORT_TYPE; /* 0xfe */
+        cmd->ulpBdeCount = 1;
+        cmd->ulpClass = CLASS3;
+        cmd->ulpOwner = OWN_CHIP;
+        cmd->ulpLe = 1; /* Limited Edition */
+        cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
+        cmdiocbq->vport = phba->pport;
+        /* We want the firmware to timeout before we do */
+        cmd->ulpTimeout = MENLO_TIMEOUT - 5;
+        cmdiocbq->context3 = bmp;
+        cmdiocbq->context2 = rspiocbq;
+        cmdiocbq->iocb_cmpl = lpfc_bsg_menlo_cmd_cmp;
+        cmdiocbq->context1 = dd_data;
+        cmdiocbq->context2 = rspiocbq;
+        if (menlo_cmd->cmd == LPFC_BSG_VENDOR_MENLO_CMD) {
+                cmd->ulpCommand = CMD_GEN_REQUEST64_CR;
+                cmd->ulpPU = MENLO_PU; /* 3 */
+                cmd->un.ulpWord[4] = MENLO_DID; /* 0x0000FC0E */
+                cmd->ulpContext = MENLO_CONTEXT; /* 0 */
+        } else {
+                cmd->ulpCommand = CMD_GEN_REQUEST64_CX;
+                cmd->ulpPU = 1;
+                cmd->un.ulpWord[4] = 0;
+                cmd->ulpContext = menlo_cmd->xri;
+        }
+
+        dd_data->type = TYPE_MENLO;
+        dd_data->context_un.menlo.cmdiocbq = cmdiocbq;
+        dd_data->context_un.menlo.rspiocbq = rspiocbq;
+        dd_data->context_un.menlo.set_job = job;
+        dd_data->context_un.menlo.bmp = bmp;
+
+        rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq,
+                MENLO_TIMEOUT - 5);
+        if (rc == IOCB_SUCCESS)
+                return 0; /* done for now */
+
+        /* iocb failed so cleanup */
+        pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
+                     job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
+                     job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+
+        lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
+
+free_rspiocbq:
+        lpfc_sli_release_iocbq(phba, rspiocbq);
+free_cmdiocbq:
+        lpfc_sli_release_iocbq(phba, cmdiocbq);
+free_bmp:
+        kfree(bmp);
+free_dd:
+        kfree(dd_data);
+no_dd_data:
+        /* make error code available to userspace */
+        job->reply->result = rc;
+        job->dd_data = NULL;
+        return rc;
+}
+/**
  * lpfc_bsg_hst_vendor - process a vendor-specific fc_bsg_job
  * @job: fc_bsg_job to handle
- */
+ **/
 static int
 lpfc_bsg_hst_vendor(struct fc_bsg_job *job)
 {
         int command = job->request->rqst_data.h_vendor.vendor_cmd[0];
+        int rc;
 
         switch (command) {
         case LPFC_BSG_VENDOR_SET_CT_EVENT:
-                return lpfc_bsg_set_event(job);
+                rc = lpfc_bsg_hba_set_event(job);
                 break;
-
         case LPFC_BSG_VENDOR_GET_CT_EVENT:
-                return lpfc_bsg_get_event(job);
+                rc = lpfc_bsg_hba_get_event(job);
+                break;
+        case LPFC_BSG_VENDOR_SEND_MGMT_RESP:
+                rc = lpfc_bsg_send_mgmt_rsp(job);
+                break;
+        case LPFC_BSG_VENDOR_DIAG_MODE:
+                rc = lpfc_bsg_diag_mode(job);
+                break;
+        case LPFC_BSG_VENDOR_DIAG_TEST:
+                rc = lpfc_bsg_diag_test(job);
+                break;
+        case LPFC_BSG_VENDOR_GET_MGMT_REV:
+                rc = lpfc_bsg_get_dfc_rev(job);
+                break;
+        case LPFC_BSG_VENDOR_MBOX:
+                rc = lpfc_bsg_mbox_cmd(job);
+                break;
+        case LPFC_BSG_VENDOR_MENLO_CMD:
+        case LPFC_BSG_VENDOR_MENLO_DATA:
+                rc = lpfc_menlo_cmd(job);
                 break;
-
         default:
-                return -EINVAL;
+                rc = -EINVAL;
+                job->reply->reply_payload_rcv_len = 0;
+                /* make error code available to userspace */
+                job->reply->result = rc;
+                break;
         }
+
+        return rc;
 }
 
 /**
  * lpfc_bsg_request - handle a bsg request from the FC transport
  * @job: fc_bsg_job to handle
- */
+ **/
 int
 lpfc_bsg_request(struct fc_bsg_job *job)
 {
         uint32_t msgcode;
-        int rc = -EINVAL;
+        int rc;
 
         msgcode = job->request->msgcode;
-
         switch (msgcode) {
         case FC_BSG_HST_VENDOR:
                 rc = lpfc_bsg_hst_vendor(job);
@@ -873,9 +3020,13 @@ lpfc_bsg_request(struct fc_bsg_job *job)
                 rc = lpfc_bsg_rport_els(job);
                 break;
         case FC_BSG_RPT_CT:
-                rc = lpfc_bsg_rport_ct(job);
+                rc = lpfc_bsg_send_mgmt_cmd(job);
                 break;
         default:
+                rc = -EINVAL;
+                job->reply->reply_payload_rcv_len = 0;
+                /* make error code available to userspace */
+                job->reply->result = rc;
                 break;
         }
 
@@ -888,17 +3039,83 @@ lpfc_bsg_request(struct fc_bsg_job *job)
  *
  * This function just aborts the job's IOCB.  The aborted IOCB will return to
  * the waiting function which will handle passing the error back to userspace
- */
+ **/
 int
 lpfc_bsg_timeout(struct fc_bsg_job *job)
 {
         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
         struct lpfc_hba *phba = vport->phba;
-        struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *)job->dd_data;
+        struct lpfc_iocbq *cmdiocb;
+        struct lpfc_bsg_event *evt;
+        struct lpfc_bsg_iocb *iocb;
+        struct lpfc_bsg_mbox *mbox;
+        struct lpfc_bsg_menlo *menlo;
         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
+        struct bsg_job_data *dd_data;
+        unsigned long flags;
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        dd_data = (struct bsg_job_data *)job->dd_data;
+        /* timeout and completion crossed paths if no dd_data */
+        if (!dd_data) {
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                return 0;
+        }
 
-        if (cmdiocb)
+        switch (dd_data->type) {
+        case TYPE_IOCB:
+                iocb = &dd_data->context_un.iocb;
+                cmdiocb = iocb->cmdiocbq;
+                /* hint to completion handler that the job timed out */
+                job->reply->result = -EAGAIN;
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                /* this will call our completion handler */
+                spin_lock_irq(&phba->hbalock);
+                lpfc_sli_issue_abort_iotag(phba, pring, cmdiocb);
+                spin_unlock_irq(&phba->hbalock);
+                break;
+        case TYPE_EVT:
+                evt = dd_data->context_un.evt;
+                /* this event has no job anymore */
+                evt->set_job = NULL;
+                job->dd_data = NULL;
+                job->reply->reply_payload_rcv_len = 0;
+                /* Return -EAGAIN which is our way of signallying the
+                 * app to retry.
+                 */
+                job->reply->result = -EAGAIN;
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                job->job_done(job);
+                break;
+        case TYPE_MBOX:
+                mbox = &dd_data->context_un.mbox;
+                /* this mbox has no job anymore */
+                mbox->set_job = NULL;
+                job->dd_data = NULL;
+                job->reply->reply_payload_rcv_len = 0;
+                job->reply->result = -EAGAIN;
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                job->job_done(job);
+                break;
+        case TYPE_MENLO:
+                menlo = &dd_data->context_un.menlo;
+                cmdiocb = menlo->cmdiocbq;
+                /* hint to completion handler that the job timed out */
+                job->reply->result = -EAGAIN;
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                /* this will call our completion handler */
+                spin_lock_irq(&phba->hbalock);
                 lpfc_sli_issue_abort_iotag(phba, pring, cmdiocb);
+                spin_unlock_irq(&phba->hbalock);
+                break;
+        default:
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                break;
+        }
 
+        /* scsi transport fc fc_bsg_job_timeout expects a zero return code,
+         * otherwise an error message will be displayed on the console
+         * so always return success (zero)
+         */
         return 0;
 }
diff --git a/drivers/scsi/lpfc/lpfc_bsg.h b/drivers/scsi/lpfc/lpfc_bsg.h
new file mode 100644
index 000000000000..5bc630819b9e
--- /dev/null
+++ b/drivers/scsi/lpfc/lpfc_bsg.h
@@ -0,0 +1,110 @@
+/*******************************************************************
+ * This file is part of the Emulex Linux Device Driver for         *
+ * Fibre Channel Host Bus Adapters.                                *
+ * Copyright (C) 2010 Emulex.  All rights reserved.                *
+ * EMULEX and SLI are trademarks of Emulex.                        *
+ * www.emulex.com                                                  *
+ *                                                                 *
+ * This program is free software; you can redistribute it and/or   *
+ * modify it under the terms of version 2 of the GNU General       *
+ * Public License as published by the Free Software Foundation.    *
+ * This program is distributed in the hope that it will be useful. *
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
+ * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
+ * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
+ * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
+ * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
+ * more details, a copy of which can be found in the file COPYING  *
+ * included with this package.                                     *
+ *******************************************************************/
+/* bsg definitions
+ * No pointers to user data are allowed, all application buffers and sizes will
+ * derived through the bsg interface.
+ *
+ * These are the vendor unique structures passed in using the bsg
+ * FC_BSG_HST_VENDOR message code type.
+ */
+#define LPFC_BSG_VENDOR_SET_CT_EVENT    1
+#define LPFC_BSG_VENDOR_GET_CT_EVENT    2
+#define LPFC_BSG_VENDOR_SEND_MGMT_RESP  3
+#define LPFC_BSG_VENDOR_DIAG_MODE       4
+#define LPFC_BSG_VENDOR_DIAG_TEST       5
+#define LPFC_BSG_VENDOR_GET_MGMT_REV    6
+#define LPFC_BSG_VENDOR_MBOX            7
+#define LPFC_BSG_VENDOR_MENLO_CMD       8
+#define LPFC_BSG_VENDOR_MENLO_DATA      9
+
+struct set_ct_event {
+        uint32_t command;
+        uint32_t type_mask;
+        uint32_t ev_req_id;
+        uint32_t ev_reg_id;
+};
+
+struct get_ct_event {
+        uint32_t command;
+        uint32_t ev_reg_id;
+        uint32_t ev_req_id;
+};
+
+struct get_ct_event_reply {
+        uint32_t immed_data;
+        uint32_t type;
+};
+
+struct send_mgmt_resp {
+        uint32_t command;
+        uint32_t tag;
+};
+
+
+#define INTERNAL_LOOP_BACK 0x1 /* adapter short cuts the loop internally */
+#define EXTERNAL_LOOP_BACK 0x2 /* requires an external loopback plug */
+
+struct diag_mode_set {
+        uint32_t command;
+        uint32_t type;
+        uint32_t timeout;
+};
+
+struct diag_mode_test {
+        uint32_t command;
+};
+
+#define LPFC_WWNN_TYPE          0
+#define LPFC_WWPN_TYPE          1
+
+struct get_mgmt_rev {
+        uint32_t command;
+};
+
+#define MANAGEMENT_MAJOR_REV   1
+#define MANAGEMENT_MINOR_REV   0
+
+/* the MgmtRevInfo structure */
+struct MgmtRevInfo {
+        uint32_t a_Major;
+        uint32_t a_Minor;
+};
+
+struct get_mgmt_rev_reply {
+        struct MgmtRevInfo info;
+};
+
+struct dfc_mbox_req {
+        uint32_t command;
+        uint32_t inExtWLen;
+        uint32_t outExtWLen;
+        uint8_t mbOffset;
+};
+
+/* Used for menlo command or menlo data. The xri is only used for menlo data */
+struct menlo_command {
+        uint32_t cmd;
+        uint32_t xri;
+};
+
+struct menlo_response {
+        uint32_t xri; /* return the xri of the iocb exchange */
+};
+
diff --git a/drivers/scsi/lpfc/lpfc_crtn.h b/drivers/scsi/lpfc/lpfc_crtn.h
index 0830f37409a3..5087c4211b43 100644
--- a/drivers/scsi/lpfc/lpfc_crtn.h
+++ b/drivers/scsi/lpfc/lpfc_crtn.h
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2008 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2010 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -44,16 +44,27 @@ int lpfc_reg_rpi(struct lpfc_hba *, uint16_t, uint32_t, uint8_t *,
 void lpfc_unreg_login(struct lpfc_hba *, uint16_t, uint32_t, LPFC_MBOXQ_t *);
 void lpfc_unreg_did(struct lpfc_hba *, uint16_t, uint32_t, LPFC_MBOXQ_t *);
 void lpfc_reg_vpi(struct lpfc_vport *, LPFC_MBOXQ_t *);
+void lpfc_register_new_vport(struct lpfc_hba *, struct lpfc_vport *,
+                        struct lpfc_nodelist *);
 void lpfc_unreg_vpi(struct lpfc_hba *, uint16_t, LPFC_MBOXQ_t *);
 void lpfc_init_link(struct lpfc_hba *, LPFC_MBOXQ_t *, uint32_t, uint32_t);
 void lpfc_request_features(struct lpfc_hba *, struct lpfcMboxq *);
+void lpfc_supported_pages(struct lpfcMboxq *);
+void lpfc_sli4_params(struct lpfcMboxq *);
+int lpfc_pc_sli4_params_get(struct lpfc_hba *, LPFC_MBOXQ_t *);
 
 struct lpfc_vport *lpfc_find_vport_by_did(struct lpfc_hba *, uint32_t);
+void lpfc_cleanup_rcv_buffers(struct lpfc_vport *);
+void lpfc_rcv_seq_check_edtov(struct lpfc_vport *);
 void lpfc_cleanup_rpis(struct lpfc_vport *, int);
+void lpfc_cleanup_pending_mbox(struct lpfc_vport *);
 int lpfc_linkdown(struct lpfc_hba *);
 void lpfc_linkdown_port(struct lpfc_vport *);
 void lpfc_port_link_failure(struct lpfc_vport *);
 void lpfc_mbx_cmpl_read_la(struct lpfc_hba *, LPFC_MBOXQ_t *);
+void lpfc_init_vpi_cmpl(struct lpfc_hba *, LPFC_MBOXQ_t *);
+void lpfc_cancel_all_vport_retry_delay_timer(struct lpfc_hba *);
+void lpfc_retry_pport_discovery(struct lpfc_hba *);
 
 void lpfc_mbx_cmpl_reg_login(struct lpfc_hba *, LPFC_MBOXQ_t *);
 void lpfc_mbx_cmpl_dflt_rpi(struct lpfc_hba *, LPFC_MBOXQ_t *);
@@ -71,6 +82,7 @@ void lpfc_set_disctmo(struct lpfc_vport *);
 int  lpfc_can_disctmo(struct lpfc_vport *);
 int  lpfc_unreg_rpi(struct lpfc_vport *, struct lpfc_nodelist *);
 void lpfc_unreg_all_rpis(struct lpfc_vport *);
+void lpfc_unreg_hba_rpis(struct lpfc_hba *);
 void lpfc_unreg_default_rpis(struct lpfc_vport *);
 void lpfc_issue_reg_vpi(struct lpfc_hba *, struct lpfc_vport *);
 
@@ -97,7 +109,7 @@ int lpfc_disc_state_machine(struct lpfc_vport *, struct lpfc_nodelist *, void *,
 
 void lpfc_do_scr_ns_plogi(struct lpfc_hba *, struct lpfc_vport *);
 int lpfc_check_sparm(struct lpfc_vport *, struct lpfc_nodelist *,
-                     struct serv_parm *, uint32_t);
+                     struct serv_parm *, uint32_t, int);
 int lpfc_els_abort(struct lpfc_hba *, struct lpfc_nodelist *);
 void lpfc_more_plogi(struct lpfc_vport *);
 void lpfc_more_adisc(struct lpfc_vport *);
@@ -144,6 +156,8 @@ void lpfc_hb_timeout_handler(struct lpfc_hba *);
 
 void lpfc_ct_unsol_event(struct lpfc_hba *, struct lpfc_sli_ring *,
                          struct lpfc_iocbq *);
+void lpfc_sli4_ct_abort_unsol_event(struct lpfc_hba *, struct lpfc_sli_ring *,
+                                    struct lpfc_iocbq *);
 int lpfc_ns_cmd(struct lpfc_vport *, int, uint8_t, uint32_t);
 int lpfc_fdmi_cmd(struct lpfc_vport *, struct lpfc_nodelist *, int);
 void lpfc_fdmi_tmo(unsigned long);
@@ -188,11 +202,12 @@ int lpfc_mbox_tmo_val(struct lpfc_hba *, int);
 void lpfc_init_vfi(struct lpfcMboxq *, struct lpfc_vport *);
 void lpfc_reg_vfi(struct lpfcMboxq *, struct lpfc_vport *, dma_addr_t);
 void lpfc_init_vpi(struct lpfc_hba *, struct lpfcMboxq *, uint16_t);
-void lpfc_unreg_vfi(struct lpfcMboxq *, uint16_t);
+void lpfc_unreg_vfi(struct lpfcMboxq *, struct lpfc_vport *);
 void lpfc_reg_fcfi(struct lpfc_hba *, struct lpfcMboxq *);
 void lpfc_unreg_fcfi(struct lpfcMboxq *, uint16_t);
 void lpfc_resume_rpi(struct lpfcMboxq *, struct lpfc_nodelist *);
 int lpfc_check_pending_fcoe_event(struct lpfc_hba *, uint8_t);
+void lpfc_issue_init_vpi(struct lpfc_vport *);
 
 void lpfc_config_hbq(struct lpfc_hba *, uint32_t, struct lpfc_hbq_init *,
         uint32_t , LPFC_MBOXQ_t *);
@@ -202,7 +217,15 @@ struct hbq_dmabuf *lpfc_sli4_rb_alloc(struct lpfc_hba *);
 void lpfc_sli4_rb_free(struct lpfc_hba *, struct hbq_dmabuf *);
 void lpfc_sli4_build_dflt_fcf_record(struct lpfc_hba *, struct fcf_record *,
                         uint16_t);
+void lpfc_unregister_fcf(struct lpfc_hba *);
+void lpfc_unregister_fcf_rescan(struct lpfc_hba *);
 void lpfc_unregister_unused_fcf(struct lpfc_hba *);
+int lpfc_sli4_redisc_fcf_table(struct lpfc_hba *);
+void lpfc_fcf_redisc_wait_start_timer(struct lpfc_hba *);
+void lpfc_sli4_fcf_dead_failthrough(struct lpfc_hba *);
+uint16_t lpfc_sli4_fcf_rr_next_index_get(struct lpfc_hba *);
+int lpfc_sli4_fcf_rr_index_set(struct lpfc_hba *, uint16_t);
+void lpfc_sli4_fcf_rr_index_clear(struct lpfc_hba *, uint16_t);
 
 int lpfc_mem_alloc(struct lpfc_hba *, int align);
 void lpfc_mem_free(struct lpfc_hba *);
@@ -212,7 +235,10 @@ void lpfc_stop_vport_timers(struct lpfc_vport *);
 void lpfc_poll_timeout(unsigned long ptr);
 void lpfc_poll_start_timer(struct lpfc_hba *);
 void lpfc_poll_eratt(unsigned long);
-void lpfc_sli_poll_fcp_ring(struct lpfc_hba *);
+int
+lpfc_sli_handle_fast_ring_event(struct lpfc_hba *,
+                        struct lpfc_sli_ring *, uint32_t);
+
 struct lpfc_iocbq * lpfc_sli_get_iocbq(struct lpfc_hba *);
 void lpfc_sli_release_iocbq(struct lpfc_hba *, struct lpfc_iocbq *);
 uint16_t lpfc_sli_next_iotag(struct lpfc_hba *, struct lpfc_iocbq *);
@@ -235,7 +261,7 @@ void lpfc_sli_mbox_sys_shutdown(struct lpfc_hba *);
 int lpfc_sli_check_eratt(struct lpfc_hba *);
 void lpfc_sli_handle_slow_ring_event(struct lpfc_hba *,
                                     struct lpfc_sli_ring *, uint32_t);
-int lpfc_sli4_handle_received_buffer(struct lpfc_hba *);
+void lpfc_sli4_handle_received_buffer(struct lpfc_hba *, struct hbq_dmabuf *);
 void lpfc_sli_def_mbox_cmpl(struct lpfc_hba *, LPFC_MBOXQ_t *);
 int lpfc_sli_issue_iocb(struct lpfc_hba *, uint32_t,
                         struct lpfc_iocbq *, uint32_t);
@@ -358,10 +384,13 @@ void lpfc_free_fast_evt(struct lpfc_hba *, struct lpfc_fast_path_event *);
 void lpfc_create_static_vport(struct lpfc_hba *);
 void lpfc_stop_hba_timers(struct lpfc_hba *);
 void lpfc_stop_port(struct lpfc_hba *);
+void __lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *);
+void lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *);
 void lpfc_parse_fcoe_conf(struct lpfc_hba *, uint8_t *, uint32_t);
 int lpfc_parse_vpd(struct lpfc_hba *, uint8_t *, int);
 void lpfc_start_fdiscs(struct lpfc_hba *phba);
-
+struct lpfc_vport *lpfc_find_vport_by_vpid(struct lpfc_hba *, uint16_t);
+struct lpfc_sglq *__lpfc_get_active_sglq(struct lpfc_hba *, uint16_t);
 #define ScsiResult(host_code, scsi_code) (((host_code) << 16) | scsi_code)
 #define HBA_EVENT_RSCN                   5
 #define HBA_EVENT_LINK_UP                2
@@ -370,5 +399,5 @@ void lpfc_start_fdiscs(struct lpfc_hba *phba);
 /* functions to support SGIOv4/bsg interface */
 int lpfc_bsg_request(struct fc_bsg_job *);
 int lpfc_bsg_timeout(struct fc_bsg_job *);
-void lpfc_bsg_ct_unsol_event(struct lpfc_hba *, struct lpfc_sli_ring *,
+int lpfc_bsg_ct_unsol_event(struct lpfc_hba *, struct lpfc_sli_ring *,
                              struct lpfc_iocbq *);
diff --git a/drivers/scsi/lpfc/lpfc_ct.c b/drivers/scsi/lpfc/lpfc_ct.c
index 9a1bd9534d74..463b74902ac4 100644
--- a/drivers/scsi/lpfc/lpfc_ct.c
+++ b/drivers/scsi/lpfc/lpfc_ct.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-2010 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -25,12 +25,14 @@
 #include <linux/blkdev.h>
 #include <linux/pci.h>
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 #include <linux/utsname.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_transport_fc.h>
+#include <scsi/fc/fc_fs.h>
 
 #include "lpfc_hw4.h"
 #include "lpfc_hw.h"
@@ -87,7 +89,6 @@ void
 lpfc_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                     struct lpfc_iocbq *piocbq)
 {
-
         struct lpfc_dmabuf *mp = NULL;
         IOCB_t *icmd = &piocbq->iocb;
         int i;
@@ -97,7 +98,8 @@ lpfc_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
         struct list_head head;
         struct lpfc_dmabuf *bdeBuf;
 
-        lpfc_bsg_ct_unsol_event(phba, pring, piocbq);
+        if (lpfc_bsg_ct_unsol_event(phba, pring, piocbq) == 0)
+                return;
 
         if (unlikely(icmd->ulpStatus == IOSTAT_NEED_BUFFER)) {
                 lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ);
@@ -160,6 +162,40 @@ lpfc_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
         }
 }
 
+/**
+ * lpfc_sli4_ct_abort_unsol_event - Default handle for sli4 unsol abort
+ * @phba: Pointer to HBA context object.
+ * @pring: Pointer to the driver internal I/O ring.
+ * @piocbq: Pointer to the IOCBQ.
+ *
+ * This function serves as the default handler for the sli4 unsolicited
+ * abort event. It shall be invoked when there is no application interface
+ * registered unsolicited abort handler. This handler does nothing but
+ * just simply releases the dma buffer used by the unsol abort event.
+ **/
+void
+lpfc_sli4_ct_abort_unsol_event(struct lpfc_hba *phba,
+                               struct lpfc_sli_ring *pring,
+                               struct lpfc_iocbq *piocbq)
+{
+        IOCB_t *icmd = &piocbq->iocb;
+        struct lpfc_dmabuf *bdeBuf;
+        uint32_t size;
+
+        /* Forward abort event to any process registered to receive ct event */
+        if (lpfc_bsg_ct_unsol_event(phba, pring, piocbq) == 0)
+                return;
+
+        /* If there is no BDE associated with IOCB, there is nothing to do */
+        if (icmd->ulpBdeCount == 0)
+                return;
+        bdeBuf = piocbq->context2;
+        piocbq->context2 = NULL;
+        size  = icmd->un.cont64[0].tus.f.bdeSize;
+        lpfc_ct_unsol_buffer(phba, piocbq, bdeBuf, size);
+        lpfc_in_buf_free(phba, bdeBuf);
+}
+
 static void
 lpfc_free_ct_rsp(struct lpfc_hba *phba, struct lpfc_dmabuf *mlist)
 {
@@ -304,8 +340,8 @@ lpfc_gen_req(struct lpfc_vport *vport, struct lpfc_dmabuf *bmp,
         /* Fill in rest of iocb */
         icmd->un.genreq64.w5.hcsw.Fctl = (SI | LA);
         icmd->un.genreq64.w5.hcsw.Dfctl = 0;
-        icmd->un.genreq64.w5.hcsw.Rctl = FC_UNSOL_CTL;
-        icmd->un.genreq64.w5.hcsw.Type = FC_COMMON_TRANSPORT_ULP;
+        icmd->un.genreq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CTL;
+        icmd->un.genreq64.w5.hcsw.Type = FC_TYPE_CT;
 
         if (!tmo) {
                  /* FC spec states we need 3 * ratov for CT requests */
@@ -363,9 +399,14 @@ lpfc_ct_cmd(struct lpfc_vport *vport, struct lpfc_dmabuf *inmp,
         outmp = lpfc_alloc_ct_rsp(phba, cmdcode, bpl, rsp_size, &cnt);
         if (!outmp)
                 return -ENOMEM;
-
+        /*
+         * Form the CT IOCB.  The total number of BDEs in this IOCB
+         * is the single command plus response count from
+         * lpfc_alloc_ct_rsp.
+         */
+        cnt += 1;
         status = lpfc_gen_req(vport, bmp, inmp, outmp, cmpl, ndlp, 0,
-                              cnt+1, 0, retry);
+                              cnt, 0, retry);
         if (status) {
                 lpfc_free_ct_rsp(phba, outmp);
                 return -ENOMEM;
@@ -501,6 +542,9 @@ lpfc_ns_rsp(struct lpfc_vport *vport, struct lpfc_dmabuf *mp, uint32_t Size)
                                                         SLI_CTNS_GFF_ID,
                                                         0, Did) == 0)
                                                         vport->num_disc_nodes++;
+                                                else
+                                                        lpfc_setup_disc_node
+                                                                (vport, Did);
                                         }
                                         else {
                                                 lpfc_debugfs_disc_trc(vport,
@@ -1209,7 +1253,7 @@ lpfc_ns_cmd(struct lpfc_vport *vport, int cmdcode,
                     be16_to_cpu(SLI_CTNS_RFF_ID);
                 CtReq->un.rff.PortId = cpu_to_be32(vport->fc_myDID);
                 CtReq->un.rff.fbits = FC4_FEATURE_INIT;
-                CtReq->un.rff.type_code = FC_FCP_DATA;
+                CtReq->un.rff.type_code = FC_TYPE_FCP;
                 cmpl = lpfc_cmpl_ct_cmd_rff_id;
                 break;
         }
@@ -1802,12 +1846,7 @@ lpfc_decode_firmware_rev(struct lpfc_hba *phba, char *fwrevision, int flag)
                 c  = (rev & 0x0000ff00) >> 8;
                 b4 = (rev & 0x000000ff);
 
-                if (flag)
-                        sprintf(fwrevision, "%d.%d%d%c%d ", b1,
-                                b2, b3, c, b4);
-                else
-                        sprintf(fwrevision, "%d.%d%d%c%d ", b1,
-                                b2, b3, c, b4);
+                sprintf(fwrevision, "%d.%d%d%c%d", b1, b2, b3, c, b4);
         }
         return;
 }
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.c b/drivers/scsi/lpfc/lpfc_debugfs.c
index 8d0f0de76b63..a80d938fafc9 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.c
+++ b/drivers/scsi/lpfc/lpfc_debugfs.c
@@ -24,6 +24,7 @@
 #include <linux/idr.h>
 #include <linux/interrupt.h>
 #include <linux/kthread.h>
+#include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/spinlock.h>
 #include <linux/ctype.h>
@@ -926,7 +927,7 @@ lpfc_debugfs_dumpData_open(struct inode *inode, struct file *file)
                 goto out;
 
         /* Round to page boundry */
-        printk(KERN_ERR "BLKGRD %s: _dump_buf_data=0x%p\n",
+        printk(KERN_ERR "9059 BLKGRD:  %s: _dump_buf_data=0x%p\n",
                         __func__, _dump_buf_data);
         debug->buffer = _dump_buf_data;
         if (!debug->buffer) {
@@ -956,8 +957,8 @@ lpfc_debugfs_dumpDif_open(struct inode *inode, struct file *file)
                 goto out;
 
         /* Round to page boundry */
-        printk(KERN_ERR "BLKGRD %s: _dump_buf_dif=0x%p file=%s\n", __func__,
-               _dump_buf_dif, file->f_dentry->d_name.name);
+        printk(KERN_ERR "9060 BLKGRD: %s: _dump_buf_dif=0x%p file=%s\n",
+                __func__, _dump_buf_dif, file->f_dentry->d_name.name);
         debug->buffer = _dump_buf_dif;
         if (!debug->buffer) {
                 kfree(debug);
@@ -1377,7 +1378,7 @@ lpfc_debugfs_initialize(struct lpfc_vport *vport)
                         debugfs_create_dir(name, phba->hba_debugfs_root);
                 if (!vport->vport_debugfs_root) {
                         lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
-                                         "0417 Cant create debugfs");
+                                         "0417 Cant create debugfs\n");
                         goto debug_failed;
                 }
                 atomic_inc(&phba->debugfs_vport_count);
@@ -1430,7 +1431,7 @@ lpfc_debugfs_initialize(struct lpfc_vport *vport)
                                  vport, &lpfc_debugfs_op_nodelist);
         if (!vport->debug_nodelist) {
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
-                                 "0409 Cant create debugfs nodelist");
+                                 "0409 Cant create debugfs nodelist\n");
                 goto debug_failed;
         }
 debug_failed:
diff --git a/drivers/scsi/lpfc/lpfc_disc.h b/drivers/scsi/lpfc/lpfc_disc.h
index 1142070e9484..2851d75ffc6f 100644
--- a/drivers/scsi/lpfc/lpfc_disc.h
+++ b/drivers/scsi/lpfc/lpfc_disc.h
@@ -19,7 +19,7 @@
  *******************************************************************/
 
 #define FC_MAX_HOLD_RSCN     32       /* max number of deferred RSCNs */
-#define FC_MAX_NS_RSP        65536    /* max size NameServer rsp */
+#define FC_MAX_NS_RSP        64512    /* max size NameServer rsp */
 #define FC_MAXLOOP           126      /* max devices supported on a fc loop */
 #define LPFC_DISC_FLOGI_TMO  10       /* Discovery FLOGI ratov */
 
@@ -105,8 +105,6 @@ struct lpfc_nodelist {
         struct lpfc_vport *vport;
         struct lpfc_work_evt els_retry_evt;
         struct lpfc_work_evt dev_loss_evt;
-        unsigned long last_ramp_up_time;        /* jiffy of last ramp up */
-        unsigned long last_q_full_time;         /* jiffy of last queue full */
         struct kref     kref;
         atomic_t cmd_pending;
         uint32_t cmd_qdepth;
diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
index 45337cd23feb..5fbdb22c1899 100644
--- a/drivers/scsi/lpfc/lpfc_els.c
+++ b/drivers/scsi/lpfc/lpfc_els.c
@@ -21,6 +21,7 @@
 /* See Fibre Channel protocol T11 FC-LS for details */
 #include <linux/blkdev.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <linux/interrupt.h>
 
 #include <scsi/scsi.h>
@@ -50,9 +51,6 @@ static int lpfc_issue_els_fdisc(struct lpfc_vport *vport,
                                 struct lpfc_nodelist *ndlp, uint8_t retry);
 static int lpfc_issue_fabric_iocb(struct lpfc_hba *phba,
                                   struct lpfc_iocbq *iocb);
-static void lpfc_register_new_vport(struct lpfc_hba *phba,
-                                    struct lpfc_vport *vport,
-                                    struct lpfc_nodelist *ndlp);
 
 static int lpfc_max_els_tries = 3;
 
@@ -173,13 +171,26 @@ lpfc_prep_els_iocb(struct lpfc_vport *vport, uint8_t expectRsp,
          * in FIP mode send FLOGI, FDISC and LOGO as FIP frames.
          */
         if ((did == Fabric_DID) &&
-                bf_get(lpfc_fip_flag, &phba->sli4_hba.sli4_flags) &&
+                (phba->hba_flag & HBA_FIP_SUPPORT) &&
                 ((elscmd == ELS_CMD_FLOGI) ||
                  (elscmd == ELS_CMD_FDISC) ||
                  (elscmd == ELS_CMD_LOGO)))
-                elsiocb->iocb_flag |= LPFC_FIP_ELS;
+                switch (elscmd) {
+                case ELS_CMD_FLOGI:
+                elsiocb->iocb_flag |= ((ELS_ID_FLOGI << LPFC_FIP_ELS_ID_SHIFT)
+                                        & LPFC_FIP_ELS_ID_MASK);
+                break;
+                case ELS_CMD_FDISC:
+                elsiocb->iocb_flag |= ((ELS_ID_FDISC << LPFC_FIP_ELS_ID_SHIFT)
+                                        & LPFC_FIP_ELS_ID_MASK);
+                break;
+                case ELS_CMD_LOGO:
+                elsiocb->iocb_flag |= ((ELS_ID_LOGO << LPFC_FIP_ELS_ID_SHIFT)
+                                        & LPFC_FIP_ELS_ID_MASK);
+                break;
+                }
         else
-                elsiocb->iocb_flag &= ~LPFC_FIP_ELS;
+                elsiocb->iocb_flag &= ~LPFC_FIP_ELS_ID_MASK;
 
         icmd = &elsiocb->iocb;
 
@@ -579,6 +590,15 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
                         spin_unlock_irq(shost->host_lock);
                 }
+                /*
+                 * If VPI is unreged, driver need to do INIT_VPI
+                 * before re-registering
+                 */
+                if (phba->sli_rev == LPFC_SLI_REV4) {
+                        spin_lock_irq(shost->host_lock);
+                        vport->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
+                        spin_unlock_irq(shost->host_lock);
+                }
         }
 
         if (phba->sli_rev < LPFC_SLI_REV4) {
@@ -591,10 +611,13 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         } else {
                 ndlp->nlp_type |= NLP_FABRIC;
                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
-                if (vport->vfi_state & LPFC_VFI_REGISTERED) {
+                if ((!(vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)) &&
+                        (vport->vpi_state & LPFC_VPI_REGISTERED)) {
                         lpfc_start_fdiscs(phba);
                         lpfc_do_scr_ns_plogi(phba, vport);
-                } else
+                } else if (vport->fc_flag & FC_VFI_REGISTERED)
+                        lpfc_issue_init_vpi(vport);
+                else
                         lpfc_issue_reg_vfi(vport);
         }
         return 0;
@@ -749,6 +772,7 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
         struct lpfc_nodelist *ndlp = cmdiocb->context1;
         struct lpfc_dmabuf *pcmd = cmdiocb->context2, *prsp;
         struct serv_parm *sp;
+        uint16_t fcf_index;
         int rc;
 
         /* Check to see if link went down during discovery */
@@ -766,6 +790,54 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                 vport->port_state);
 
         if (irsp->ulpStatus) {
+                /*
+                 * In case of FIP mode, perform round robin FCF failover
+                 * due to new FCF discovery
+                 */
+                if ((phba->hba_flag & HBA_FIP_SUPPORT) &&
+                    (phba->fcf.fcf_flag & FCF_DISCOVERY)) {
+                        lpfc_printf_log(phba, KERN_WARNING, LOG_FIP | LOG_ELS,
+                                        "2611 FLOGI failed on registered "
+                                        "FCF record fcf_index:%d, trying "
+                                        "to perform round robin failover\n",
+                                        phba->fcf.current_rec.fcf_indx);
+                        fcf_index = lpfc_sli4_fcf_rr_next_index_get(phba);
+                        if (fcf_index == LPFC_FCOE_FCF_NEXT_NONE) {
+                                /*
+                                 * Exhausted the eligible FCF record list,
+                                 * fail through to retry FLOGI on current
+                                 * FCF record.
+                                 */
+                                lpfc_printf_log(phba, KERN_WARNING,
+                                                LOG_FIP | LOG_ELS,
+                                                "2760 FLOGI exhausted FCF "
+                                                "round robin failover list, "
+                                                "retry FLOGI on the current "
+                                                "registered FCF index:%d\n",
+                                                phba->fcf.current_rec.fcf_indx);
+                                spin_lock_irq(&phba->hbalock);
+                                phba->fcf.fcf_flag &= ~FCF_DISCOVERY;
+                                spin_unlock_irq(&phba->hbalock);
+                        } else {
+                                rc = lpfc_sli4_fcf_rr_read_fcf_rec(phba,
+                                                                   fcf_index);
+                                if (rc) {
+                                        lpfc_printf_log(phba, KERN_WARNING,
+                                                        LOG_FIP | LOG_ELS,
+                                                        "2761 FLOGI round "
+                                                        "robin FCF failover "
+                                                        "read FCF failed "
+                                                        "rc:x%x, fcf_index:"
+                                                        "%d\n", rc,
+                                                phba->fcf.current_rec.fcf_indx);
+                                        spin_lock_irq(&phba->hbalock);
+                                        phba->fcf.fcf_flag &= ~FCF_DISCOVERY;
+                                        spin_unlock_irq(&phba->hbalock);
+                                } else
+                                        goto out;
+                        }
+                }
+
                 /* Check for retry */
                 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
                         goto out;
@@ -784,13 +856,15 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                 }
 
                 /* FLOGI failure */
-                lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
-                                 "0100 FLOGI failure Data: x%x x%x "
-                                 "x%x\n",
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+                                 "0100 FLOGI failure Status:x%x/x%x TMO:x%x\n",
                                  irsp->ulpStatus, irsp->un.ulpWord[4],
                                  irsp->ulpTimeout);
                 goto flogifail;
         }
+        spin_lock_irq(shost->host_lock);
+        vport->fc_flag &= ~FC_VPORT_CVL_RCVD;
+        spin_unlock_irq(shost->host_lock);
 
         /*
          * The FLogI succeeded.  Sync the data for the CPU before
@@ -802,7 +876,7 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
 
         /* FLOGI completes successfully */
         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
-                         "0101 FLOGI completes sucessfully "
+                         "0101 FLOGI completes successfully "
                          "Data: x%x x%x x%x x%x\n",
                          irsp->un.ulpWord[4], sp->cmn.e_d_tov,
                          sp->cmn.w2.r_a_tov, sp->cmn.edtovResolution);
@@ -817,8 +891,18 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                 else
                         rc = lpfc_cmpl_els_flogi_nport(vport, ndlp, sp);
 
-                if (!rc)
+                if (!rc) {
+                        /* Mark the FCF discovery process done */
+                        lpfc_printf_vlog(vport, KERN_INFO, LOG_FIP | LOG_ELS,
+                                         "2769 FLOGI successful on FCF record: "
+                                         "current_fcf_index:x%x, terminate FCF "
+                                         "round robin failover process\n",
+                                         phba->fcf.current_rec.fcf_indx);
+                        spin_lock_irq(&phba->hbalock);
+                        phba->fcf.fcf_flag &= ~FCF_DISCOVERY;
+                        spin_unlock_irq(&phba->hbalock);
                         goto out;
+                }
         }
 
 flogifail:
@@ -956,7 +1040,7 @@ lpfc_issue_els_flogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
  * function returns, it does not guarantee all the IOCBs are actually aborted.
  *
  * Return code
- *   0 - Sucessfully issued abort iocb on all outstanding flogis (Always 0)
+ *   0 - Successfully issued abort iocb on all outstanding flogis (Always 0)
  **/
 int
 lpfc_els_abort_flogi(struct lpfc_hba *phba)
@@ -1384,6 +1468,10 @@ lpfc_cmpl_els_plogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                         goto out;
                 }
                 /* PLOGI failed */
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+                                 "2753 PLOGI failure DID:%06X Status:x%x/x%x\n",
+                                 ndlp->nlp_DID, irsp->ulpStatus,
+                                 irsp->un.ulpWord[4]);
                 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
                 if (lpfc_error_lost_link(irsp))
                         rc = NLP_STE_FREED_NODE;
@@ -1552,6 +1640,10 @@ lpfc_cmpl_els_prli(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                         goto out;
                 }
                 /* PRLI failed */
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+                                 "2754 PRLI failure DID:%06X Status:x%x/x%x\n",
+                                 ndlp->nlp_DID, irsp->ulpStatus,
+                                 irsp->un.ulpWord[4]);
                 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
                 if (lpfc_error_lost_link(irsp))
                         goto out;
@@ -1835,6 +1927,10 @@ lpfc_cmpl_els_adisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                         goto out;
                 }
                 /* ADISC failed */
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+                                 "2755 ADISC failure DID:%06X Status:x%x/x%x\n",
+                                 ndlp->nlp_DID, irsp->ulpStatus,
+                                 irsp->un.ulpWord[4]);
                 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
                 if (!lpfc_error_lost_link(irsp))
                         lpfc_disc_state_machine(vport, ndlp, cmdiocb,
@@ -1984,6 +2080,10 @@ lpfc_cmpl_els_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                         /* ELS command is being retried */
                         goto out;
                 /* LOGO failed */
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+                                 "2756 LOGO failure DID:%06X Status:x%x/x%x\n",
+                                 ndlp->nlp_DID, irsp->ulpStatus,
+                                 irsp->un.ulpWord[4]);
                 /* Do not call DSM for lpfc_els_abort'ed ELS cmds */
                 if (lpfc_error_lost_link(irsp))
                         goto out;
@@ -2452,6 +2552,7 @@ lpfc_els_retry_delay_handler(struct lpfc_nodelist *ndlp)
          */
         del_timer_sync(&ndlp->nlp_delayfunc);
         retry = ndlp->nlp_retry;
+        ndlp->nlp_retry = 0;
 
         switch (cmd) {
         case ELS_CMD_FLOGI:
@@ -2706,17 +2807,21 @@ lpfc_els_retry(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
         if (did == FDMI_DID)
                 retry = 1;
 
-        if ((cmd == ELS_CMD_FLOGI) &&
+        if (((cmd == ELS_CMD_FLOGI) || (cmd == ELS_CMD_FDISC)) &&
             (phba->fc_topology != TOPOLOGY_LOOP) &&
             !lpfc_error_lost_link(irsp)) {
                 /* FLOGI retry policy */
                 retry = 1;
-                maxretry = 48;
-                if (cmdiocb->retry >= 32)
+                /* retry forever */
+                maxretry = 0;
+                if (cmdiocb->retry >= 100)
+                        delay = 5000;
+                else if (cmdiocb->retry >= 32)
                         delay = 1000;
         }
 
-        if ((++cmdiocb->retry) >= maxretry) {
+        cmdiocb->retry++;
+        if (maxretry && (cmdiocb->retry >= maxretry)) {
                 phba->fc_stat.elsRetryExceeded++;
                 retry = 0;
         }
@@ -3099,7 +3204,7 @@ lpfc_cmpl_els_rsp(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
         if (ndlp && NLP_CHK_NODE_ACT(ndlp) &&
             (*((uint32_t *) (pcmd)) == ELS_CMD_LS_RJT)) {
                 /* A LS_RJT associated with Default RPI cleanup has its own
-                 * seperate code path.
+                 * separate code path.
                  */
                 if (!(ndlp->nlp_flag & NLP_RM_DFLT_RPI))
                         ls_rjt = 1;
@@ -4124,8 +4229,8 @@ lpfc_els_rcv_rscn(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
         spin_lock_irq(shost->host_lock);
         if (vport->fc_rscn_flush) {
                 /* Another thread is walking fc_rscn_id_list on this vport */
-                spin_unlock_irq(shost->host_lock);
                 vport->fc_flag |= FC_RSCN_DISCOVERY;
+                spin_unlock_irq(shost->host_lock);
                 /* Send back ACC */
                 lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
                 return 0;
@@ -4133,7 +4238,7 @@ lpfc_els_rcv_rscn(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
         /* Indicate we are walking fc_rscn_id_list on this vport */
         vport->fc_rscn_flush = 1;
         spin_unlock_irq(shost->host_lock);
-        /* Get the array count after sucessfully have the token */
+        /* Get the array count after successfully have the token */
         rscn_cnt = vport->fc_rscn_id_cnt;
         /* If we are already processing an RSCN, save the received
          * RSCN payload buffer, cmdiocb->context2 to process later.
@@ -4367,7 +4472,7 @@ lpfc_els_rcv_flogi(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
 
         did = Fabric_DID;
 
-        if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3))) {
+        if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3, 1))) {
                 /* For a FLOGI we accept, then if our portname is greater
                  * then the remote portname we initiate Nport login.
                  */
@@ -4503,6 +4608,29 @@ lpfc_els_rcv_lirr(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
 }
 
 /**
+ * lpfc_els_rcv_rrq - Process an unsolicited rrq iocb
+ * @vport: pointer to a host virtual N_Port data structure.
+ * @cmdiocb: pointer to lpfc command iocb data structure.
+ * @ndlp: pointer to a node-list data structure.
+ *
+ * This routine processes a Reinstate Recovery Qualifier (RRQ) IOCB
+ * received as an ELS unsolicited event. A request to RRQ shall only
+ * be accepted if the Originator Nx_Port N_Port_ID or the Responder
+ * Nx_Port N_Port_ID of the target Exchange is the same as the
+ * N_Port_ID of the Nx_Port that makes the request. If the RRQ is
+ * not accepted, an LS_RJT with reason code "Unable to perform
+ * command request" and reason code explanation "Invalid Originator
+ * S_ID" shall be returned. For now, we just unconditionally accept
+ * RRQ from the target.
+ **/
+static void
+lpfc_els_rcv_rrq(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
+                 struct lpfc_nodelist *ndlp)
+{
+        lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
+}
+
+/**
  * lpfc_els_rsp_rps_acc - Completion callbk func for MBX_READ_LNK_STAT mbox cmd
  * @phba: pointer to lpfc hba data structure.
  * @pmb: pointer to the driver internal queue element for mailbox command.
@@ -5396,7 +5524,7 @@ lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
         if (lpfc_els_chk_latt(vport))
                 goto dropit;
 
-        /* Ignore traffic recevied during vport shutdown. */
+        /* Ignore traffic received during vport shutdown. */
         if (vport->load_flag & FC_UNLOADING)
                 goto dropit;
 
@@ -5618,6 +5746,16 @@ lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                 if (newnode)
                         lpfc_nlp_put(ndlp);
                 break;
+        case ELS_CMD_RRQ:
+                lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
+                        "RCV RRQ:         did:x%x/ste:x%x flg:x%x",
+                        did, vport->port_state, ndlp->nlp_flag);
+
+                phba->fc_stat.elsRcvRRQ++;
+                lpfc_els_rcv_rrq(vport, elsiocb, ndlp);
+                if (newnode)
+                        lpfc_nlp_put(ndlp);
+                break;
         default:
                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
                         "RCV ELS cmd:     cmd:x%x did:x%x/ste:x%x",
@@ -5670,7 +5808,7 @@ dropit:
  *    NULL - No vport with the matching @vpi found
  *    Otherwise - Address to the vport with the matching @vpi.
  **/
-static struct lpfc_vport *
+struct lpfc_vport *
 lpfc_find_vport_by_vpid(struct lpfc_hba *phba, uint16_t vpi)
 {
         struct lpfc_vport *vport;
@@ -5864,6 +6002,7 @@ lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
         MAILBOX_t *mb = &pmb->u.mb;
+        int rc;
 
         spin_lock_irq(shost->host_lock);
         vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
@@ -5885,6 +6024,26 @@ lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                         spin_unlock_irq(shost->host_lock);
                         lpfc_can_disctmo(vport);
                         break;
+                /* If reg_vpi fail with invalid VPI status, re-init VPI */
+                case 0x20:
+                        spin_lock_irq(shost->host_lock);
+                        vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
+                        spin_unlock_irq(shost->host_lock);
+                        lpfc_init_vpi(phba, pmb, vport->vpi);
+                        pmb->vport = vport;
+                        pmb->mbox_cmpl = lpfc_init_vpi_cmpl;
+                        rc = lpfc_sli_issue_mbox(phba, pmb,
+                                MBX_NOWAIT);
+                        if (rc == MBX_NOT_FINISHED) {
+                                lpfc_printf_vlog(vport,
+                                        KERN_ERR, LOG_MBOX,
+                                        "2732 Failed to issue INIT_VPI"
+                                        " mailbox command\n");
+                        } else {
+                                lpfc_nlp_put(ndlp);
+                                return;
+                        }
+
                 default:
                         /* Try to recover from this error */
                         lpfc_mbx_unreg_vpi(vport);
@@ -5897,14 +6056,23 @@ lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                                 lpfc_initial_fdisc(vport);
                         break;
                 }
-
         } else {
-                if (vport == phba->pport)
+                spin_lock_irq(shost->host_lock);
+                vport->vpi_state |= LPFC_VPI_REGISTERED;
+                spin_unlock_irq(shost->host_lock);
+                if (vport == phba->pport) {
                         if (phba->sli_rev < LPFC_SLI_REV4)
                                 lpfc_issue_fabric_reglogin(vport);
-                        else
-                                lpfc_issue_reg_vfi(vport);
-                else
+                        else {
+                                /*
+                                 * If the physical port is instantiated using
+                                 * FDISC, do not start vport discovery.
+                                 */
+                                if (vport->port_state != LPFC_FDISC)
+                                        lpfc_start_fdiscs(phba);
+                                lpfc_do_scr_ns_plogi(phba, vport);
+                        }
+                } else
                         lpfc_do_scr_ns_plogi(phba, vport);
         }
 
@@ -5926,7 +6094,7 @@ lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
  * This routine registers the @vport as a new virtual port with a HBA.
  * It is done through a registering vpi mailbox command.
  **/
-static void
+void
 lpfc_register_new_vport(struct lpfc_hba *phba, struct lpfc_vport *vport,
                         struct lpfc_nodelist *ndlp)
 {
@@ -5967,6 +6135,92 @@ mbox_err_exit:
 }
 
 /**
+ * lpfc_cancel_all_vport_retry_delay_timer - Cancel all vport retry delay timer
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine cancels the retry delay timers to all the vports.
+ **/
+void
+lpfc_cancel_all_vport_retry_delay_timer(struct lpfc_hba *phba)
+{
+        struct lpfc_vport **vports;
+        struct lpfc_nodelist *ndlp;
+        uint32_t link_state;
+        int i;
+
+        /* Treat this failure as linkdown for all vports */
+        link_state = phba->link_state;
+        lpfc_linkdown(phba);
+        phba->link_state = link_state;
+
+        vports = lpfc_create_vport_work_array(phba);
+
+        if (vports) {
+                for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
+                        ndlp = lpfc_findnode_did(vports[i], Fabric_DID);
+                        if (ndlp)
+                                lpfc_cancel_retry_delay_tmo(vports[i], ndlp);
+                        lpfc_els_flush_cmd(vports[i]);
+                }
+                lpfc_destroy_vport_work_array(phba, vports);
+        }
+}
+
+/**
+ * lpfc_retry_pport_discovery - Start timer to retry FLOGI.
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine abort all pending discovery commands and
+ * start a timer to retry FLOGI for the physical port
+ * discovery.
+ **/
+void
+lpfc_retry_pport_discovery(struct lpfc_hba *phba)
+{
+        struct lpfc_nodelist *ndlp;
+        struct Scsi_Host  *shost;
+
+        /* Cancel the all vports retry delay retry timers */
+        lpfc_cancel_all_vport_retry_delay_timer(phba);
+
+        /* If fabric require FLOGI, then re-instantiate physical login */
+        ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
+        if (!ndlp)
+                return;
+
+        shost = lpfc_shost_from_vport(phba->pport);
+        mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
+        spin_lock_irq(shost->host_lock);
+        ndlp->nlp_flag |= NLP_DELAY_TMO;
+        spin_unlock_irq(shost->host_lock);
+        ndlp->nlp_last_elscmd = ELS_CMD_FLOGI;
+        phba->pport->port_state = LPFC_FLOGI;
+        return;
+}
+
+/**
+ * lpfc_fabric_login_reqd - Check if FLOGI required.
+ * @phba: pointer to lpfc hba data structure.
+ * @cmdiocb: pointer to FDISC command iocb.
+ * @rspiocb: pointer to FDISC response iocb.
+ *
+ * This routine checks if a FLOGI is reguired for FDISC
+ * to succeed.
+ **/
+static int
+lpfc_fabric_login_reqd(struct lpfc_hba *phba,
+                struct lpfc_iocbq *cmdiocb,
+                struct lpfc_iocbq *rspiocb)
+{
+
+        if ((rspiocb->iocb.ulpStatus != IOSTAT_FABRIC_RJT) ||
+                (rspiocb->iocb.un.ulpWord[4] != RJT_LOGIN_REQUIRED))
+                return 0;
+        else
+                return 1;
+}
+
+/**
  * lpfc_cmpl_els_fdisc - Completion function for fdisc iocb command
  * @phba: pointer to lpfc hba data structure.
  * @cmdiocb: pointer to lpfc command iocb data structure.
@@ -6015,6 +6269,12 @@ lpfc_cmpl_els_fdisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                 irsp->ulpStatus, irsp->un.ulpWord[4], vport->fc_prevDID);
 
         if (irsp->ulpStatus) {
+
+                if (lpfc_fabric_login_reqd(phba, cmdiocb, rspiocb)) {
+                        lpfc_retry_pport_discovery(phba);
+                        goto out;
+                }
+
                 /* Check for retry */
                 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
                         goto out;
@@ -6024,12 +6284,8 @@ lpfc_cmpl_els_fdisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                                  irsp->ulpStatus, irsp->un.ulpWord[4]);
                 goto fdisc_failed;
         }
-                if (vport->fc_vport->vport_state == FC_VPORT_INITIALIZING)
-                        lpfc_vport_set_state(vport, FC_VPORT_FAILED);
-                lpfc_nlp_put(ndlp);
-                /* giving up on FDISC. Cancel discovery timer */
-                lpfc_can_disctmo(vport);
         spin_lock_irq(shost->host_lock);
+        vport->fc_flag &= ~FC_VPORT_CVL_RCVD;
         vport->fc_flag |= FC_FABRIC;
         if (vport->phba->fc_topology == TOPOLOGY_LOOP)
                 vport->fc_flag |=  FC_PUBLIC_LOOP;
@@ -6057,10 +6313,14 @@ lpfc_cmpl_els_fdisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                 lpfc_mbx_unreg_vpi(vport);
                 spin_lock_irq(shost->host_lock);
                 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
+                if (phba->sli_rev == LPFC_SLI_REV4)
+                        vport->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
                 spin_unlock_irq(shost->host_lock);
         }
 
-        if (vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)
+        if (vport->fc_flag & FC_VPORT_NEEDS_INIT_VPI)
+                lpfc_issue_init_vpi(vport);
+        else if (vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)
                 lpfc_register_new_vport(phba, vport, ndlp);
         else
                 lpfc_do_scr_ns_plogi(phba, vport);
@@ -6107,6 +6367,7 @@ lpfc_issue_els_fdisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         int did = ndlp->nlp_DID;
         int rc;
 
+        vport->port_state = LPFC_FDISC;
         cmdsize = (sizeof(uint32_t) + sizeof(struct serv_parm));
         elsiocb = lpfc_prep_els_iocb(vport, 1, cmdsize, retry, ndlp, did,
                                      ELS_CMD_FDISC);
@@ -6172,7 +6433,6 @@ lpfc_issue_els_fdisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                 return 1;
         }
         lpfc_vport_set_state(vport, FC_VPORT_INITIALIZING);
-        vport->port_state = LPFC_FDISC;
         return 0;
 }
 
@@ -6632,21 +6892,27 @@ lpfc_sli4_els_xri_aborted(struct lpfc_hba *phba,
         struct lpfc_sglq *sglq_entry = NULL, *sglq_next = NULL;
         unsigned long iflag = 0;
 
-        spin_lock_irqsave(&phba->sli4_hba.abts_sgl_list_lock, iflag);
+        spin_lock_irqsave(&phba->hbalock, iflag);
+        spin_lock(&phba->sli4_hba.abts_sgl_list_lock);
         list_for_each_entry_safe(sglq_entry, sglq_next,
                         &phba->sli4_hba.lpfc_abts_els_sgl_list, list) {
                 if (sglq_entry->sli4_xritag == xri) {
                         list_del(&sglq_entry->list);
-                        spin_unlock_irqrestore(
-                                        &phba->sli4_hba.abts_sgl_list_lock,
-                                         iflag);
-                        spin_lock_irqsave(&phba->hbalock, iflag);
-
                         list_add_tail(&sglq_entry->list,
                                 &phba->sli4_hba.lpfc_sgl_list);
+                        sglq_entry->state = SGL_FREED;
+                        spin_unlock(&phba->sli4_hba.abts_sgl_list_lock);
                         spin_unlock_irqrestore(&phba->hbalock, iflag);
                         return;
                 }
         }
-        spin_unlock_irqrestore(&phba->sli4_hba.abts_sgl_list_lock, iflag);
+        spin_unlock(&phba->sli4_hba.abts_sgl_list_lock);
+        sglq_entry = __lpfc_get_active_sglq(phba, xri);
+        if (!sglq_entry || (sglq_entry->sli4_xritag != xri)) {
+                spin_unlock_irqrestore(&phba->hbalock, iflag);
+                return;
+        }
+        sglq_entry->state = SGL_XRI_ABORTED;
+        spin_unlock_irqrestore(&phba->hbalock, iflag);
+        return;
 }
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index e6a47e25b218..e1466eec56b7 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -20,6 +20,7 @@
  *******************************************************************/
 
 #include <linux/blkdev.h>
+#include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/kthread.h>
 #include <linux/interrupt.h>
@@ -525,8 +526,8 @@ lpfc_work_done(struct lpfc_hba *phba)
                         spin_unlock_irq(&phba->hbalock);
                         lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ);
                 }
-                if (phba->hba_flag & HBA_RECEIVE_BUFFER)
-                        lpfc_sli4_handle_received_buffer(phba);
+                if (phba->fcf.fcf_flag & FCF_REDISC_EVT)
+                        lpfc_sli4_fcf_redisc_event_proc(phba);
         }
 
         vports = lpfc_create_vport_work_array(phba);
@@ -568,8 +569,9 @@ lpfc_work_done(struct lpfc_hba *phba)
         pring = &phba->sli.ring[LPFC_ELS_RING];
         status = (ha_copy & (HA_RXMASK  << (4*LPFC_ELS_RING)));
         status >>= (4*LPFC_ELS_RING);
-        if ((status & HA_RXMASK)
-                || (pring->flag & LPFC_DEFERRED_RING_EVENT)) {
+        if ((status & HA_RXMASK) ||
+            (pring->flag & LPFC_DEFERRED_RING_EVENT) ||
+            (phba->hba_flag & HBA_SP_QUEUE_EVT)) {
                 if (pring->flag & LPFC_STOP_IOCB_EVENT) {
                         pring->flag |= LPFC_DEFERRED_RING_EVENT;
                         /* Set the lpfc data pending flag */
@@ -688,7 +690,8 @@ lpfc_cleanup_rpis(struct lpfc_vport *vport, int remove)
                         lpfc_unreg_rpi(vport, ndlp);
 
                 /* Leave Fabric nodes alone on link down */
-                if (!remove && ndlp->nlp_type & NLP_FABRIC)
+                if ((phba->sli_rev < LPFC_SLI_REV4) &&
+                    (!remove && ndlp->nlp_type & NLP_FABRIC))
                         continue;
                 rc = lpfc_disc_state_machine(vport, ndlp, NULL,
                                              remove
@@ -706,6 +709,11 @@ lpfc_cleanup_rpis(struct lpfc_vport *vport, int remove)
 void
 lpfc_port_link_failure(struct lpfc_vport *vport)
 {
+        lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
+
+        /* Cleanup any outstanding received buffers */
+        lpfc_cleanup_rcv_buffers(vport);
+
         /* Cleanup any outstanding RSCN activity */
         lpfc_els_flush_rscn(vport);
 
@@ -744,13 +752,19 @@ lpfc_linkdown(struct lpfc_hba *phba)
 
         if (phba->link_state == LPFC_LINK_DOWN)
                 return 0;
+
+        /* Block all SCSI stack I/Os */
+        lpfc_scsi_dev_block(phba);
+
         spin_lock_irq(&phba->hbalock);
-        phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_DISCOVERED);
+        phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_SCAN_DONE);
+        spin_unlock_irq(&phba->hbalock);
         if (phba->link_state > LPFC_LINK_DOWN) {
                 phba->link_state = LPFC_LINK_DOWN;
+                spin_lock_irq(shost->host_lock);
                 phba->pport->fc_flag &= ~FC_LBIT;
+                spin_unlock_irq(shost->host_lock);
         }
-        spin_unlock_irq(&phba->hbalock);
         vports = lpfc_create_vport_work_array(phba);
         if (vports != NULL)
                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
@@ -1015,13 +1029,12 @@ lpfc_mbx_cmpl_reg_fcfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                 mempool_free(mboxq, phba->mbox_mem_pool);
                 return;
         }
-        if (vport->port_state != LPFC_FLOGI) {
-                spin_lock_irqsave(&phba->hbalock, flags);
-                phba->fcf.fcf_flag |= (FCF_DISCOVERED | FCF_IN_USE);
-                phba->hba_flag &= ~FCF_DISC_INPROGRESS;
-                spin_unlock_irqrestore(&phba->hbalock, flags);
+        spin_lock_irqsave(&phba->hbalock, flags);
+        phba->fcf.fcf_flag |= (FCF_SCAN_DONE | FCF_IN_USE);
+        phba->hba_flag &= ~FCF_DISC_INPROGRESS;
+        spin_unlock_irqrestore(&phba->hbalock, flags);
+        if (vport->port_state != LPFC_FLOGI)
                 lpfc_initial_flogi(vport);
-        }
 
         mempool_free(mboxq, phba->mbox_mem_pool);
         return;
@@ -1039,25 +1052,23 @@ lpfc_mbx_cmpl_reg_fcfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
 static uint32_t
 lpfc_fab_name_match(uint8_t *fab_name, struct fcf_record *new_fcf_record)
 {
-        if ((fab_name[0] ==
-                bf_get(lpfc_fcf_record_fab_name_0, new_fcf_record)) &&
-            (fab_name[1] ==
-                bf_get(lpfc_fcf_record_fab_name_1, new_fcf_record)) &&
-            (fab_name[2] ==
-                bf_get(lpfc_fcf_record_fab_name_2, new_fcf_record)) &&
-            (fab_name[3] ==
-                bf_get(lpfc_fcf_record_fab_name_3, new_fcf_record)) &&
-            (fab_name[4] ==
-                bf_get(lpfc_fcf_record_fab_name_4, new_fcf_record)) &&
-            (fab_name[5] ==
-                bf_get(lpfc_fcf_record_fab_name_5, new_fcf_record)) &&
-            (fab_name[6] ==
-                bf_get(lpfc_fcf_record_fab_name_6, new_fcf_record)) &&
-            (fab_name[7] ==
-                bf_get(lpfc_fcf_record_fab_name_7, new_fcf_record)))
-                return 1;
-        else
+        if (fab_name[0] != bf_get(lpfc_fcf_record_fab_name_0, new_fcf_record))
+                return 0;
+        if (fab_name[1] != bf_get(lpfc_fcf_record_fab_name_1, new_fcf_record))
+                return 0;
+        if (fab_name[2] != bf_get(lpfc_fcf_record_fab_name_2, new_fcf_record))
+                return 0;
+        if (fab_name[3] != bf_get(lpfc_fcf_record_fab_name_3, new_fcf_record))
+                return 0;
+        if (fab_name[4] != bf_get(lpfc_fcf_record_fab_name_4, new_fcf_record))
+                return 0;
+        if (fab_name[5] != bf_get(lpfc_fcf_record_fab_name_5, new_fcf_record))
+                return 0;
+        if (fab_name[6] != bf_get(lpfc_fcf_record_fab_name_6, new_fcf_record))
+                return 0;
+        if (fab_name[7] != bf_get(lpfc_fcf_record_fab_name_7, new_fcf_record))
                 return 0;
+        return 1;
 }
 
 /**
@@ -1072,30 +1083,28 @@ lpfc_fab_name_match(uint8_t *fab_name, struct fcf_record *new_fcf_record)
 static uint32_t
 lpfc_sw_name_match(uint8_t *sw_name, struct fcf_record *new_fcf_record)
 {
-        if ((sw_name[0] ==
-                bf_get(lpfc_fcf_record_switch_name_0, new_fcf_record)) &&
-            (sw_name[1] ==
-                bf_get(lpfc_fcf_record_switch_name_1, new_fcf_record)) &&
-            (sw_name[2] ==
-                bf_get(lpfc_fcf_record_switch_name_2, new_fcf_record)) &&
-            (sw_name[3] ==
-                bf_get(lpfc_fcf_record_switch_name_3, new_fcf_record)) &&
-            (sw_name[4] ==
-                bf_get(lpfc_fcf_record_switch_name_4, new_fcf_record)) &&
-            (sw_name[5] ==
-                bf_get(lpfc_fcf_record_switch_name_5, new_fcf_record)) &&
-            (sw_name[6] ==
-                bf_get(lpfc_fcf_record_switch_name_6, new_fcf_record)) &&
-            (sw_name[7] ==
-                bf_get(lpfc_fcf_record_switch_name_7, new_fcf_record)))
-                return 1;
-        else
+        if (sw_name[0] != bf_get(lpfc_fcf_record_switch_name_0, new_fcf_record))
+                return 0;
+        if (sw_name[1] != bf_get(lpfc_fcf_record_switch_name_1, new_fcf_record))
+                return 0;
+        if (sw_name[2] != bf_get(lpfc_fcf_record_switch_name_2, new_fcf_record))
+                return 0;
+        if (sw_name[3] != bf_get(lpfc_fcf_record_switch_name_3, new_fcf_record))
+                return 0;
+        if (sw_name[4] != bf_get(lpfc_fcf_record_switch_name_4, new_fcf_record))
                 return 0;
+        if (sw_name[5] != bf_get(lpfc_fcf_record_switch_name_5, new_fcf_record))
+                return 0;
+        if (sw_name[6] != bf_get(lpfc_fcf_record_switch_name_6, new_fcf_record))
+                return 0;
+        if (sw_name[7] != bf_get(lpfc_fcf_record_switch_name_7, new_fcf_record))
+                return 0;
+        return 1;
 }
 
 /**
  * lpfc_mac_addr_match - Check if the fcf mac address match.
- * @phba: pointer to lpfc hba data structure.
+ * @mac_addr: pointer to mac address.
  * @new_fcf_record: pointer to fcf record.
  *
  * This routine compare the fcf record's mac address with HBA's
@@ -1103,85 +1112,115 @@ lpfc_sw_name_match(uint8_t *sw_name, struct fcf_record *new_fcf_record)
  * returns 1 else return 0.
  **/
 static uint32_t
-lpfc_mac_addr_match(struct lpfc_hba *phba, struct fcf_record *new_fcf_record)
+lpfc_mac_addr_match(uint8_t *mac_addr, struct fcf_record *new_fcf_record)
 {
-        if ((phba->fcf.mac_addr[0] ==
-                bf_get(lpfc_fcf_record_mac_0, new_fcf_record)) &&
-            (phba->fcf.mac_addr[1] ==
-                bf_get(lpfc_fcf_record_mac_1, new_fcf_record)) &&
-            (phba->fcf.mac_addr[2] ==
-                bf_get(lpfc_fcf_record_mac_2, new_fcf_record)) &&
-            (phba->fcf.mac_addr[3] ==
-                bf_get(lpfc_fcf_record_mac_3, new_fcf_record)) &&
-            (phba->fcf.mac_addr[4] ==
-                bf_get(lpfc_fcf_record_mac_4, new_fcf_record)) &&
-            (phba->fcf.mac_addr[5] ==
-                bf_get(lpfc_fcf_record_mac_5, new_fcf_record)))
-                return 1;
-        else
+        if (mac_addr[0] != bf_get(lpfc_fcf_record_mac_0, new_fcf_record))
+                return 0;
+        if (mac_addr[1] != bf_get(lpfc_fcf_record_mac_1, new_fcf_record))
                 return 0;
+        if (mac_addr[2] != bf_get(lpfc_fcf_record_mac_2, new_fcf_record))
+                return 0;
+        if (mac_addr[3] != bf_get(lpfc_fcf_record_mac_3, new_fcf_record))
+                return 0;
+        if (mac_addr[4] != bf_get(lpfc_fcf_record_mac_4, new_fcf_record))
+                return 0;
+        if (mac_addr[5] != bf_get(lpfc_fcf_record_mac_5, new_fcf_record))
+                return 0;
+        return 1;
+}
+
+static bool
+lpfc_vlan_id_match(uint16_t curr_vlan_id, uint16_t new_vlan_id)
+{
+        return (curr_vlan_id == new_vlan_id);
 }
 
 /**
  * lpfc_copy_fcf_record - Copy fcf information to lpfc_hba.
- * @phba: pointer to lpfc hba data structure.
+ * @fcf: pointer to driver fcf record.
  * @new_fcf_record: pointer to fcf record.
  *
  * This routine copies the FCF information from the FCF
  * record to lpfc_hba data structure.
  **/
 static void
-lpfc_copy_fcf_record(struct lpfc_hba *phba, struct fcf_record *new_fcf_record)
+lpfc_copy_fcf_record(struct lpfc_fcf_rec *fcf_rec,
+                     struct fcf_record *new_fcf_record)
 {
-        phba->fcf.fabric_name[0] =
+        /* Fabric name */
+        fcf_rec->fabric_name[0] =
                 bf_get(lpfc_fcf_record_fab_name_0, new_fcf_record);
-        phba->fcf.fabric_name[1] =
+        fcf_rec->fabric_name[1] =
                 bf_get(lpfc_fcf_record_fab_name_1, new_fcf_record);
-        phba->fcf.fabric_name[2] =
+        fcf_rec->fabric_name[2] =
                 bf_get(lpfc_fcf_record_fab_name_2, new_fcf_record);
-        phba->fcf.fabric_name[3] =
+        fcf_rec->fabric_name[3] =
                 bf_get(lpfc_fcf_record_fab_name_3, new_fcf_record);
-        phba->fcf.fabric_name[4] =
+        fcf_rec->fabric_name[4] =
                 bf_get(lpfc_fcf_record_fab_name_4, new_fcf_record);
-        phba->fcf.fabric_name[5] =
+        fcf_rec->fabric_name[5] =
                 bf_get(lpfc_fcf_record_fab_name_5, new_fcf_record);
-        phba->fcf.fabric_name[6] =
+        fcf_rec->fabric_name[6] =
                 bf_get(lpfc_fcf_record_fab_name_6, new_fcf_record);
-        phba->fcf.fabric_name[7] =
+        fcf_rec->fabric_name[7] =
                 bf_get(lpfc_fcf_record_fab_name_7, new_fcf_record);
-        phba->fcf.mac_addr[0] =
-                bf_get(lpfc_fcf_record_mac_0, new_fcf_record);
-        phba->fcf.mac_addr[1] =
-                bf_get(lpfc_fcf_record_mac_1, new_fcf_record);
-        phba->fcf.mac_addr[2] =
-                bf_get(lpfc_fcf_record_mac_2, new_fcf_record);
-        phba->fcf.mac_addr[3] =
-                bf_get(lpfc_fcf_record_mac_3, new_fcf_record);
-        phba->fcf.mac_addr[4] =
-                bf_get(lpfc_fcf_record_mac_4, new_fcf_record);
-        phba->fcf.mac_addr[5] =
-                bf_get(lpfc_fcf_record_mac_5, new_fcf_record);
-        phba->fcf.fcf_indx = bf_get(lpfc_fcf_record_fcf_index, new_fcf_record);
-        phba->fcf.priority = new_fcf_record->fip_priority;
-        phba->fcf.switch_name[0] =
+        /* Mac address */
+        fcf_rec->mac_addr[0] = bf_get(lpfc_fcf_record_mac_0, new_fcf_record);
+        fcf_rec->mac_addr[1] = bf_get(lpfc_fcf_record_mac_1, new_fcf_record);
+        fcf_rec->mac_addr[2] = bf_get(lpfc_fcf_record_mac_2, new_fcf_record);
+        fcf_rec->mac_addr[3] = bf_get(lpfc_fcf_record_mac_3, new_fcf_record);
+        fcf_rec->mac_addr[4] = bf_get(lpfc_fcf_record_mac_4, new_fcf_record);
+        fcf_rec->mac_addr[5] = bf_get(lpfc_fcf_record_mac_5, new_fcf_record);
+        /* FCF record index */
+        fcf_rec->fcf_indx = bf_get(lpfc_fcf_record_fcf_index, new_fcf_record);
+        /* FCF record priority */
+        fcf_rec->priority = new_fcf_record->fip_priority;
+        /* Switch name */
+        fcf_rec->switch_name[0] =
                 bf_get(lpfc_fcf_record_switch_name_0, new_fcf_record);
-        phba->fcf.switch_name[1] =
+        fcf_rec->switch_name[1] =
                 bf_get(lpfc_fcf_record_switch_name_1, new_fcf_record);
-        phba->fcf.switch_name[2] =
+        fcf_rec->switch_name[2] =
                 bf_get(lpfc_fcf_record_switch_name_2, new_fcf_record);
-        phba->fcf.switch_name[3] =
+        fcf_rec->switch_name[3] =
                 bf_get(lpfc_fcf_record_switch_name_3, new_fcf_record);
-        phba->fcf.switch_name[4] =
+        fcf_rec->switch_name[4] =
                 bf_get(lpfc_fcf_record_switch_name_4, new_fcf_record);
-        phba->fcf.switch_name[5] =
+        fcf_rec->switch_name[5] =
                 bf_get(lpfc_fcf_record_switch_name_5, new_fcf_record);
-        phba->fcf.switch_name[6] =
+        fcf_rec->switch_name[6] =
                 bf_get(lpfc_fcf_record_switch_name_6, new_fcf_record);
-        phba->fcf.switch_name[7] =
+        fcf_rec->switch_name[7] =
                 bf_get(lpfc_fcf_record_switch_name_7, new_fcf_record);
 }
 
 /**
+ * lpfc_update_fcf_record - Update driver fcf record
+ * @phba: pointer to lpfc hba data structure.
+ * @fcf_rec: pointer to driver fcf record.
+ * @new_fcf_record: pointer to hba fcf record.
+ * @addr_mode: address mode to be set to the driver fcf record.
+ * @vlan_id: vlan tag to be set to the driver fcf record.
+ * @flag: flag bits to be set to the driver fcf record.
+ *
+ * This routine updates the driver FCF record from the new HBA FCF record
+ * together with the address mode, vlan_id, and other informations. This
+ * routine is called with the host lock held.
+ **/
+static void
+__lpfc_update_fcf_record(struct lpfc_hba *phba, struct lpfc_fcf_rec *fcf_rec,
+                       struct fcf_record *new_fcf_record, uint32_t addr_mode,
+                       uint16_t vlan_id, uint32_t flag)
+{
+        /* Copy the fields from the HBA's FCF record */
+        lpfc_copy_fcf_record(fcf_rec, new_fcf_record);
+        /* Update other fields of driver FCF record */
+        fcf_rec->addr_mode = addr_mode;
+        fcf_rec->vlan_id = vlan_id;
+        fcf_rec->flag |= (flag | RECORD_VALID);
+}
+
+/**
  * lpfc_register_fcf - Register the FCF with hba.
  * @phba: pointer to lpfc hba data structure.
  *
@@ -1199,13 +1238,14 @@ lpfc_register_fcf(struct lpfc_hba *phba)
 
         /* If the FCF is not availabe do nothing. */
         if (!(phba->fcf.fcf_flag & FCF_AVAILABLE)) {
+                phba->hba_flag &= ~FCF_DISC_INPROGRESS;
                 spin_unlock_irqrestore(&phba->hbalock, flags);
                 return;
         }
 
         /* The FCF is already registered, start discovery */
         if (phba->fcf.fcf_flag & FCF_REGISTERED) {
-                phba->fcf.fcf_flag |= (FCF_DISCOVERED | FCF_IN_USE);
+                phba->fcf.fcf_flag |= (FCF_SCAN_DONE | FCF_IN_USE);
                 phba->hba_flag &= ~FCF_DISC_INPROGRESS;
                 spin_unlock_irqrestore(&phba->hbalock, flags);
                 if (phba->pport->port_state != LPFC_FLOGI)
@@ -1216,15 +1256,23 @@ lpfc_register_fcf(struct lpfc_hba *phba)
 
         fcf_mbxq = mempool_alloc(phba->mbox_mem_pool,
                 GFP_KERNEL);
-        if (!fcf_mbxq)
+        if (!fcf_mbxq) {
+                spin_lock_irqsave(&phba->hbalock, flags);
+                phba->hba_flag &= ~FCF_DISC_INPROGRESS;
+                spin_unlock_irqrestore(&phba->hbalock, flags);
                 return;
+        }
 
         lpfc_reg_fcfi(phba, fcf_mbxq);
         fcf_mbxq->vport = phba->pport;
         fcf_mbxq->mbox_cmpl = lpfc_mbx_cmpl_reg_fcfi;
         rc = lpfc_sli_issue_mbox(phba, fcf_mbxq, MBX_NOWAIT);
-        if (rc == MBX_NOT_FINISHED)
+        if (rc == MBX_NOT_FINISHED) {
+                spin_lock_irqsave(&phba->hbalock, flags);
+                phba->hba_flag &= ~FCF_DISC_INPROGRESS;
+                spin_unlock_irqrestore(&phba->hbalock, flags);
                 mempool_free(fcf_mbxq, phba->mbox_mem_pool);
+        }
 
         return;
 }
@@ -1235,6 +1283,7 @@ lpfc_register_fcf(struct lpfc_hba *phba)
  * @new_fcf_record: pointer to fcf record.
  * @boot_flag: Indicates if this record used by boot bios.
  * @addr_mode: The address mode to be used by this FCF
+ * @vlan_id: The vlan id to be used as vlan tagging by this FCF.
  *
  * This routine compare the fcf record with connect list obtained from the
  * config region to decide if this FCF can be used for SAN discovery. It returns
@@ -1253,13 +1302,27 @@ lpfc_match_fcf_conn_list(struct lpfc_hba *phba,
                         uint16_t *vlan_id)
 {
         struct lpfc_fcf_conn_entry *conn_entry;
+        int i, j, fcf_vlan_id = 0;
+
+        /* Find the lowest VLAN id in the FCF record */
+        for (i = 0; i < 512; i++) {
+                if (new_fcf_record->vlan_bitmap[i]) {
+                        fcf_vlan_id = i * 8;
+                        j = 0;
+                        while (!((new_fcf_record->vlan_bitmap[i] >> j) & 1)) {
+                                j++;
+                                fcf_vlan_id++;
+                        }
+                        break;
+                }
+        }
 
         /* If FCF not available return 0 */
         if (!bf_get(lpfc_fcf_record_fcf_avail, new_fcf_record) ||
                 !bf_get(lpfc_fcf_record_fcf_valid, new_fcf_record))
                 return 0;
 
-        if (!phba->cfg_enable_fip) {
+        if (!(phba->hba_flag & HBA_FIP_SUPPORT)) {
                 *boot_flag = 0;
                 *addr_mode = bf_get(lpfc_fcf_record_mac_addr_prov,
                                 new_fcf_record);
@@ -1286,11 +1349,16 @@ lpfc_match_fcf_conn_list(struct lpfc_hba *phba,
                 if (*addr_mode & LPFC_FCF_FPMA)
                         *addr_mode = LPFC_FCF_FPMA;
 
-                *vlan_id = 0xFFFF;
+                /* If FCF record report a vlan id use that vlan id */
+                if (fcf_vlan_id)
+                        *vlan_id = fcf_vlan_id;
+                else
+                        *vlan_id = 0xFFFF;
                 return 1;
         }
 
-        list_for_each_entry(conn_entry, &phba->fcf_conn_rec_list, list) {
+        list_for_each_entry(conn_entry,
+                            &phba->fcf_conn_rec_list, list) {
                 if (!(conn_entry->conn_rec.flags & FCFCNCT_VALID))
                         continue;
 
@@ -1384,8 +1452,15 @@ lpfc_match_fcf_conn_list(struct lpfc_hba *phba,
                         (*addr_mode & LPFC_FCF_FPMA))
                                 *addr_mode = LPFC_FCF_FPMA;
 
+                /* If matching connect list has a vlan id, use it */
                 if (conn_entry->conn_rec.flags & FCFCNCT_VLAN_VALID)
                         *vlan_id = conn_entry->conn_rec.vlan_tag;
+                /*
+                 * If no vlan id is specified in connect list, use the vlan id
+                 * in the FCF record
+                 */
+                else if (fcf_vlan_id)
+                        *vlan_id = fcf_vlan_id;
                 else
                         *vlan_id = 0xFFFF;
 
@@ -1407,8 +1482,6 @@ lpfc_match_fcf_conn_list(struct lpfc_hba *phba,
 int
 lpfc_check_pending_fcoe_event(struct lpfc_hba *phba, uint8_t unreg_fcf)
 {
-        LPFC_MBOXQ_t *mbox;
-        int rc;
         /*
          * If the Link is up and no FCoE events while in the
          * FCF discovery, no need to restart FCF discovery.
@@ -1417,75 +1490,70 @@ lpfc_check_pending_fcoe_event(struct lpfc_hba *phba, uint8_t unreg_fcf)
                 (phba->fcoe_eventtag == phba->fcoe_eventtag_at_fcf_scan))
                 return 0;
 
+        lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
+                        "2768 Pending link or FCF event during current "
+                        "handling of the previous event: link_state:x%x, "
+                        "evt_tag_at_scan:x%x, evt_tag_current:x%x\n",
+                        phba->link_state, phba->fcoe_eventtag_at_fcf_scan,
+                        phba->fcoe_eventtag);
+
         spin_lock_irq(&phba->hbalock);
         phba->fcf.fcf_flag &= ~FCF_AVAILABLE;
         spin_unlock_irq(&phba->hbalock);
 
-        if (phba->link_state >= LPFC_LINK_UP)
-                lpfc_sli4_read_fcf_record(phba, LPFC_FCOE_FCF_GET_FIRST);
+        if (phba->link_state >= LPFC_LINK_UP) {
+                lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
+                                "2780 Restart FCF table scan due to "
+                                "pending FCF event:evt_tag_at_scan:x%x, "
+                                "evt_tag_current:x%x\n",
+                                phba->fcoe_eventtag_at_fcf_scan,
+                                phba->fcoe_eventtag);
+                lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST);
+        } else {
+                /*
+                 * Do not continue FCF discovery and clear FCF_DISC_INPROGRESS
+                 * flag
+                 */
+                spin_lock_irq(&phba->hbalock);
+                phba->hba_flag &= ~FCF_DISC_INPROGRESS;
+                phba->fcf.fcf_flag &= ~(FCF_REDISC_FOV | FCF_DISCOVERY);
+                spin_unlock_irq(&phba->hbalock);
+        }
 
+        /* Unregister the currently registered FCF if required */
         if (unreg_fcf) {
                 spin_lock_irq(&phba->hbalock);
                 phba->fcf.fcf_flag &= ~FCF_REGISTERED;
                 spin_unlock_irq(&phba->hbalock);
-                mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
-                if (!mbox) {
-                        lpfc_printf_log(phba, KERN_ERR,
-                                LOG_DISCOVERY|LOG_MBOX,
-                                "2610 UNREG_FCFI mbox allocation failed\n");
-                        return 1;
-                }
-                lpfc_unreg_fcfi(mbox, phba->fcf.fcfi);
-                mbox->vport = phba->pport;
-                mbox->mbox_cmpl = lpfc_unregister_fcfi_cmpl;
-                rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
-                if (rc == MBX_NOT_FINISHED) {
-                        lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
-                                "2611 UNREG_FCFI issue mbox failed\n");
-                        mempool_free(mbox, phba->mbox_mem_pool);
-                }
+                lpfc_sli4_unregister_fcf(phba);
         }
-
         return 1;
 }
 
 /**
- * lpfc_mbx_cmpl_read_fcf_record - Completion handler for read_fcf mbox.
+ * lpfc_sli4_fcf_rec_mbox_parse - parse non-embedded fcf record mailbox command
  * @phba: pointer to lpfc hba data structure.
  * @mboxq: pointer to mailbox object.
+ * @next_fcf_index: pointer to holder of next fcf index.
  *
- * This function iterate through all the fcf records available in
- * HBA and choose the optimal FCF record for discovery. After finding
- * the FCF for discovery it register the FCF record and kick start
- * discovery.
- * If FCF_IN_USE flag is set in currently used FCF, the routine try to
- * use a FCF record which match fabric name and mac address of the
- * currently used FCF record.
- * If the driver support only one FCF, it will try to use the FCF record
- * used by BOOT_BIOS.
+ * This routine parses the non-embedded fcf mailbox command by performing the
+ * necessarily error checking, non-embedded read FCF record mailbox command
+ * SGE parsing, and endianness swapping.
+ *
+ * Returns the pointer to the new FCF record in the non-embedded mailbox
+ * command DMA memory if successfully, other NULL.
  */
-void
-lpfc_mbx_cmpl_read_fcf_record(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
+static struct fcf_record *
+lpfc_sli4_fcf_rec_mbox_parse(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq,
+                             uint16_t *next_fcf_index)
 {
         void *virt_addr;
         dma_addr_t phys_addr;
-        uint8_t *bytep;
         struct lpfc_mbx_sge sge;
         struct lpfc_mbx_read_fcf_tbl *read_fcf;
         uint32_t shdr_status, shdr_add_status;
         union lpfc_sli4_cfg_shdr *shdr;
         struct fcf_record *new_fcf_record;
-        int rc;
-        uint32_t boot_flag, addr_mode;
-        uint32_t next_fcf_index;
-        unsigned long flags;
-        uint16_t vlan_id;
-
-        /* If there is pending FCoE event restart FCF table scan */
-        if (lpfc_check_pending_fcoe_event(phba, 0)) {
-                lpfc_sli4_mbox_cmd_free(phba, mboxq);
-                return;
-        }
 
         /* Get the first SGE entry from the non-embedded DMA memory. This
          * routine only uses a single SGE.
@@ -1496,134 +1564,359 @@ lpfc_mbx_cmpl_read_fcf_record(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
                                 "2524 Failed to get the non-embedded SGE "
                                 "virtual address\n");
-                goto out;
+                return NULL;
         }
         virt_addr = mboxq->sge_array->addr[0];
 
         shdr = (union lpfc_sli4_cfg_shdr *)virt_addr;
         shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
-        shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
-                                 &shdr->response);
-        /*
-         * The FCF Record was read and there is no reason for the driver
-         * to maintain the FCF record data or memory. Instead, just need
-         * to book keeping the FCFIs can be used.
-         */
+        shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
         if (shdr_status || shdr_add_status) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "2521 READ_FCF_RECORD mailbox failed "
-                                "with status x%x add_status x%x, mbx\n",
-                                shdr_status, shdr_add_status);
-                goto out;
+                if (shdr_status == STATUS_FCF_TABLE_EMPTY)
+                        lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
+                                        "2726 READ_FCF_RECORD Indicates empty "
+                                        "FCF table.\n");
+                else
+                        lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
+                                        "2521 READ_FCF_RECORD mailbox failed "
+                                        "with status x%x add_status x%x, "
+                                        "mbx\n", shdr_status, shdr_add_status);
+                return NULL;
         }
-        /* Interpreting the returned information of FCF records */
+
+        /* Interpreting the returned information of the FCF record */
         read_fcf = (struct lpfc_mbx_read_fcf_tbl *)virt_addr;
         lpfc_sli_pcimem_bcopy(read_fcf, read_fcf,
                               sizeof(struct lpfc_mbx_read_fcf_tbl));
-        next_fcf_index = bf_get(lpfc_mbx_read_fcf_tbl_nxt_vindx, read_fcf);
-
+        *next_fcf_index = bf_get(lpfc_mbx_read_fcf_tbl_nxt_vindx, read_fcf);
         new_fcf_record = (struct fcf_record *)(virt_addr +
                           sizeof(struct lpfc_mbx_read_fcf_tbl));
         lpfc_sli_pcimem_bcopy(new_fcf_record, new_fcf_record,
                               sizeof(struct fcf_record));
-        bytep = virt_addr + sizeof(union lpfc_sli4_cfg_shdr);
 
-        rc = lpfc_match_fcf_conn_list(phba, new_fcf_record,
-                                      &boot_flag, &addr_mode,
-                                        &vlan_id);
+        return new_fcf_record;
+}
+
+/**
+ * lpfc_sli4_log_fcf_record_info - Log the information of a fcf record
+ * @phba: pointer to lpfc hba data structure.
+ * @fcf_record: pointer to the fcf record.
+ * @vlan_id: the lowest vlan identifier associated to this fcf record.
+ * @next_fcf_index: the index to the next fcf record in hba's fcf table.
+ *
+ * This routine logs the detailed FCF record if the LOG_FIP loggin is
+ * enabled.
+ **/
+static void
+lpfc_sli4_log_fcf_record_info(struct lpfc_hba *phba,
+                              struct fcf_record *fcf_record,
+                              uint16_t vlan_id,
+                              uint16_t next_fcf_index)
+{
+        lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
+                        "2764 READ_FCF_RECORD:\n"
+                        "\tFCF_Index     : x%x\n"
+                        "\tFCF_Avail     : x%x\n"
+                        "\tFCF_Valid     : x%x\n"
+                        "\tFIP_Priority  : x%x\n"
+                        "\tMAC_Provider  : x%x\n"
+                        "\tLowest VLANID : x%x\n"
+                        "\tFCF_MAC Addr  : x%x:%x:%x:%x:%x:%x\n"
+                        "\tFabric_Name   : x%x:%x:%x:%x:%x:%x:%x:%x\n"
+                        "\tSwitch_Name   : x%x:%x:%x:%x:%x:%x:%x:%x\n"
+                        "\tNext_FCF_Index: x%x\n",
+                        bf_get(lpfc_fcf_record_fcf_index, fcf_record),
+                        bf_get(lpfc_fcf_record_fcf_avail, fcf_record),
+                        bf_get(lpfc_fcf_record_fcf_valid, fcf_record),
+                        fcf_record->fip_priority,
+                        bf_get(lpfc_fcf_record_mac_addr_prov, fcf_record),
+                        vlan_id,
+                        bf_get(lpfc_fcf_record_mac_0, fcf_record),
+                        bf_get(lpfc_fcf_record_mac_1, fcf_record),
+                        bf_get(lpfc_fcf_record_mac_2, fcf_record),
+                        bf_get(lpfc_fcf_record_mac_3, fcf_record),
+                        bf_get(lpfc_fcf_record_mac_4, fcf_record),
+                        bf_get(lpfc_fcf_record_mac_5, fcf_record),
+                        bf_get(lpfc_fcf_record_fab_name_0, fcf_record),
+                        bf_get(lpfc_fcf_record_fab_name_1, fcf_record),
+                        bf_get(lpfc_fcf_record_fab_name_2, fcf_record),
+                        bf_get(lpfc_fcf_record_fab_name_3, fcf_record),
+                        bf_get(lpfc_fcf_record_fab_name_4, fcf_record),
+                        bf_get(lpfc_fcf_record_fab_name_5, fcf_record),
+                        bf_get(lpfc_fcf_record_fab_name_6, fcf_record),
+                        bf_get(lpfc_fcf_record_fab_name_7, fcf_record),
+                        bf_get(lpfc_fcf_record_switch_name_0, fcf_record),
+                        bf_get(lpfc_fcf_record_switch_name_1, fcf_record),
+                        bf_get(lpfc_fcf_record_switch_name_2, fcf_record),
+                        bf_get(lpfc_fcf_record_switch_name_3, fcf_record),
+                        bf_get(lpfc_fcf_record_switch_name_4, fcf_record),
+                        bf_get(lpfc_fcf_record_switch_name_5, fcf_record),
+                        bf_get(lpfc_fcf_record_switch_name_6, fcf_record),
+                        bf_get(lpfc_fcf_record_switch_name_7, fcf_record),
+                        next_fcf_index);
+}
+
+/**
+ * lpfc_mbx_cmpl_fcf_scan_read_fcf_rec - fcf scan read_fcf mbox cmpl handler.
+ * @phba: pointer to lpfc hba data structure.
+ * @mboxq: pointer to mailbox object.
+ *
+ * This function iterates through all the fcf records available in
+ * HBA and chooses the optimal FCF record for discovery. After finding
+ * the FCF for discovery it registers the FCF record and kicks start
+ * discovery.
+ * If FCF_IN_USE flag is set in currently used FCF, the routine tries to
+ * use an FCF record which matches fabric name and mac address of the
+ * currently used FCF record.
+ * If the driver supports only one FCF, it will try to use the FCF record
+ * used by BOOT_BIOS.
+ */
+void
+lpfc_mbx_cmpl_fcf_scan_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
+{
+        struct fcf_record *new_fcf_record;
+        uint32_t boot_flag, addr_mode;
+        uint16_t fcf_index, next_fcf_index;
+        struct lpfc_fcf_rec *fcf_rec = NULL;
+        uint16_t vlan_id;
+        int rc;
+
+        /* If there is pending FCoE event restart FCF table scan */
+        if (lpfc_check_pending_fcoe_event(phba, 0)) {
+                lpfc_sli4_mbox_cmd_free(phba, mboxq);
+                return;
+        }
+
+        /* Parse the FCF record from the non-embedded mailbox command */
+        new_fcf_record = lpfc_sli4_fcf_rec_mbox_parse(phba, mboxq,
+                                                      &next_fcf_index);
+        if (!new_fcf_record) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_FIP,
+                                "2765 Mailbox command READ_FCF_RECORD "
+                                "failed to retrieve a FCF record.\n");
+                /* Let next new FCF event trigger fast failover */
+                spin_lock_irq(&phba->hbalock);
+                phba->hba_flag &= ~FCF_DISC_INPROGRESS;
+                spin_unlock_irq(&phba->hbalock);
+                lpfc_sli4_mbox_cmd_free(phba, mboxq);
+                return;
+        }
+
+        /* Check the FCF record against the connection list */
+        rc = lpfc_match_fcf_conn_list(phba, new_fcf_record, &boot_flag,
+                                      &addr_mode, &vlan_id);
+
+        /* Log the FCF record information if turned on */
+        lpfc_sli4_log_fcf_record_info(phba, new_fcf_record, vlan_id,
+                                      next_fcf_index);
+
         /*
          * If the fcf record does not match with connect list entries
-         * read the next entry.
+         * read the next entry; otherwise, this is an eligible FCF
+         * record for round robin FCF failover.
          */
-        if (!rc)
+        if (!rc) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_FIP,
+                                "2781 FCF record fcf_index:x%x failed FCF "
+                                "connection list check, fcf_avail:x%x, "
+                                "fcf_valid:x%x\n",
+                                bf_get(lpfc_fcf_record_fcf_index,
+                                       new_fcf_record),
+                                bf_get(lpfc_fcf_record_fcf_avail,
+                                       new_fcf_record),
+                                bf_get(lpfc_fcf_record_fcf_valid,
+                                       new_fcf_record));
                 goto read_next_fcf;
+        } else {
+                fcf_index = bf_get(lpfc_fcf_record_fcf_index, new_fcf_record);
+                rc = lpfc_sli4_fcf_rr_index_set(phba, fcf_index);
+                if (rc)
+                        goto read_next_fcf;
+        }
+
         /*
          * If this is not the first FCF discovery of the HBA, use last
-         * FCF record for the discovery.
+         * FCF record for the discovery. The condition that a rescan
+         * matches the in-use FCF record: fabric name, switch name, mac
+         * address, and vlan_id.
          */
-        spin_lock_irqsave(&phba->hbalock, flags);
+        spin_lock_irq(&phba->hbalock);
         if (phba->fcf.fcf_flag & FCF_IN_USE) {
-                if (lpfc_fab_name_match(phba->fcf.fabric_name,
+                if (lpfc_fab_name_match(phba->fcf.current_rec.fabric_name,
+                                        new_fcf_record) &&
+                    lpfc_sw_name_match(phba->fcf.current_rec.switch_name,
                                         new_fcf_record) &&
-                    lpfc_sw_name_match(phba->fcf.switch_name,
+                    lpfc_mac_addr_match(phba->fcf.current_rec.mac_addr,
                                         new_fcf_record) &&
-                    lpfc_mac_addr_match(phba, new_fcf_record)) {
+                    lpfc_vlan_id_match(phba->fcf.current_rec.vlan_id,
+                                        vlan_id)) {
                         phba->fcf.fcf_flag |= FCF_AVAILABLE;
-                        spin_unlock_irqrestore(&phba->hbalock, flags);
+                        if (phba->fcf.fcf_flag & FCF_REDISC_PEND)
+                                /* Stop FCF redisc wait timer if pending */
+                                __lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
+                        else if (phba->fcf.fcf_flag & FCF_REDISC_FOV)
+                                /* If in fast failover, mark it's completed */
+                                phba->fcf.fcf_flag &= ~(FCF_REDISC_FOV |
+                                                        FCF_DISCOVERY);
+                        spin_unlock_irq(&phba->hbalock);
                         goto out;
                 }
-                spin_unlock_irqrestore(&phba->hbalock, flags);
-                goto read_next_fcf;
+                /*
+                 * Read next FCF record from HBA searching for the matching
+                 * with in-use record only if not during the fast failover
+                 * period. In case of fast failover period, it shall try to
+                 * determine whether the FCF record just read should be the
+                 * next candidate.
+                 */
+                if (!(phba->fcf.fcf_flag & FCF_REDISC_FOV)) {
+                        spin_unlock_irq(&phba->hbalock);
+                        goto read_next_fcf;
+                }
         }
+        /*
+         * Update on failover FCF record only if it's in FCF fast-failover
+         * period; otherwise, update on current FCF record.
+         */
+        if (phba->fcf.fcf_flag & FCF_REDISC_FOV)
+                fcf_rec = &phba->fcf.failover_rec;
+        else
+                fcf_rec = &phba->fcf.current_rec;
+
         if (phba->fcf.fcf_flag & FCF_AVAILABLE) {
                 /*
-                 * If the current FCF record does not have boot flag
-                 * set and new fcf record has boot flag set, use the
-                 * new fcf record.
+                 * If the driver FCF record does not have boot flag
+                 * set and new hba fcf record has boot flag set, use
+                 * the new hba fcf record.
                  */
-                if (boot_flag && !(phba->fcf.fcf_flag & FCF_BOOT_ENABLE)) {
-                        /* Use this FCF record */
-                        lpfc_copy_fcf_record(phba, new_fcf_record);
-                        phba->fcf.addr_mode = addr_mode;
-                        phba->fcf.fcf_flag |= FCF_BOOT_ENABLE;
-                        if (vlan_id != 0xFFFF) {
-                                phba->fcf.fcf_flag |= FCF_VALID_VLAN;
-                                phba->fcf.vlan_id = vlan_id;
-                        }
-                        spin_unlock_irqrestore(&phba->hbalock, flags);
+                if (boot_flag && !(fcf_rec->flag & BOOT_ENABLE)) {
+                        /* Choose this FCF record */
+                        __lpfc_update_fcf_record(phba, fcf_rec, new_fcf_record,
+                                        addr_mode, vlan_id, BOOT_ENABLE);
+                        spin_unlock_irq(&phba->hbalock);
                         goto read_next_fcf;
                 }
                 /*
-                 * If the current FCF record has boot flag set and the
-                 * new FCF record does not have boot flag, read the next
-                 * FCF record.
+                 * If the driver FCF record has boot flag set and the
+                 * new hba FCF record does not have boot flag, read
+                 * the next FCF record.
                  */
-                if (!boot_flag && (phba->fcf.fcf_flag & FCF_BOOT_ENABLE)) {
-                        spin_unlock_irqrestore(&phba->hbalock, flags);
+                if (!boot_flag && (fcf_rec->flag & BOOT_ENABLE)) {
+                        spin_unlock_irq(&phba->hbalock);
                         goto read_next_fcf;
                 }
                 /*
-                 * If there is a record with lower priority value for
-                 * the current FCF, use that record.
+                 * If the new hba FCF record has lower priority value
+                 * than the driver FCF record, use the new record.
                  */
-                if (lpfc_fab_name_match(phba->fcf.fabric_name,
-                                        new_fcf_record) &&
-                    (new_fcf_record->fip_priority < phba->fcf.priority)) {
-                        /* Use this FCF record */
-                        lpfc_copy_fcf_record(phba, new_fcf_record);
-                        phba->fcf.addr_mode = addr_mode;
-                        if (vlan_id != 0xFFFF) {
-                                phba->fcf.fcf_flag |= FCF_VALID_VLAN;
-                                phba->fcf.vlan_id = vlan_id;
-                        }
-                        spin_unlock_irqrestore(&phba->hbalock, flags);
-                        goto read_next_fcf;
+                if (new_fcf_record->fip_priority < fcf_rec->priority) {
+                        /* Choose this FCF record */
+                        __lpfc_update_fcf_record(phba, fcf_rec, new_fcf_record,
+                                        addr_mode, vlan_id, 0);
                 }
-                spin_unlock_irqrestore(&phba->hbalock, flags);
+                spin_unlock_irq(&phba->hbalock);
                 goto read_next_fcf;
         }
         /*
-         * This is the first available FCF record, use this
-         * record.
+         * This is the first suitable FCF record, choose this record for
+         * initial best-fit FCF.
          */
-        lpfc_copy_fcf_record(phba, new_fcf_record);
-        phba->fcf.addr_mode = addr_mode;
-        if (boot_flag)
-                phba->fcf.fcf_flag |= FCF_BOOT_ENABLE;
-        phba->fcf.fcf_flag |= FCF_AVAILABLE;
-        if (vlan_id != 0xFFFF) {
-                phba->fcf.fcf_flag |= FCF_VALID_VLAN;
-                phba->fcf.vlan_id = vlan_id;
+        if (fcf_rec) {
+                __lpfc_update_fcf_record(phba, fcf_rec, new_fcf_record,
+                                         addr_mode, vlan_id, (boot_flag ?
+                                         BOOT_ENABLE : 0));
+                phba->fcf.fcf_flag |= FCF_AVAILABLE;
         }
-        spin_unlock_irqrestore(&phba->hbalock, flags);
+        spin_unlock_irq(&phba->hbalock);
         goto read_next_fcf;
 
 read_next_fcf:
         lpfc_sli4_mbox_cmd_free(phba, mboxq);
-        if (next_fcf_index == LPFC_FCOE_FCF_NEXT_NONE || next_fcf_index == 0)
-                lpfc_register_fcf(phba);
-        else
-                lpfc_sli4_read_fcf_record(phba, next_fcf_index);
+        if (next_fcf_index == LPFC_FCOE_FCF_NEXT_NONE || next_fcf_index == 0) {
+                if (phba->fcf.fcf_flag & FCF_REDISC_FOV) {
+                        /*
+                         * Case of FCF fast failover scan
+                         */
+
+                        /*
+                         * It has not found any suitable FCF record, cancel
+                         * FCF scan inprogress, and do nothing
+                         */
+                        if (!(phba->fcf.failover_rec.flag & RECORD_VALID)) {
+                                lpfc_printf_log(phba, KERN_WARNING, LOG_FIP,
+                                               "2782 No suitable FCF record "
+                                               "found during this round of "
+                                               "post FCF rediscovery scan: "
+                                               "fcf_evt_tag:x%x, fcf_index: "
+                                               "x%x\n",
+                                               phba->fcoe_eventtag_at_fcf_scan,
+                                               bf_get(lpfc_fcf_record_fcf_index,
+                                                      new_fcf_record));
+                                /*
+                                 * Let next new FCF event trigger fast
+                                 * failover
+                                 */
+                                spin_lock_irq(&phba->hbalock);
+                                phba->hba_flag &= ~FCF_DISC_INPROGRESS;
+                                spin_unlock_irq(&phba->hbalock);
+                                return;
+                        }
+                        /*
+                         * It has found a suitable FCF record that is not
+                         * the same as in-use FCF record, unregister the
+                         * in-use FCF record, replace the in-use FCF record
+                         * with the new FCF record, mark FCF fast failover
+                         * completed, and then start register the new FCF
+                         * record.
+                         */
+
+                        /* Unregister the current in-use FCF record */
+                        lpfc_unregister_fcf(phba);
+
+                        /* Replace in-use record with the new record */
+                        memcpy(&phba->fcf.current_rec,
+                               &phba->fcf.failover_rec,
+                               sizeof(struct lpfc_fcf_rec));
+                        /* mark the FCF fast failover completed */
+                        spin_lock_irq(&phba->hbalock);
+                        phba->fcf.fcf_flag &= ~FCF_REDISC_FOV;
+                        spin_unlock_irq(&phba->hbalock);
+                        /*
+                         * Set up the initial registered FCF index for FLOGI
+                         * round robin FCF failover.
+                         */
+                        phba->fcf.fcf_rr_init_indx =
+                                        phba->fcf.failover_rec.fcf_indx;
+                        /* Register to the new FCF record */
+                        lpfc_register_fcf(phba);
+                } else {
+                        /*
+                         * In case of transaction period to fast FCF failover,
+                         * do nothing when search to the end of the FCF table.
+                         */
+                        if ((phba->fcf.fcf_flag & FCF_REDISC_EVT) ||
+                            (phba->fcf.fcf_flag & FCF_REDISC_PEND))
+                                return;
+                        /*
+                         * Otherwise, initial scan or post linkdown rescan,
+                         * register with the best FCF record found so far
+                         * through the FCF scanning process.
+                         */
+
+                        /* mark the initial FCF discovery completed */
+                        spin_lock_irq(&phba->hbalock);
+                        phba->fcf.fcf_flag &= ~FCF_INIT_DISC;
+                        spin_unlock_irq(&phba->hbalock);
+                        /*
+                         * Set up the initial registered FCF index for FLOGI
+                         * round robin FCF failover
+                         */
+                        phba->fcf.fcf_rr_init_indx =
+                                        phba->fcf.current_rec.fcf_indx;
+                        /* Register to the new FCF record */
+                        lpfc_register_fcf(phba);
+                }
+        } else
+                lpfc_sli4_fcf_scan_read_fcf_rec(phba, next_fcf_index);
         return;
 
 out:
@@ -1634,16 +1927,154 @@ out:
 }
 
 /**
+ * lpfc_mbx_cmpl_fcf_rr_read_fcf_rec - fcf round robin read_fcf mbox cmpl hdler
+ * @phba: pointer to lpfc hba data structure.
+ * @mboxq: pointer to mailbox object.
+ *
+ * This is the callback function for FLOGI failure round robin FCF failover
+ * read FCF record mailbox command from the eligible FCF record bmask for
+ * performing the failover. If the FCF read back is not valid/available, it
+ * fails through to retrying FLOGI to the currently registered FCF again.
+ * Otherwise, if the FCF read back is valid and available, it will set the
+ * newly read FCF record to the failover FCF record, unregister currently
+ * registered FCF record, copy the failover FCF record to the current
+ * FCF record, and then register the current FCF record before proceeding
+ * to trying FLOGI on the new failover FCF.
+ */
+void
+lpfc_mbx_cmpl_fcf_rr_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
+{
+        struct fcf_record *new_fcf_record;
+        uint32_t boot_flag, addr_mode;
+        uint16_t next_fcf_index;
+        uint16_t current_fcf_index;
+        uint16_t vlan_id;
+
+        /* If link state is not up, stop the round robin failover process */
+        if (phba->link_state < LPFC_LINK_UP) {
+                spin_lock_irq(&phba->hbalock);
+                phba->fcf.fcf_flag &= ~FCF_DISCOVERY;
+                spin_unlock_irq(&phba->hbalock);
+                lpfc_sli4_mbox_cmd_free(phba, mboxq);
+                return;
+        }
+
+        /* Parse the FCF record from the non-embedded mailbox command */
+        new_fcf_record = lpfc_sli4_fcf_rec_mbox_parse(phba, mboxq,
+                                                      &next_fcf_index);
+        if (!new_fcf_record) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_FIP,
+                                "2766 Mailbox command READ_FCF_RECORD "
+                                "failed to retrieve a FCF record.\n");
+                goto out;
+        }
+
+        /* Get the needed parameters from FCF record */
+        lpfc_match_fcf_conn_list(phba, new_fcf_record, &boot_flag,
+                                 &addr_mode, &vlan_id);
+
+        /* Log the FCF record information if turned on */
+        lpfc_sli4_log_fcf_record_info(phba, new_fcf_record, vlan_id,
+                                      next_fcf_index);
+
+        /* Upload new FCF record to the failover FCF record */
+        spin_lock_irq(&phba->hbalock);
+        __lpfc_update_fcf_record(phba, &phba->fcf.failover_rec,
+                                 new_fcf_record, addr_mode, vlan_id,
+                                 (boot_flag ? BOOT_ENABLE : 0));
+        spin_unlock_irq(&phba->hbalock);
+
+        current_fcf_index = phba->fcf.current_rec.fcf_indx;
+
+        /* Unregister the current in-use FCF record */
+        lpfc_unregister_fcf(phba);
+
+        /* Replace in-use record with the new record */
+        memcpy(&phba->fcf.current_rec, &phba->fcf.failover_rec,
+               sizeof(struct lpfc_fcf_rec));
+
+        lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
+                        "2783 FLOGI round robin FCF failover from FCF "
+                        "(index:x%x) to FCF (index:x%x).\n",
+                        current_fcf_index,
+                        bf_get(lpfc_fcf_record_fcf_index, new_fcf_record));
+
+out:
+        lpfc_sli4_mbox_cmd_free(phba, mboxq);
+        lpfc_register_fcf(phba);
+}
+
+/**
+ * lpfc_mbx_cmpl_read_fcf_rec - read fcf completion handler.
+ * @phba: pointer to lpfc hba data structure.
+ * @mboxq: pointer to mailbox object.
+ *
+ * This is the callback function of read FCF record mailbox command for
+ * updating the eligible FCF bmask for FLOGI failure round robin FCF
+ * failover when a new FCF event happened. If the FCF read back is
+ * valid/available and it passes the connection list check, it updates
+ * the bmask for the eligible FCF record for round robin failover.
+ */
+void
+lpfc_mbx_cmpl_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
+{
+        struct fcf_record *new_fcf_record;
+        uint32_t boot_flag, addr_mode;
+        uint16_t fcf_index, next_fcf_index;
+        uint16_t vlan_id;
+        int rc;
+
+        /* If link state is not up, no need to proceed */
+        if (phba->link_state < LPFC_LINK_UP)
+                goto out;
+
+        /* If FCF discovery period is over, no need to proceed */
+        if (phba->fcf.fcf_flag & FCF_DISCOVERY)
+                goto out;
+
+        /* Parse the FCF record from the non-embedded mailbox command */
+        new_fcf_record = lpfc_sli4_fcf_rec_mbox_parse(phba, mboxq,
+                                                      &next_fcf_index);
+        if (!new_fcf_record) {
+                lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
+                                "2767 Mailbox command READ_FCF_RECORD "
+                                "failed to retrieve a FCF record.\n");
+                goto out;
+        }
+
+        /* Check the connection list for eligibility */
+        rc = lpfc_match_fcf_conn_list(phba, new_fcf_record, &boot_flag,
+                                      &addr_mode, &vlan_id);
+
+        /* Log the FCF record information if turned on */
+        lpfc_sli4_log_fcf_record_info(phba, new_fcf_record, vlan_id,
+                                      next_fcf_index);
+
+        if (!rc)
+                goto out;
+
+        /* Update the eligible FCF record index bmask */
+        fcf_index = bf_get(lpfc_fcf_record_fcf_index, new_fcf_record);
+        rc = lpfc_sli4_fcf_rr_index_set(phba, fcf_index);
+
+out:
+        lpfc_sli4_mbox_cmd_free(phba, mboxq);
+}
+
+/**
  * lpfc_init_vpi_cmpl - Completion handler for init_vpi mbox command.
  * @phba: pointer to lpfc hba data structure.
  * @mboxq: pointer to mailbox data structure.
  *
  * This function handles completion of init vpi mailbox command.
  */
-static void
+void
 lpfc_init_vpi_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
 {
         struct lpfc_vport *vport = mboxq->vport;
+        struct lpfc_nodelist *ndlp;
+        struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
+
         if (mboxq->u.mb.mbxStatus) {
                 lpfc_printf_vlog(vport, KERN_ERR,
                                 LOG_MBOX,
@@ -1653,20 +2084,67 @@ lpfc_init_vpi_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
                 return;
         }
+        spin_lock_irq(shost->host_lock);
         vport->fc_flag &= ~FC_VPORT_NEEDS_INIT_VPI;
+        spin_unlock_irq(shost->host_lock);
+
+        /* If this port is physical port or FDISC is done, do reg_vpi */
+        if ((phba->pport == vport) || (vport->port_state == LPFC_FDISC)) {
+                        ndlp = lpfc_findnode_did(vport, Fabric_DID);
+                        if (!ndlp)
+                                lpfc_printf_vlog(vport, KERN_ERR,
+                                        LOG_DISCOVERY,
+                                        "2731 Cannot find fabric "
+                                        "controller node\n");
+                        else
+                                lpfc_register_new_vport(phba, vport, ndlp);
+                        mempool_free(mboxq, phba->mbox_mem_pool);
+                        return;
+        }
 
         if (phba->link_flag & LS_NPIV_FAB_SUPPORTED)
                 lpfc_initial_fdisc(vport);
         else {
                 lpfc_vport_set_state(vport, FC_VPORT_NO_FABRIC_SUPP);
-                lpfc_printf_vlog(vport, KERN_ERR,
-                        LOG_ELS,
-                        "2606 No NPIV Fabric support\n");
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
+                                 "2606 No NPIV Fabric support\n");
         }
+        mempool_free(mboxq, phba->mbox_mem_pool);
         return;
 }
 
 /**
+ * lpfc_issue_init_vpi - Issue init_vpi mailbox command.
+ * @vport: pointer to lpfc_vport data structure.
+ *
+ * This function issue a init_vpi mailbox command to initialize
+ * VPI for the vport.
+ */
+void
+lpfc_issue_init_vpi(struct lpfc_vport *vport)
+{
+        LPFC_MBOXQ_t *mboxq;
+        int rc;
+
+        mboxq = mempool_alloc(vport->phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mboxq) {
+                lpfc_printf_vlog(vport, KERN_ERR,
+                        LOG_MBOX, "2607 Failed to allocate "
+                        "init_vpi mailbox\n");
+                return;
+        }
+        lpfc_init_vpi(vport->phba, mboxq, vport->vpi);
+        mboxq->vport = vport;
+        mboxq->mbox_cmpl = lpfc_init_vpi_cmpl;
+        rc = lpfc_sli_issue_mbox(vport->phba, mboxq, MBX_NOWAIT);
+        if (rc == MBX_NOT_FINISHED) {
+                lpfc_printf_vlog(vport, KERN_ERR,
+                        LOG_MBOX, "2608 Failed to issue init_vpi mailbox\n");
+                mempool_free(mboxq, vport->phba->mbox_mem_pool);
+        }
+}
+
+/**
  * lpfc_start_fdiscs - send fdiscs for each vports on this port.
  * @phba: pointer to lpfc hba data structure.
  *
@@ -1678,8 +2156,6 @@ lpfc_start_fdiscs(struct lpfc_hba *phba)
 {
         struct lpfc_vport **vports;
         int i;
-        LPFC_MBOXQ_t *mboxq;
-        int rc;
 
         vports = lpfc_create_vport_work_array(phba);
         if (vports != NULL) {
@@ -1698,26 +2174,7 @@ lpfc_start_fdiscs(struct lpfc_hba *phba)
                                 continue;
                         }
                         if (vports[i]->fc_flag & FC_VPORT_NEEDS_INIT_VPI) {
-                                mboxq = mempool_alloc(phba->mbox_mem_pool,
-                                        GFP_KERNEL);
-                                if (!mboxq) {
-                                        lpfc_printf_vlog(vports[i], KERN_ERR,
-                                        LOG_MBOX, "2607 Failed to allocate "
-                                        "init_vpi mailbox\n");
-                                        continue;
-                                }
-                                lpfc_init_vpi(phba, mboxq, vports[i]->vpi);
-                                mboxq->vport = vports[i];
-                                mboxq->mbox_cmpl = lpfc_init_vpi_cmpl;
-                                rc = lpfc_sli_issue_mbox(phba, mboxq,
-                                        MBX_NOWAIT);
-                                if (rc == MBX_NOT_FINISHED) {
-                                        lpfc_printf_vlog(vports[i], KERN_ERR,
-                                        LOG_MBOX, "2608 Failed to issue "
-                                        "init_vpi mailbox\n");
-                                        mempool_free(mboxq,
-                                                phba->mbox_mem_pool);
-                                }
+                                lpfc_issue_init_vpi(vports[i]);
                                 continue;
                         }
                         if (phba->link_flag & LS_NPIV_FAB_SUPPORTED)
@@ -1740,6 +2197,7 @@ lpfc_mbx_cmpl_reg_vfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
 {
         struct lpfc_dmabuf *dmabuf = mboxq->context1;
         struct lpfc_vport *vport = mboxq->vport;
+        struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 
         if (mboxq->u.mb.mbxStatus) {
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
@@ -1756,8 +2214,12 @@ lpfc_mbx_cmpl_reg_vfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
                 goto fail_free_mem;
         }
-        /* Mark the vport has registered with its VFI */
-        vport->vfi_state |= LPFC_VFI_REGISTERED;
+        /* The VPI is implicitly registered when the VFI is registered */
+        spin_lock_irq(shost->host_lock);
+        vport->vpi_state |= LPFC_VPI_REGISTERED;
+        vport->fc_flag |= FC_VFI_REGISTERED;
+        vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
+        spin_unlock_irq(shost->host_lock);
 
         if (vport->port_state == LPFC_FABRIC_CFG_LINK) {
                 lpfc_start_fdiscs(phba);
@@ -1831,8 +2293,6 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la)
         int rc;
         struct fcf_record *fcf_record;
 
-        sparam_mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
-
         spin_lock_irq(&phba->hbalock);
         switch (la->UlnkSpeed) {
         case LA_1GHZ_LINK:
@@ -1861,7 +2321,10 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la)
         if (phba->fc_topology == TOPOLOGY_LOOP) {
                 phba->sli3_options &= ~LPFC_SLI3_NPIV_ENABLED;
 
-                if (phba->cfg_enable_npiv)
+                /* if npiv is enabled and this adapter supports npiv log
+                 * a message that npiv is not supported in this topology
+                 */
+                if (phba->cfg_enable_npiv && phba->max_vpi)
                         lpfc_printf_log(phba, KERN_ERR, LOG_LINK_EVENT,
                                 "1309 Link Up Event npiv not supported in loop "
                                 "topology\n");
@@ -1921,18 +2384,24 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la)
         spin_unlock_irq(&phba->hbalock);
 
         lpfc_linkup(phba);
-        if (sparam_mbox) {
-                lpfc_read_sparam(phba, sparam_mbox, 0);
-                sparam_mbox->vport = vport;
-                sparam_mbox->mbox_cmpl = lpfc_mbx_cmpl_read_sparam;
-                rc = lpfc_sli_issue_mbox(phba, sparam_mbox, MBX_NOWAIT);
-                if (rc == MBX_NOT_FINISHED) {
-                        mp = (struct lpfc_dmabuf *) sparam_mbox->context1;
-                        lpfc_mbuf_free(phba, mp->virt, mp->phys);
-                        kfree(mp);
-                        mempool_free(sparam_mbox, phba->mbox_mem_pool);
-                        goto out;
-                }
+        sparam_mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!sparam_mbox)
+                goto out;
+
+        rc = lpfc_read_sparam(phba, sparam_mbox, 0);
+        if (rc) {
+                mempool_free(sparam_mbox, phba->mbox_mem_pool);
+                goto out;
+        }
+        sparam_mbox->vport = vport;
+        sparam_mbox->mbox_cmpl = lpfc_mbx_cmpl_read_sparam;
+        rc = lpfc_sli_issue_mbox(phba, sparam_mbox, MBX_NOWAIT);
+        if (rc == MBX_NOT_FINISHED) {
+                mp = (struct lpfc_dmabuf *) sparam_mbox->context1;
+                lpfc_mbuf_free(phba, mp->virt, mp->phys);
+                kfree(mp);
+                mempool_free(sparam_mbox, phba->mbox_mem_pool);
+                goto out;
         }
 
         if (!(phba->hba_flag & HBA_FCOE_SUPPORT)) {
@@ -1955,7 +2424,7 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la)
                  * is phase 1 implementation that support FCF index 0 and driver
                  * defaults.
                  */
-                if (phba->cfg_enable_fip == 0) {
+                if (!(phba->hba_flag & HBA_FIP_SUPPORT)) {
                         fcf_record = kzalloc(sizeof(struct fcf_record),
                                         GFP_KERNEL);
                         if (unlikely(!fcf_record)) {
@@ -1990,11 +2459,20 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la)
                         spin_unlock_irq(&phba->hbalock);
                         return;
                 }
+                /* This is the initial FCF discovery scan */
+                phba->fcf.fcf_flag |= FCF_INIT_DISC;
                 spin_unlock_irq(&phba->hbalock);
-                rc = lpfc_sli4_read_fcf_record(phba,
-                                        LPFC_FCOE_FCF_GET_FIRST);
-                if (rc)
+                lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
+                                "2778 Start FCF table scan at linkup\n");
+
+                rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba,
+                                                     LPFC_FCOE_FCF_GET_FIRST);
+                if (rc) {
+                        spin_lock_irq(&phba->hbalock);
+                        phba->fcf.fcf_flag &= ~FCF_INIT_DISC;
+                        spin_unlock_irq(&phba->hbalock);
                         goto out;
+                }
         }
 
         return;
@@ -2080,11 +2558,14 @@ lpfc_mbx_cmpl_read_la(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         }
 
         phba->fc_eventTag = la->eventTag;
+        spin_lock_irq(&phba->hbalock);
         if (la->mm)
                 phba->sli.sli_flag |= LPFC_MENLO_MAINT;
         else
                 phba->sli.sli_flag &= ~LPFC_MENLO_MAINT;
+        spin_unlock_irq(&phba->hbalock);
 
+        phba->link_events++;
         if (la->attType == AT_LINK_UP && (!la->mm)) {
                 phba->fc_stat.LinkUp++;
                 if (phba->link_flag & LS_LOOPBACK_MODE) {
@@ -2211,13 +2692,17 @@ lpfc_mbx_cmpl_unreg_vpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                                  mb->mbxStatus);
                 break;
         }
+        spin_lock_irq(shost->host_lock);
+        vport->vpi_state &= ~LPFC_VPI_REGISTERED;
+        vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
+        spin_unlock_irq(shost->host_lock);
         vport->unreg_vpi_cmpl = VPORT_OK;
         mempool_free(pmb, phba->mbox_mem_pool);
         /*
          * This shost reference might have been taken at the beginning of
          * lpfc_vport_delete()
          */
-        if (vport->load_flag & FC_UNLOADING)
+        if ((vport->load_flag & FC_UNLOADING) && (vport != phba->pport))
                 scsi_host_put(shost);
 }
 
@@ -2268,6 +2753,10 @@ lpfc_mbx_cmpl_reg_vpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                 goto out;
         }
 
+        spin_lock_irq(shost->host_lock);
+        vport->vpi_state |= LPFC_VPI_REGISTERED;
+        vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
+        spin_unlock_irq(shost->host_lock);
         vport->num_disc_nodes = 0;
         /* go thru NPR list and issue ELS PLOGIs */
         if (vport->fc_npr_cnt)
@@ -3077,7 +3566,7 @@ lpfc_no_rpi(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
         struct lpfc_sli *psli;
         struct lpfc_sli_ring *pring;
         struct lpfc_iocbq *iocb, *next_iocb;
-        uint32_t rpi, i;
+        uint32_t i;
 
         lpfc_fabric_abort_nport(ndlp);
 
@@ -3086,7 +3575,6 @@ lpfc_no_rpi(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
          * by firmware with a no rpi error.
          */
         psli = &phba->sli;
-        rpi = ndlp->nlp_rpi;
         if (ndlp->nlp_flag & NLP_RPI_VALID) {
                 /* Now process each ring */
                 for (i = 0; i < psli->num_rings; i++) {
@@ -3154,6 +3642,38 @@ lpfc_unreg_rpi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
         return 0;
 }
 
+/**
+ * lpfc_unreg_hba_rpis - Unregister rpis registered to the hba.
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is invoked to unregister all the currently registered RPIs
+ * to the HBA.
+ **/
+void
+lpfc_unreg_hba_rpis(struct lpfc_hba *phba)
+{
+        struct lpfc_vport **vports;
+        struct lpfc_nodelist *ndlp;
+        struct Scsi_Host *shost;
+        int i;
+
+        vports = lpfc_create_vport_work_array(phba);
+        for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
+                shost = lpfc_shost_from_vport(vports[i]);
+                spin_lock_irq(shost->host_lock);
+                list_for_each_entry(ndlp, &vports[i]->fc_nodes, nlp_listp) {
+                        if (ndlp->nlp_flag & NLP_RPI_VALID) {
+                                /* The mempool_alloc might sleep */
+                                spin_unlock_irq(shost->host_lock);
+                                lpfc_unreg_rpi(vports[i], ndlp);
+                                spin_lock_irq(shost->host_lock);
+                        }
+                }
+                spin_unlock_irq(shost->host_lock);
+        }
+        lpfc_destroy_vport_work_array(phba, vports);
+}
+
 void
 lpfc_unreg_all_rpis(struct lpfc_vport *vport)
 {
@@ -4322,6 +4842,14 @@ lpfc_fcf_inuse(struct lpfc_hba *phba)
                                 ret = 1;
                                 spin_unlock_irq(shost->host_lock);
                                 goto out;
+                        } else {
+                                lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
+                                        "2624 RPI %x DID %x flg %x still "
+                                        "logged in\n",
+                                        ndlp->nlp_rpi, ndlp->nlp_DID,
+                                        ndlp->nlp_flag);
+                                if (ndlp->nlp_flag & NLP_RPI_VALID)
+                                        ret = 1;
                         }
                 }
                 spin_unlock_irq(shost->host_lock);
@@ -4376,120 +4904,231 @@ lpfc_unregister_fcfi_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
 }
 
 /**
- * lpfc_unregister_unused_fcf - Unregister FCF if all devices are disconnected.
+ * lpfc_unregister_fcf_prep - Unregister fcf record preparation
  * @phba: Pointer to hba context object.
  *
- * This function check if there are any connected remote port for the FCF and
- * if all the devices are disconnected, this function unregister FCFI.
- * This function also tries to use another FCF for discovery.
+ * This function prepare the HBA for unregistering the currently registered
+ * FCF from the HBA. It performs unregistering, in order, RPIs, VPIs, and
+ * VFIs.
  */
-void
-lpfc_unregister_unused_fcf(struct lpfc_hba *phba)
+int
+lpfc_unregister_fcf_prep(struct lpfc_hba *phba)
 {
         LPFC_MBOXQ_t *mbox;
-        int rc;
         struct lpfc_vport **vports;
-        int i;
-
-        spin_lock_irq(&phba->hbalock);
-        /*
-         * If HBA is not running in FIP mode or
-         * If HBA does not support FCoE or
-         * If FCF is not registered.
-         * do nothing.
-         */
-        if (!(phba->hba_flag & HBA_FCOE_SUPPORT) ||
-                !(phba->fcf.fcf_flag & FCF_REGISTERED) ||
-                (phba->cfg_enable_fip == 0)) {
-                spin_unlock_irq(&phba->hbalock);
-                return;
-        }
-        spin_unlock_irq(&phba->hbalock);
+        struct lpfc_nodelist *ndlp;
+        struct Scsi_Host *shost;
+        int i, rc;
 
+        /* Unregister RPIs */
         if (lpfc_fcf_inuse(phba))
-                return;
+                lpfc_unreg_hba_rpis(phba);
 
+        /* At this point, all discovery is aborted */
+        phba->pport->port_state = LPFC_VPORT_UNKNOWN;
 
         /* Unregister VPIs */
         vports = lpfc_create_vport_work_array(phba);
-        if (vports &&
-                (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED))
+        if (vports && (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED))
                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
+                        /* Stop FLOGI/FDISC retries */
+                        ndlp = lpfc_findnode_did(vports[i], Fabric_DID);
+                        if (ndlp)
+                                lpfc_cancel_retry_delay_tmo(vports[i], ndlp);
                         lpfc_mbx_unreg_vpi(vports[i]);
-                        vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
-                        vports[i]->vfi_state &= ~LPFC_VFI_REGISTERED;
+                        shost = lpfc_shost_from_vport(vports[i]);
+                        spin_lock_irq(shost->host_lock);
+                        vports[i]->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
+                        vports[i]->vpi_state &= ~LPFC_VPI_REGISTERED;
+                        spin_unlock_irq(shost->host_lock);
                 }
         lpfc_destroy_vport_work_array(phba, vports);
 
+        /* Cleanup any outstanding ELS commands */
+        lpfc_els_flush_all_cmd(phba);
+
         /* Unregister VFI */
         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (!mbox) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
-                        "2556 UNREG_VFI mbox allocation failed"
-                        "HBA state x%x\n",
-                        phba->pport->port_state);
-                return;
+                                "2556 UNREG_VFI mbox allocation failed"
+                                "HBA state x%x\n", phba->pport->port_state);
+                return -ENOMEM;
         }
 
-        lpfc_unreg_vfi(mbox, phba->pport->vfi);
+        lpfc_unreg_vfi(mbox, phba->pport);
         mbox->vport = phba->pport;
         mbox->mbox_cmpl = lpfc_unregister_vfi_cmpl;
 
         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
         if (rc == MBX_NOT_FINISHED) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
-                        "2557 UNREG_VFI issue mbox failed rc x%x "
-                        "HBA state x%x\n",
-                        rc, phba->pport->port_state);
+                                "2557 UNREG_VFI issue mbox failed rc x%x "
+                                "HBA state x%x\n",
+                                rc, phba->pport->port_state);
                 mempool_free(mbox, phba->mbox_mem_pool);
-                return;
+                return -EIO;
         }
 
-        /* Unregister FCF */
+        shost = lpfc_shost_from_vport(phba->pport);
+        spin_lock_irq(shost->host_lock);
+        phba->pport->fc_flag &= ~FC_VFI_REGISTERED;
+        spin_unlock_irq(shost->host_lock);
+
+        return 0;
+}
+
+/**
+ * lpfc_sli4_unregister_fcf - Unregister currently registered FCF record
+ * @phba: Pointer to hba context object.
+ *
+ * This function issues synchronous unregister FCF mailbox command to HBA to
+ * unregister the currently registered FCF record. The driver does not reset
+ * the driver FCF usage state flags.
+ *
+ * Return 0 if successfully issued, none-zero otherwise.
+ */
+int
+lpfc_sli4_unregister_fcf(struct lpfc_hba *phba)
+{
+        LPFC_MBOXQ_t *mbox;
+        int rc;
+
         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (!mbox) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
-                        "2551 UNREG_FCFI mbox allocation failed"
-                        "HBA state x%x\n",
-                        phba->pport->port_state);
-                return;
+                                "2551 UNREG_FCFI mbox allocation failed"
+                                "HBA state x%x\n", phba->pport->port_state);
+                return -ENOMEM;
         }
-
         lpfc_unreg_fcfi(mbox, phba->fcf.fcfi);
         mbox->vport = phba->pport;
         mbox->mbox_cmpl = lpfc_unregister_fcfi_cmpl;
         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
 
         if (rc == MBX_NOT_FINISHED) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
-                        "2552 UNREG_FCFI issue mbox failed rc x%x "
-                        "HBA state x%x\n",
-                        rc, phba->pport->port_state);
-                mempool_free(mbox, phba->mbox_mem_pool);
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "2552 Unregister FCFI command failed rc x%x "
+                                "HBA state x%x\n",
+                                rc, phba->pport->port_state);
+                return -EINVAL;
+        }
+        return 0;
+}
+
+/**
+ * lpfc_unregister_fcf_rescan - Unregister currently registered fcf and rescan
+ * @phba: Pointer to hba context object.
+ *
+ * This function unregisters the currently reigstered FCF. This function
+ * also tries to find another FCF for discovery by rescan the HBA FCF table.
+ */
+void
+lpfc_unregister_fcf_rescan(struct lpfc_hba *phba)
+{
+        int rc;
+
+        /* Preparation for unregistering fcf */
+        rc = lpfc_unregister_fcf_prep(phba);
+        if (rc) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
+                                "2748 Failed to prepare for unregistering "
+                                "HBA's FCF record: rc=%d\n", rc);
                 return;
         }
 
-        spin_lock_irq(&phba->hbalock);
-        phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_REGISTERED |
-                FCF_DISCOVERED | FCF_BOOT_ENABLE | FCF_IN_USE |
-                FCF_VALID_VLAN);
-        spin_unlock_irq(&phba->hbalock);
+        /* Now, unregister FCF record and reset HBA FCF state */
+        rc = lpfc_sli4_unregister_fcf(phba);
+        if (rc)
+                return;
+        /* Reset HBA FCF states after successful unregister FCF */
+        phba->fcf.fcf_flag = 0;
+        phba->fcf.current_rec.flag = 0;
 
         /*
          * If driver is not unloading, check if there is any other
          * FCF record that can be used for discovery.
          */
         if ((phba->pport->load_flag & FC_UNLOADING) ||
-                (phba->link_state < LPFC_LINK_UP))
+            (phba->link_state < LPFC_LINK_UP))
                 return;
 
-        rc = lpfc_sli4_read_fcf_record(phba, LPFC_FCOE_FCF_GET_FIRST);
+        /* This is considered as the initial FCF discovery scan */
+        spin_lock_irq(&phba->hbalock);
+        phba->fcf.fcf_flag |= FCF_INIT_DISC;
+        spin_unlock_irq(&phba->hbalock);
+        rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST);
 
-        if (rc)
+        if (rc) {
+                spin_lock_irq(&phba->hbalock);
+                phba->fcf.fcf_flag &= ~FCF_INIT_DISC;
+                spin_unlock_irq(&phba->hbalock);
                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
-                        "2553 lpfc_unregister_unused_fcf failed to read FCF"
-                        " record HBA state x%x\n",
-                        phba->pport->port_state);
+                                "2553 lpfc_unregister_unused_fcf failed "
+                                "to read FCF record HBA state x%x\n",
+                                phba->pport->port_state);
+        }
+}
+
+/**
+ * lpfc_unregister_fcf - Unregister the currently registered fcf record
+ * @phba: Pointer to hba context object.
+ *
+ * This function just unregisters the currently reigstered FCF. It does not
+ * try to find another FCF for discovery.
+ */
+void
+lpfc_unregister_fcf(struct lpfc_hba *phba)
+{
+        int rc;
+
+        /* Preparation for unregistering fcf */
+        rc = lpfc_unregister_fcf_prep(phba);
+        if (rc) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
+                                "2749 Failed to prepare for unregistering "
+                                "HBA's FCF record: rc=%d\n", rc);
+                return;
+        }
+
+        /* Now, unregister FCF record and reset HBA FCF state */
+        rc = lpfc_sli4_unregister_fcf(phba);
+        if (rc)
+                return;
+        /* Set proper HBA FCF states after successful unregister FCF */
+        spin_lock_irq(&phba->hbalock);
+        phba->fcf.fcf_flag &= ~FCF_REGISTERED;
+        spin_unlock_irq(&phba->hbalock);
+}
+
+/**
+ * lpfc_unregister_unused_fcf - Unregister FCF if all devices are disconnected.
+ * @phba: Pointer to hba context object.
+ *
+ * This function check if there are any connected remote port for the FCF and
+ * if all the devices are disconnected, this function unregister FCFI.
+ * This function also tries to use another FCF for discovery.
+ */
+void
+lpfc_unregister_unused_fcf(struct lpfc_hba *phba)
+{
+        /*
+         * If HBA is not running in FIP mode or if HBA does not support
+         * FCoE or if FCF is not registered, do nothing.
+         */
+        spin_lock_irq(&phba->hbalock);
+        if (!(phba->hba_flag & HBA_FCOE_SUPPORT) ||
+            !(phba->fcf.fcf_flag & FCF_REGISTERED) ||
+            !(phba->hba_flag & HBA_FIP_SUPPORT)) {
+                spin_unlock_irq(&phba->hbalock);
+                return;
+        }
+        spin_unlock_irq(&phba->hbalock);
+
+        if (lpfc_fcf_inuse(phba))
+                return;
+
+        lpfc_unregister_fcf_rescan(phba);
 }
 
 /**
@@ -4512,8 +5151,10 @@ lpfc_read_fcf_conn_tbl(struct lpfc_hba *phba,
 
         /* Free the current connect table */
         list_for_each_entry_safe(conn_entry, next_conn_entry,
-                &phba->fcf_conn_rec_list, list)
+                &phba->fcf_conn_rec_list, list) {
+                list_del_init(&conn_entry->list);
                 kfree(conn_entry);
+        }
 
         conn_hdr = (struct lpfc_fcf_conn_hdr *) buff;
         record_count = conn_hdr->length * sizeof(uint32_t)/
@@ -4569,14 +5210,6 @@ lpfc_read_fcoe_param(struct lpfc_hba *phba,
                 (fcoe_param_hdr->length != FCOE_PARAM_LENGTH))
                 return;
 
-        if (bf_get(lpfc_fip_param_hdr_fipp_mode, fcoe_param_hdr) ==
-                        FIPP_MODE_ON)
-                phba->cfg_enable_fip = 1;
-
-        if (bf_get(lpfc_fip_param_hdr_fipp_mode, fcoe_param_hdr) ==
-                FIPP_MODE_OFF)
-                phba->cfg_enable_fip = 0;
-
         if (fcoe_param_hdr->parm_flags & FIPP_VLAN_VALID) {
                 phba->valid_vlan = 1;
                 phba->vlan_id = le16_to_cpu(fcoe_param->vlan_tag) &
diff --git a/drivers/scsi/lpfc/lpfc_hw.h b/drivers/scsi/lpfc/lpfc_hw.h
index ccb26724dc53..89ff7c09e298 100644
--- a/drivers/scsi/lpfc/lpfc_hw.h
+++ b/drivers/scsi/lpfc/lpfc_hw.h
@@ -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-2010 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -1124,21 +1124,6 @@ typedef struct {
 /* Number of 4-byte words in an IOCB. */
 #define IOCB_WORD_SZ    8
 
-/* defines for type field in fc header */
-#define FC_ELS_DATA     0x1
-#define FC_LLC_SNAP     0x5
-#define FC_FCP_DATA     0x8
-#define FC_COMMON_TRANSPORT_ULP 0x20
-
-/* defines for rctl field in fc header */
-#define FC_DEV_DATA     0x0
-#define FC_UNSOL_CTL    0x2
-#define FC_SOL_CTL      0x3
-#define FC_UNSOL_DATA   0x4
-#define FC_FCP_CMND     0x6
-#define FC_ELS_REQ      0x22
-#define FC_ELS_RSP      0x23
-
 /* network headers for Dfctl field */
 #define FC_NET_HDR      0x20
 
@@ -1183,6 +1168,8 @@ typedef struct {
 #define PCI_DEVICE_ID_ZEPHYR_DCSP   0xfe12
 #define PCI_VENDOR_ID_SERVERENGINE  0x19a2
 #define PCI_DEVICE_ID_TIGERSHARK    0x0704
+#define PCI_DEVICE_ID_TOMCAT        0x0714
+#define PCI_DEVICE_ID_FALCON        0xf180
 
 #define JEDEC_ID_ADDRESS            0x0080001c
 #define FIREFLY_JEDEC_ID            0x1ACC
@@ -1359,6 +1346,9 @@ typedef struct {		/* FireFly BIU registers */
 #define MBX_HEARTBEAT       0x31
 #define MBX_WRITE_VPARMS    0x32
 #define MBX_ASYNCEVT_ENABLE 0x33
+#define MBX_READ_EVENT_LOG_STATUS 0x37
+#define MBX_READ_EVENT_LOG  0x38
+#define MBX_WRITE_EVENT_LOG 0x39
 
 #define MBX_PORT_CAPABILITIES 0x3B
 #define MBX_PORT_IOV_CONTROL 0x3C
@@ -1444,6 +1434,7 @@ typedef struct {		/* FireFly BIU registers */
 #define CMD_ABORT_MXRI64_CN     0x8C
 #define CMD_RCV_ELS_REQ64_CX    0x8D
 #define CMD_XMIT_ELS_RSP64_CX   0x95
+#define CMD_XMIT_BLS_RSP64_CX   0x97
 #define CMD_FCP_IWRITE64_CR     0x98
 #define CMD_FCP_IWRITE64_CX     0x99
 #define CMD_FCP_IREAD64_CR      0x9A
@@ -1477,17 +1468,13 @@ typedef struct {		/* FireFly BIU registers */
 #define CMD_IOCB_LOGENTRY_CN            0x94
 #define CMD_IOCB_LOGENTRY_ASYNC_CN      0x96
 
-/* Unhandled Data Security SLI Commands */
-#define DSSCMD_IWRITE64_CR              0xD8
-#define DSSCMD_IWRITE64_CX              0xD9
-#define DSSCMD_IREAD64_CR               0xDA
-#define DSSCMD_IREAD64_CX               0xDB
-#define DSSCMD_INVALIDATE_DEK           0xDC
-#define DSSCMD_SET_KEK                  0xDD
-#define DSSCMD_GET_KEK_ID               0xDE
-#define DSSCMD_GEN_XFER                 0xDF
-
-#define CMD_MAX_IOCB_CMD        0xE6
+/* Data Security SLI Commands */
+#define DSSCMD_IWRITE64_CR              0xF8
+#define DSSCMD_IWRITE64_CX              0xF9
+#define DSSCMD_IREAD64_CR               0xFA
+#define DSSCMD_IREAD64_CX               0xFB
+
+#define CMD_MAX_IOCB_CMD        0xFB
 #define CMD_IOCB_MASK           0xff
 
 #define MAX_MSG_DATA            28      /* max msg data in CMD_ADAPTER_MSG
@@ -2306,8 +2293,7 @@ typedef struct {
         uint32_t rsvd1;
         uint32_t rsvd2:8;
         uint32_t sid:24;
-        uint32_t rsvd3;
-        uint32_t rsvd4;
+        uint32_t wwn[2];
         uint32_t rsvd5;
         uint16_t vfi;
         uint16_t vpi;
@@ -2315,8 +2301,7 @@ typedef struct {
         uint32_t rsvd1;
         uint32_t sid:24;
         uint32_t rsvd2:8;
-        uint32_t rsvd3;
-        uint32_t rsvd4;
+        uint32_t wwn[2];
         uint32_t rsvd5;
         uint16_t vpi;
         uint16_t vfi;
@@ -2326,7 +2311,13 @@ typedef struct {
 /* Structure for MB Command UNREG_VPI (0x97) */
 typedef struct {
         uint32_t rsvd1;
-        uint32_t rsvd2;
+#ifdef __BIG_ENDIAN_BITFIELD
+        uint16_t rsvd2;
+        uint16_t sli4_vpi;
+#else   /*  __LITTLE_ENDIAN */
+        uint16_t sli4_vpi;
+        uint16_t rsvd2;
+#endif
         uint32_t rsvd3;
         uint32_t rsvd4;
         uint32_t rsvd5;
@@ -3547,7 +3538,7 @@ typedef struct _IOCB {	/* IOCB structure */
                 ASYNCSTAT_FIELDS asyncstat; /* async_status iocb */
                 QUE_XRI64_CX_FIELDS quexri64cx; /* que_xri64_cx fields */
                 struct rcv_seq64 rcvseq64;      /* RCV_SEQ64 and RCV_CONT64 */
-
+                struct sli4_bls_acc bls_acc; /* UNSOL ABTS BLS_ACC params */
                 uint32_t ulpWord[IOCB_WORD_SZ - 2];     /* generic 6 'words' */
         } un;
         union {
diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h
index 3689eee04535..820015fbc4d6 100644
--- a/drivers/scsi/lpfc/lpfc_hw4.h
+++ b/drivers/scsi/lpfc/lpfc_hw4.h
@@ -52,35 +52,37 @@ struct dma_address {
         uint32_t addr_hi;
 };
 
-#define LPFC_SLIREV_CONF_WORD   0x58
 struct lpfc_sli_intf {
         uint32_t word0;
-#define lpfc_sli_intf_iftype_MASK       0x00000007
-#define lpfc_sli_intf_iftype_SHIFT      0
-#define lpfc_sli_intf_iftype_WORD       word0
-#define lpfc_sli_intf_rev_MASK          0x0000000f
-#define lpfc_sli_intf_rev_SHIFT         4
-#define lpfc_sli_intf_rev_WORD          word0
-#define LPFC_SLIREV_CONF_SLI4   4
-#define lpfc_sli_intf_family_MASK       0x000000ff
-#define lpfc_sli_intf_family_SHIFT      8
-#define lpfc_sli_intf_family_WORD       word0
-#define lpfc_sli_intf_feat1_MASK        0x000000ff
-#define lpfc_sli_intf_feat1_SHIFT       16
-#define lpfc_sli_intf_feat1_WORD        word0
-#define lpfc_sli_intf_feat2_MASK        0x0000001f
-#define lpfc_sli_intf_feat2_SHIFT       24
-#define lpfc_sli_intf_feat2_WORD        word0
-#define lpfc_sli_intf_valid_MASK        0x00000007
-#define lpfc_sli_intf_valid_SHIFT       29
-#define lpfc_sli_intf_valid_WORD        word0
+#define lpfc_sli_intf_valid_SHIFT               29
+#define lpfc_sli_intf_valid_MASK                0x00000007
+#define lpfc_sli_intf_valid_WORD                word0
 #define LPFC_SLI_INTF_VALID             6
+#define lpfc_sli_intf_featurelevel2_SHIFT       24
+#define lpfc_sli_intf_featurelevel2_MASK        0x0000001F
+#define lpfc_sli_intf_featurelevel2_WORD        word0
+#define lpfc_sli_intf_featurelevel1_SHIFT       16
+#define lpfc_sli_intf_featurelevel1_MASK        0x000000FF
+#define lpfc_sli_intf_featurelevel1_WORD        word0
+#define LPFC_SLI_INTF_FEATURELEVEL1_1   1
+#define LPFC_SLI_INTF_FEATURELEVEL1_2   2
+#define lpfc_sli_intf_sli_family_SHIFT          8
+#define lpfc_sli_intf_sli_family_MASK           0x000000FF
+#define lpfc_sli_intf_sli_family_WORD           word0
+#define LPFC_SLI_INTF_FAMILY_BE2        0
+#define LPFC_SLI_INTF_FAMILY_BE3        1
+#define lpfc_sli_intf_slirev_SHIFT              4
+#define lpfc_sli_intf_slirev_MASK               0x0000000F
+#define lpfc_sli_intf_slirev_WORD               word0
+#define LPFC_SLI_INTF_REV_SLI3          3
+#define LPFC_SLI_INTF_REV_SLI4          4
+#define lpfc_sli_intf_if_type_SHIFT             0
+#define lpfc_sli_intf_if_type_MASK              0x00000007
+#define lpfc_sli_intf_if_type_WORD              word0
+#define LPFC_SLI_INTF_IF_TYPE_0         0
+#define LPFC_SLI_INTF_IF_TYPE_1         1
 };
 
-#define LPFC_SLI4_BAR0          1
-#define LPFC_SLI4_BAR1          2
-#define LPFC_SLI4_BAR2          4
-
 #define LPFC_SLI4_MBX_EMBED     true
 #define LPFC_SLI4_MBX_NEMBED    false
 
@@ -161,6 +163,9 @@ struct lpfc_sli_intf {
 #define LPFC_FP_DEF_IMAX       10000
 #define LPFC_SP_DEF_IMAX       10000
 
+/* PORT_CAPABILITIES constants. */
+#define LPFC_MAX_SUPPORTED_PAGES        8
+
 struct ulp_bde64 {
         union ULP_BDE_TUS {
                 uint32_t w;
@@ -194,6 +199,26 @@ struct lpfc_sli4_flags {
 #define lpfc_fip_flag_WORD word0
 };
 
+struct sli4_bls_acc {
+        uint32_t word0_rsvd;      /* Word0 must be reserved */
+        uint32_t word1;
+#define lpfc_abts_orig_SHIFT      0
+#define lpfc_abts_orig_MASK       0x00000001
+#define lpfc_abts_orig_WORD       word1
+#define LPFC_ABTS_UNSOL_RSP       1
+#define LPFC_ABTS_UNSOL_INT       0
+        uint32_t word2;
+#define lpfc_abts_rxid_SHIFT      0
+#define lpfc_abts_rxid_MASK       0x0000FFFF
+#define lpfc_abts_rxid_WORD       word2
+#define lpfc_abts_oxid_SHIFT      16
+#define lpfc_abts_oxid_MASK       0x0000FFFF
+#define lpfc_abts_oxid_WORD       word2
+        uint32_t word3;
+        uint32_t word4;
+        uint32_t word5_rsvd;    /* Word5 must be reserved */
+};
+
 /* event queue entry structure */
 struct lpfc_eqe {
         uint32_t word0;
@@ -425,7 +450,7 @@ struct lpfc_wqe_generic{
 #define lpfc_wqe_gen_status_MASK        0x0000000F
 #define lpfc_wqe_gen_status_WORD        word7
 #define lpfc_wqe_gen_ct_SHIFT           2
-#define lpfc_wqe_gen_ct_MASK            0x00000007
+#define lpfc_wqe_gen_ct_MASK            0x00000003
 #define lpfc_wqe_gen_ct_WORD            word7
         uint32_t abort_tag;
         uint32_t word9;
@@ -453,6 +478,13 @@ struct lpfc_wqe_generic{
 #define lpfc_wqe_gen_wqec_SHIFT         7
 #define lpfc_wqe_gen_wqec_MASK          0x00000001
 #define lpfc_wqe_gen_wqec_WORD          word11
+#define ELS_ID_FLOGI 3
+#define ELS_ID_FDISC 2
+#define ELS_ID_LOGO  1
+#define ELS_ID_DEFAULT 0
+#define lpfc_wqe_gen_els_id_SHIFT       4
+#define lpfc_wqe_gen_els_id_MASK        0x00000003
+#define lpfc_wqe_gen_els_id_WORD        word11
 #define lpfc_wqe_gen_cmd_type_SHIFT     0
 #define lpfc_wqe_gen_cmd_type_MASK      0x0000000F
 #define lpfc_wqe_gen_cmd_type_WORD      word11
@@ -487,9 +519,9 @@ struct lpfc_register {
 
 #define LPFC_UERR_STATUS_HI             0x00A4
 #define LPFC_UERR_STATUS_LO             0x00A0
-#define LPFC_ONLINE0                    0x00B0
-#define LPFC_ONLINE1                    0x00B4
-#define LPFC_SCRATCHPAD                 0x0058
+#define LPFC_UE_MASK_HI                 0x00AC
+#define LPFC_UE_MASK_LO                 0x00A8
+#define LPFC_SLI_INTF                   0x0058
 
 /* BAR0 Registers */
 #define LPFC_HST_STATE                  0x00AC
@@ -549,19 +581,6 @@ struct lpfc_register {
 #define LPFC_POST_STAGE_ARMFW_READY                     0xC000
 #define LPFC_POST_STAGE_ARMFW_UE                        0xF000
 
-#define lpfc_scratchpad_slirev_SHIFT                    4
-#define lpfc_scratchpad_slirev_MASK                     0xF
-#define lpfc_scratchpad_slirev_WORD                     word0
-#define lpfc_scratchpad_chiptype_SHIFT                  8
-#define lpfc_scratchpad_chiptype_MASK                   0xFF
-#define lpfc_scratchpad_chiptype_WORD                   word0
-#define lpfc_scratchpad_featurelevel1_SHIFT             16
-#define lpfc_scratchpad_featurelevel1_MASK              0xFF
-#define lpfc_scratchpad_featurelevel1_WORD              word0
-#define lpfc_scratchpad_featurelevel2_SHIFT             24
-#define lpfc_scratchpad_featurelevel2_MASK              0xFF
-#define lpfc_scratchpad_featurelevel2_WORD              word0
-
 /* BAR1 Registers */
 #define LPFC_IMR_MASK_ALL       0xFFFFFFFF
 #define LPFC_ISCR_CLEAR_ALL     0xFFFFFFFF
@@ -760,6 +779,7 @@ struct mbox_header {
 #define LPFC_MBOX_OPCODE_MQ_DESTROY             0x35
 #define LPFC_MBOX_OPCODE_CQ_DESTROY             0x36
 #define LPFC_MBOX_OPCODE_EQ_DESTROY             0x37
+#define LPFC_MBOX_OPCODE_QUERY_FW_CFG           0x3A
 #define LPFC_MBOX_OPCODE_FUNCTION_RESET         0x3D
 
 /* FCoE Opcodes */
@@ -773,6 +793,7 @@ struct mbox_header {
 #define LPFC_MBOX_OPCODE_FCOE_ADD_FCF                   0x09
 #define LPFC_MBOX_OPCODE_FCOE_DELETE_FCF                0x0A
 #define LPFC_MBOX_OPCODE_FCOE_POST_HDR_TEMPLATE         0x0B
+#define LPFC_MBOX_OPCODE_FCOE_REDISCOVER_FCF            0x10
 
 /* Mailbox command structures */
 struct eq_context {
@@ -985,7 +1006,7 @@ struct lpfc_mbx_wq_destroy {
 };
 
 #define LPFC_HDR_BUF_SIZE 128
-#define LPFC_DATA_BUF_SIZE 4096
+#define LPFC_DATA_BUF_SIZE 2048
 struct rq_context {
         uint32_t word0;
 #define lpfc_rq_context_rq_size_SHIFT   16
@@ -1121,10 +1142,7 @@ struct sli4_sge {	/* SLI-4 */
                                                 this  flag !! */
 #define lpfc_sli4_sge_last_MASK         0x00000001
 #define lpfc_sli4_sge_last_WORD         word2
-        uint32_t word3;
-#define lpfc_sli4_sge_len_SHIFT         0
-#define lpfc_sli4_sge_len_MASK          0x0001FFFF
-#define lpfc_sli4_sge_len_WORD          word3
+        uint32_t sge_len;
 };
 
 struct fcf_record {
@@ -1273,6 +1291,64 @@ struct lpfc_mbx_del_fcf_tbl_entry {
 #define lpfc_mbx_del_fcf_tbl_index_WORD         word10
 };
 
+struct lpfc_mbx_redisc_fcf_tbl {
+        struct mbox_header header;
+        uint32_t word10;
+#define lpfc_mbx_redisc_fcf_count_SHIFT         0
+#define lpfc_mbx_redisc_fcf_count_MASK          0x0000FFFF
+#define lpfc_mbx_redisc_fcf_count_WORD          word10
+        uint32_t resvd;
+        uint32_t word12;
+#define lpfc_mbx_redisc_fcf_index_SHIFT         0
+#define lpfc_mbx_redisc_fcf_index_MASK          0x0000FFFF
+#define lpfc_mbx_redisc_fcf_index_WORD          word12
+};
+
+struct lpfc_mbx_query_fw_cfg {
+        struct mbox_header header;
+        uint32_t config_number;
+        uint32_t asic_rev;
+        uint32_t phys_port;
+        uint32_t function_mode;
+/* firmware Function Mode */
+#define lpfc_function_mode_toe_SHIFT            0
+#define lpfc_function_mode_toe_MASK             0x00000001
+#define lpfc_function_mode_toe_WORD             function_mode
+#define lpfc_function_mode_nic_SHIFT            1
+#define lpfc_function_mode_nic_MASK             0x00000001
+#define lpfc_function_mode_nic_WORD             function_mode
+#define lpfc_function_mode_rdma_SHIFT           2
+#define lpfc_function_mode_rdma_MASK            0x00000001
+#define lpfc_function_mode_rdma_WORD            function_mode
+#define lpfc_function_mode_vm_SHIFT             3
+#define lpfc_function_mode_vm_MASK              0x00000001
+#define lpfc_function_mode_vm_WORD              function_mode
+#define lpfc_function_mode_iscsi_i_SHIFT        4
+#define lpfc_function_mode_iscsi_i_MASK         0x00000001
+#define lpfc_function_mode_iscsi_i_WORD         function_mode
+#define lpfc_function_mode_iscsi_t_SHIFT        5
+#define lpfc_function_mode_iscsi_t_MASK         0x00000001
+#define lpfc_function_mode_iscsi_t_WORD         function_mode
+#define lpfc_function_mode_fcoe_i_SHIFT         6
+#define lpfc_function_mode_fcoe_i_MASK          0x00000001
+#define lpfc_function_mode_fcoe_i_WORD          function_mode
+#define lpfc_function_mode_fcoe_t_SHIFT         7
+#define lpfc_function_mode_fcoe_t_MASK          0x00000001
+#define lpfc_function_mode_fcoe_t_WORD          function_mode
+#define lpfc_function_mode_dal_SHIFT            8
+#define lpfc_function_mode_dal_MASK             0x00000001
+#define lpfc_function_mode_dal_WORD             function_mode
+#define lpfc_function_mode_lro_SHIFT            9
+#define lpfc_function_mode_lro_MASK             0x00000001
+#define lpfc_function_mode_lro_WORD             function_mode9
+#define lpfc_function_mode_flex10_SHIFT         10
+#define lpfc_function_mode_flex10_MASK          0x00000001
+#define lpfc_function_mode_flex10_WORD          function_mode
+#define lpfc_function_mode_ncsi_SHIFT           11
+#define lpfc_function_mode_ncsi_MASK            0x00000001
+#define lpfc_function_mode_ncsi_WORD            function_mode
+};
+
 /* Status field for embedded SLI_CONFIG mailbox command */
 #define STATUS_SUCCESS                                  0x0
 #define STATUS_FAILED                                   0x1
@@ -1298,6 +1374,7 @@ struct lpfc_mbx_del_fcf_tbl_entry {
 #define STATUS_ERROR_ACITMAIN                           0x2a
 #define STATUS_REBOOT_REQUIRED                          0x2c
 #define STATUS_FCF_IN_USE                               0x3a
+#define STATUS_FCF_TABLE_EMPTY                          0x43
 
 struct lpfc_mbx_sli4_config {
         struct mbox_header header;
@@ -1349,8 +1426,7 @@ struct lpfc_mbx_reg_vfi {
 #define lpfc_reg_vfi_fcfi_SHIFT         0
 #define lpfc_reg_vfi_fcfi_MASK          0x0000FFFF
 #define lpfc_reg_vfi_fcfi_WORD          word2
-        uint32_t word3_rsvd;
-        uint32_t word4_rsvd;
+        uint32_t wwn[2];
         struct ulp_bde64 bde;
         uint32_t word8_rsvd;
         uint32_t word9_rsvd;
@@ -1555,6 +1631,11 @@ struct lpfc_mbx_read_rev {
 #define lpfc_mbx_rd_rev_fcoe_SHIFT              20
 #define lpfc_mbx_rd_rev_fcoe_MASK               0x00000001
 #define lpfc_mbx_rd_rev_fcoe_WORD               word1
+#define lpfc_mbx_rd_rev_cee_ver_SHIFT           21
+#define lpfc_mbx_rd_rev_cee_ver_MASK            0x00000003
+#define lpfc_mbx_rd_rev_cee_ver_WORD            word1
+#define LPFC_PREDCBX_CEE_MODE   0
+#define LPFC_DCBX_CEE_MODE      1
 #define lpfc_mbx_rd_rev_vpd_SHIFT               29
 #define lpfc_mbx_rd_rev_vpd_MASK                0x00000001
 #define lpfc_mbx_rd_rev_vpd_WORD                word1
@@ -1756,6 +1837,177 @@ struct lpfc_mbx_request_features {
 #define lpfc_mbx_rq_ftr_rsp_ifip_WORD           word3
 };
 
+struct lpfc_mbx_supp_pages {
+        uint32_t word1;
+#define qs_SHIFT                                0
+#define qs_MASK                                 0x00000001
+#define qs_WORD                                 word1
+#define wr_SHIFT                                1
+#define wr_MASK                                 0x00000001
+#define wr_WORD                                 word1
+#define pf_SHIFT                                8
+#define pf_MASK                                 0x000000ff
+#define pf_WORD                                 word1
+#define cpn_SHIFT                               16
+#define cpn_MASK                                0x000000ff
+#define cpn_WORD                                word1
+        uint32_t word2;
+#define list_offset_SHIFT                       0
+#define list_offset_MASK                        0x000000ff
+#define list_offset_WORD                        word2
+#define next_offset_SHIFT                       8
+#define next_offset_MASK                        0x000000ff
+#define next_offset_WORD                        word2
+#define elem_cnt_SHIFT                          16
+#define elem_cnt_MASK                           0x000000ff
+#define elem_cnt_WORD                           word2
+        uint32_t word3;
+#define pn_0_SHIFT                              24
+#define pn_0_MASK                               0x000000ff
+#define pn_0_WORD                               word3
+#define pn_1_SHIFT                              16
+#define pn_1_MASK                               0x000000ff
+#define pn_1_WORD                               word3
+#define pn_2_SHIFT                              8
+#define pn_2_MASK                               0x000000ff
+#define pn_2_WORD                               word3
+#define pn_3_SHIFT                              0
+#define pn_3_MASK                               0x000000ff
+#define pn_3_WORD                               word3
+        uint32_t word4;
+#define pn_4_SHIFT                              24
+#define pn_4_MASK                               0x000000ff
+#define pn_4_WORD                               word4
+#define pn_5_SHIFT                              16
+#define pn_5_MASK                               0x000000ff
+#define pn_5_WORD                               word4
+#define pn_6_SHIFT                              8
+#define pn_6_MASK                               0x000000ff
+#define pn_6_WORD                               word4
+#define pn_7_SHIFT                              0
+#define pn_7_MASK                               0x000000ff
+#define pn_7_WORD                               word4
+        uint32_t rsvd[27];
+#define LPFC_SUPP_PAGES                 0
+#define LPFC_BLOCK_GUARD_PROFILES       1
+#define LPFC_SLI4_PARAMETERS            2
+};
+
+struct lpfc_mbx_sli4_params {
+        uint32_t word1;
+#define qs_SHIFT                                0
+#define qs_MASK                                 0x00000001
+#define qs_WORD                                 word1
+#define wr_SHIFT                                1
+#define wr_MASK                                 0x00000001
+#define wr_WORD                                 word1
+#define pf_SHIFT                                8
+#define pf_MASK                                 0x000000ff
+#define pf_WORD                                 word1
+#define cpn_SHIFT                               16
+#define cpn_MASK                                0x000000ff
+#define cpn_WORD                                word1
+        uint32_t word2;
+#define if_type_SHIFT                           0
+#define if_type_MASK                            0x00000007
+#define if_type_WORD                            word2
+#define sli_rev_SHIFT                           4
+#define sli_rev_MASK                            0x0000000f
+#define sli_rev_WORD                            word2
+#define sli_family_SHIFT                        8
+#define sli_family_MASK                         0x000000ff
+#define sli_family_WORD                         word2
+#define featurelevel_1_SHIFT                    16
+#define featurelevel_1_MASK                     0x000000ff
+#define featurelevel_1_WORD                     word2
+#define featurelevel_2_SHIFT                    24
+#define featurelevel_2_MASK                     0x0000001f
+#define featurelevel_2_WORD                     word2
+        uint32_t word3;
+#define fcoe_SHIFT                              0
+#define fcoe_MASK                               0x00000001
+#define fcoe_WORD                               word3
+#define fc_SHIFT                                1
+#define fc_MASK                                 0x00000001
+#define fc_WORD                                 word3
+#define nic_SHIFT                               2
+#define nic_MASK                                0x00000001
+#define nic_WORD                                word3
+#define iscsi_SHIFT                             3
+#define iscsi_MASK                              0x00000001
+#define iscsi_WORD                              word3
+#define rdma_SHIFT                              4
+#define rdma_MASK                               0x00000001
+#define rdma_WORD                               word3
+        uint32_t sge_supp_len;
+        uint32_t word5;
+#define if_page_sz_SHIFT                        0
+#define if_page_sz_MASK                         0x0000ffff
+#define if_page_sz_WORD                         word5
+#define loopbk_scope_SHIFT                      24
+#define loopbk_scope_MASK                       0x0000000f
+#define loopbk_scope_WORD                       word5
+#define rq_db_window_SHIFT                      28
+#define rq_db_window_MASK                       0x0000000f
+#define rq_db_window_WORD                       word5
+        uint32_t word6;
+#define eq_pages_SHIFT                          0
+#define eq_pages_MASK                           0x0000000f
+#define eq_pages_WORD                           word6
+#define eqe_size_SHIFT                          8
+#define eqe_size_MASK                           0x000000ff
+#define eqe_size_WORD                           word6
+        uint32_t word7;
+#define cq_pages_SHIFT                          0
+#define cq_pages_MASK                           0x0000000f
+#define cq_pages_WORD                           word7
+#define cqe_size_SHIFT                          8
+#define cqe_size_MASK                           0x000000ff
+#define cqe_size_WORD                           word7
+        uint32_t word8;
+#define mq_pages_SHIFT                          0
+#define mq_pages_MASK                           0x0000000f
+#define mq_pages_WORD                           word8
+#define mqe_size_SHIFT                          8
+#define mqe_size_MASK                           0x000000ff
+#define mqe_size_WORD                           word8
+#define mq_elem_cnt_SHIFT                       16
+#define mq_elem_cnt_MASK                        0x000000ff
+#define mq_elem_cnt_WORD                        word8
+        uint32_t word9;
+#define wq_pages_SHIFT                          0
+#define wq_pages_MASK                           0x0000ffff
+#define wq_pages_WORD                           word9
+#define wqe_size_SHIFT                          8
+#define wqe_size_MASK                           0x000000ff
+#define wqe_size_WORD                           word9
+        uint32_t word10;
+#define rq_pages_SHIFT                          0
+#define rq_pages_MASK                           0x0000ffff
+#define rq_pages_WORD                           word10
+#define rqe_size_SHIFT                          8
+#define rqe_size_MASK                           0x000000ff
+#define rqe_size_WORD                           word10
+        uint32_t word11;
+#define hdr_pages_SHIFT                         0
+#define hdr_pages_MASK                          0x0000000f
+#define hdr_pages_WORD                          word11
+#define hdr_size_SHIFT                          8
+#define hdr_size_MASK                           0x0000000f
+#define hdr_size_WORD                           word11
+#define hdr_pp_align_SHIFT                      16
+#define hdr_pp_align_MASK                       0x0000ffff
+#define hdr_pp_align_WORD                       word11
+        uint32_t word12;
+#define sgl_pages_SHIFT                         0
+#define sgl_pages_MASK                          0x0000000f
+#define sgl_pages_WORD                          word12
+#define sgl_pp_align_SHIFT                      16
+#define sgl_pp_align_MASK                       0x0000ffff
+#define sgl_pp_align_WORD                       word12
+        uint32_t rsvd_13_63[51];
+};
+
 /* Mailbox Completion Queue Error Messages */
 #define MB_CQE_STATUS_SUCCESS                   0x0
 #define MB_CQE_STATUS_INSUFFICIENT_PRIVILEGES   0x1
@@ -1785,6 +2037,7 @@ struct lpfc_mqe {
                 struct lpfc_mbx_read_fcf_tbl read_fcf_tbl;
                 struct lpfc_mbx_add_fcf_tbl_entry add_fcf_entry;
                 struct lpfc_mbx_del_fcf_tbl_entry del_fcf_entry;
+                struct lpfc_mbx_redisc_fcf_tbl redisc_fcf_tbl;
                 struct lpfc_mbx_reg_fcfi reg_fcfi;
                 struct lpfc_mbx_unreg_fcfi unreg_fcfi;
                 struct lpfc_mbx_mq_create mq_create;
@@ -1804,6 +2057,9 @@ struct lpfc_mqe {
                 struct lpfc_mbx_read_config rd_config;
                 struct lpfc_mbx_request_features req_ftrs;
                 struct lpfc_mbx_post_hdr_tmpl hdr_tmpl;
+                struct lpfc_mbx_query_fw_cfg query_fw_cfg;
+                struct lpfc_mbx_supp_pages supp_pages;
+                struct lpfc_mbx_sli4_params sli4_params;
                 struct lpfc_mbx_nop nop;
         } un;
 };
@@ -1880,12 +2136,15 @@ struct lpfc_acqe_link {
 #define LPFC_ASYNC_LINK_FAULT_NONE      0x0
 #define LPFC_ASYNC_LINK_FAULT_LOCAL     0x1
 #define LPFC_ASYNC_LINK_FAULT_REMOTE    0x2
+#define lpfc_acqe_qos_link_speed_SHIFT  16
+#define lpfc_acqe_qos_link_speed_MASK   0x0000FFFF
+#define lpfc_acqe_qos_link_speed_WORD   word1
         uint32_t event_tag;
         uint32_t trailer;
 };
 
 struct lpfc_acqe_fcoe {
-        uint32_t fcf_index;
+        uint32_t index;
         uint32_t word1;
 #define lpfc_acqe_fcoe_fcf_count_SHIFT          0
 #define lpfc_acqe_fcoe_fcf_count_MASK           0x0000FFFF
@@ -1896,6 +2155,8 @@ struct lpfc_acqe_fcoe {
 #define LPFC_FCOE_EVENT_TYPE_NEW_FCF            0x1
 #define LPFC_FCOE_EVENT_TYPE_FCF_TABLE_FULL     0x2
 #define LPFC_FCOE_EVENT_TYPE_FCF_DEAD           0x3
+#define LPFC_FCOE_EVENT_TYPE_CVL                0x4
+#define LPFC_FCOE_EVENT_TYPE_FCF_PARAM_MOD      0x5
         uint32_t event_tag;
         uint32_t trailer;
 };
@@ -1921,12 +2182,13 @@ struct lpfc_bmbx_create {
 #define SGL_ALIGN_SZ 64
 #define SGL_PAGE_SIZE 4096
 /* align SGL addr on a size boundary - adjust address up */
-#define NO_XRI ((uint16_t)-1)
+#define NO_XRI  ((uint16_t)-1)
+
 struct wqe_common {
         uint32_t word6;
-#define wqe_xri_SHIFT         0
-#define wqe_xri_MASK          0x0000FFFF
-#define wqe_xri_WORD          word6
+#define wqe_xri_tag_SHIFT     0
+#define wqe_xri_tag_MASK      0x0000FFFF
+#define wqe_xri_tag_WORD      word6
 #define wqe_ctxt_tag_SHIFT    16
 #define wqe_ctxt_tag_MASK     0x0000FFFF
 #define wqe_ctxt_tag_WORD     word6
@@ -1987,7 +2249,7 @@ struct wqe_common {
 #define wqe_wqec_MASK       0x00000001
 #define wqe_wqec_WORD       word11
 #define wqe_cqid_SHIFT      16
-#define wqe_cqid_MASK       0x000003ff
+#define wqe_cqid_MASK       0x0000ffff
 #define wqe_cqid_WORD       word11
 };
 
@@ -1996,6 +2258,9 @@ struct wqe_did {
 #define wqe_els_did_SHIFT         0
 #define wqe_els_did_MASK          0x00FFFFFF
 #define wqe_els_did_WORD          word5
+#define wqe_xmit_bls_pt_SHIFT         28
+#define wqe_xmit_bls_pt_MASK          0x00000003
+#define wqe_xmit_bls_pt_WORD          word5
 #define wqe_xmit_bls_ar_SHIFT         30
 #define wqe_xmit_bls_ar_MASK          0x00000001
 #define wqe_xmit_bls_ar_WORD          word5
@@ -2044,6 +2309,23 @@ struct xmit_els_rsp64_wqe {
 
 struct xmit_bls_rsp64_wqe {
         uint32_t payload0;
+/* Payload0 for BA_ACC */
+#define xmit_bls_rsp64_acc_seq_id_SHIFT        16
+#define xmit_bls_rsp64_acc_seq_id_MASK         0x000000ff
+#define xmit_bls_rsp64_acc_seq_id_WORD         payload0
+#define xmit_bls_rsp64_acc_seq_id_vald_SHIFT   24
+#define xmit_bls_rsp64_acc_seq_id_vald_MASK    0x000000ff
+#define xmit_bls_rsp64_acc_seq_id_vald_WORD    payload0
+/* Payload0 for BA_RJT */
+#define xmit_bls_rsp64_rjt_vspec_SHIFT   0
+#define xmit_bls_rsp64_rjt_vspec_MASK    0x000000ff
+#define xmit_bls_rsp64_rjt_vspec_WORD    payload0
+#define xmit_bls_rsp64_rjt_expc_SHIFT    8
+#define xmit_bls_rsp64_rjt_expc_MASK     0x000000ff
+#define xmit_bls_rsp64_rjt_expc_WORD     payload0
+#define xmit_bls_rsp64_rjt_rsnc_SHIFT    16
+#define xmit_bls_rsp64_rjt_rsnc_MASK     0x000000ff
+#define xmit_bls_rsp64_rjt_rsnc_WORD     payload0
         uint32_t word1;
 #define xmit_bls_rsp64_rxid_SHIFT  0
 #define xmit_bls_rsp64_rxid_MASK   0x0000ffff
@@ -2052,18 +2334,19 @@ struct xmit_bls_rsp64_wqe {
 #define xmit_bls_rsp64_oxid_MASK   0x0000ffff
 #define xmit_bls_rsp64_oxid_WORD   word1
         uint32_t word2;
-#define xmit_bls_rsp64_seqcntlo_SHIFT  0
-#define xmit_bls_rsp64_seqcntlo_MASK   0x0000ffff
-#define xmit_bls_rsp64_seqcntlo_WORD   word2
-#define xmit_bls_rsp64_seqcnthi_SHIFT  16
+#define xmit_bls_rsp64_seqcnthi_SHIFT  0
 #define xmit_bls_rsp64_seqcnthi_MASK   0x0000ffff
 #define xmit_bls_rsp64_seqcnthi_WORD   word2
+#define xmit_bls_rsp64_seqcntlo_SHIFT  16
+#define xmit_bls_rsp64_seqcntlo_MASK   0x0000ffff
+#define xmit_bls_rsp64_seqcntlo_WORD   word2
         uint32_t rsrvd3;
         uint32_t rsrvd4;
         struct wqe_did  wqe_dest;
         struct wqe_common wqe_com; /* words 6-11 */
         uint32_t rsvd_12_15[4];
 };
+
 struct wqe_rctl_dfctl {
         uint32_t word5;
 #define wqe_si_SHIFT 2
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index 562d8cee874b..774663e8e1fe 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.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-2010 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -28,6 +28,8 @@
 #include <linux/pci.h>
 #include <linux/spinlock.h>
 #include <linux/ctype.h>
+#include <linux/aer.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_device.h>
@@ -349,7 +351,12 @@ lpfc_config_port_post(struct lpfc_hba *phba)
         mb = &pmb->u.mb;
 
         /* Get login parameters for NID.  */
-        lpfc_read_sparam(phba, pmb, 0);
+        rc = lpfc_read_sparam(phba, pmb, 0);
+        if (rc) {
+                mempool_free(pmb, phba->mbox_mem_pool);
+                return -ENOMEM;
+        }
+
         pmb->vport = vport;
         if (lpfc_sli_issue_mbox(phba, pmb, MBX_POLL) != MBX_SUCCESS) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -358,7 +365,7 @@ lpfc_config_port_post(struct lpfc_hba *phba)
                                 mb->mbxCommand, mb->mbxStatus);
                 phba->link_state = LPFC_HBA_ERROR;
                 mp = (struct lpfc_dmabuf *) pmb->context1;
-                mempool_free( pmb, phba->mbox_mem_pool);
+                mempool_free(pmb, phba->mbox_mem_pool);
                 lpfc_mbuf_free(phba, mp->virt, mp->phys);
                 kfree(mp);
                 return -EIO;
@@ -543,7 +550,7 @@ lpfc_config_port_post(struct lpfc_hba *phba)
                         mempool_free(pmb, phba->mbox_mem_pool);
                         return -EIO;
                 }
-        } else {
+        } else if (phba->cfg_suppress_link_up == LPFC_INITIALIZE_LINK) {
                 lpfc_init_link(phba, pmb, phba->cfg_topology,
                         phba->cfg_link_speed);
                 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
@@ -570,6 +577,11 @@ lpfc_config_port_post(struct lpfc_hba *phba)
         }
         /* MBOX buffer will be freed in mbox compl */
         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmb) {
+                phba->link_state = LPFC_HBA_ERROR;
+                return -ENOMEM;
+        }
+
         lpfc_config_async(phba, pmb, LPFC_ELS_RING);
         pmb->mbox_cmpl = lpfc_config_async_cmpl;
         pmb->vport = phba->pport;
@@ -587,6 +599,11 @@ lpfc_config_port_post(struct lpfc_hba *phba)
 
         /* Get Option rom version */
         pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmb) {
+                phba->link_state = LPFC_HBA_ERROR;
+                return -ENOMEM;
+        }
+
         lpfc_dump_wakeup_param(phba, pmb);
         pmb->mbox_cmpl = lpfc_dump_wakeup_param_cmpl;
         pmb->vport = phba->pport;
@@ -602,6 +619,102 @@ lpfc_config_port_post(struct lpfc_hba *phba)
 }
 
 /**
+ * lpfc_hba_init_link - Initialize the FC link
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine will issue the INIT_LINK mailbox command call.
+ * It is available to other drivers through the lpfc_hba data
+ * structure for use as a delayed link up mechanism with the
+ * module parameter lpfc_suppress_link_up.
+ *
+ * Return code
+ *              0 - success
+ *              Any other value - error
+ **/
+int
+lpfc_hba_init_link(struct lpfc_hba *phba)
+{
+        struct lpfc_vport *vport = phba->pport;
+        LPFC_MBOXQ_t *pmb;
+        MAILBOX_t *mb;
+        int rc;
+
+        pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmb) {
+                phba->link_state = LPFC_HBA_ERROR;
+                return -ENOMEM;
+        }
+        mb = &pmb->u.mb;
+        pmb->vport = vport;
+
+        lpfc_init_link(phba, pmb, phba->cfg_topology,
+                phba->cfg_link_speed);
+        pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
+        lpfc_set_loopback_flag(phba);
+        rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
+        if (rc != MBX_SUCCESS) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                        "0498 Adapter failed to init, mbxCmd x%x "
+                        "INIT_LINK, mbxStatus x%x\n",
+                        mb->mbxCommand, mb->mbxStatus);
+                /* Clear all interrupt enable conditions */
+                writel(0, phba->HCregaddr);
+                readl(phba->HCregaddr); /* flush */
+                /* Clear all pending interrupts */
+                writel(0xffffffff, phba->HAregaddr);
+                readl(phba->HAregaddr); /* flush */
+                phba->link_state = LPFC_HBA_ERROR;
+                if (rc != MBX_BUSY)
+                        mempool_free(pmb, phba->mbox_mem_pool);
+                return -EIO;
+        }
+        phba->cfg_suppress_link_up = LPFC_INITIALIZE_LINK;
+
+        return 0;
+}
+
+/**
+ * lpfc_hba_down_link - this routine downs the FC link
+ *
+ * This routine will issue the DOWN_LINK mailbox command call.
+ * It is available to other drivers through the lpfc_hba data
+ * structure for use to stop the link.
+ *
+ * Return code
+ *              0 - success
+ *              Any other value - error
+ **/
+int
+lpfc_hba_down_link(struct lpfc_hba *phba)
+{
+        LPFC_MBOXQ_t *pmb;
+        int rc;
+
+        pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmb) {
+                phba->link_state = LPFC_HBA_ERROR;
+                return -ENOMEM;
+        }
+
+        lpfc_printf_log(phba,
+                KERN_ERR, LOG_INIT,
+                "0491 Adapter Link is disabled.\n");
+        lpfc_down_link(phba, pmb);
+        pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
+        rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
+        if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
+                lpfc_printf_log(phba,
+                KERN_ERR, LOG_INIT,
+                "2522 Adapter failed to issue DOWN_LINK"
+                " mbox command rc 0x%x\n", rc);
+
+                mempool_free(pmb, phba->mbox_mem_pool);
+                return -EIO;
+        }
+        return 0;
+}
+
+/**
  * lpfc_hba_down_prep - Perform lpfc uninitialization prior to HBA reset
  * @phba: pointer to lpfc HBA data structure.
  *
@@ -645,7 +758,7 @@ lpfc_hba_down_prep(struct lpfc_hba *phba)
  * down the SLI Layer.
  *
  * Return codes
- *   0 - sucess.
+ *   0 - success.
  *   Any other value - error.
  **/
 static int
@@ -700,7 +813,7 @@ lpfc_hba_down_post_s3(struct lpfc_hba *phba)
  * down the SLI Layer.
  *
  * Return codes
- *   0 - sucess.
+ *   0 - success.
  *   Any other value - error.
  **/
 static int
@@ -710,6 +823,8 @@ lpfc_hba_down_post_s4(struct lpfc_hba *phba)
         LIST_HEAD(aborts);
         int ret;
         unsigned long iflag = 0;
+        struct lpfc_sglq *sglq_entry = NULL;
+
         ret = lpfc_hba_down_post_s3(phba);
         if (ret)
                 return ret;
@@ -725,6 +840,10 @@ lpfc_hba_down_post_s4(struct lpfc_hba *phba)
          * list.
          */
         spin_lock(&phba->sli4_hba.abts_sgl_list_lock);
+        list_for_each_entry(sglq_entry,
+                &phba->sli4_hba.lpfc_abts_els_sgl_list, list)
+                sglq_entry->state = SGL_FREED;
+
         list_splice_init(&phba->sli4_hba.lpfc_abts_els_sgl_list,
                         &phba->sli4_hba.lpfc_sgl_list);
         spin_unlock(&phba->sli4_hba.abts_sgl_list_lock);
@@ -755,7 +874,7 @@ lpfc_hba_down_post_s4(struct lpfc_hba *phba)
  * uninitialization after the HBA is reset when bring down the SLI Layer.
  *
  * Return codes
- *   0 - sucess.
+ *   0 - success.
  *   Any other value - error.
  **/
 int
@@ -852,12 +971,19 @@ lpfc_hb_mbox_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
 void
 lpfc_hb_timeout_handler(struct lpfc_hba *phba)
 {
+        struct lpfc_vport **vports;
         LPFC_MBOXQ_t *pmboxq;
         struct lpfc_dmabuf *buf_ptr;
-        int retval;
+        int retval, i;
         struct lpfc_sli *psli = &phba->sli;
         LIST_HEAD(completions);
 
+        vports = lpfc_create_vport_work_array(phba);
+        if (vports != NULL)
+                for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
+                        lpfc_rcv_seq_check_edtov(vports[i]);
+        lpfc_destroy_vport_work_array(phba, vports);
+
         if ((phba->link_state == LPFC_HBA_ERROR) ||
                 (phba->pport->load_flag & FC_UNLOADING) ||
                 (phba->pport->fc_flag & FC_OFFLINE_MODE))
@@ -1254,7 +1380,7 @@ lpfc_handle_eratt_s4(struct lpfc_hba *phba)
  * routine from the API jump table function pointer from the lpfc_hba struct.
  *
  * Return codes
- *   0 - sucess.
+ *   0 - success.
  *   Any other value - error.
  **/
 void
@@ -1521,10 +1647,10 @@ lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
         int GE = 0;
         int oneConnect = 0; /* default is not a oneConnect */
         struct {
-                char * name;
-                int    max_speed;
-                char * bus;
-        } m = {"<Unknown>", 0, ""};
+                char *name;
+                char *bus;
+                char *function;
+        } m = {"<Unknown>", "", ""};
 
         if (mdp && mdp[0] != '\0'
                 && descp && descp[0] != '\0')
@@ -1545,132 +1671,155 @@ lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
 
         switch (dev_id) {
         case PCI_DEVICE_ID_FIREFLY:
-                m = (typeof(m)){"LP6000", max_speed, "PCI"};
+                m = (typeof(m)){"LP6000", "PCI", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_SUPERFLY:
                 if (vp->rev.biuRev >= 1 && vp->rev.biuRev <= 3)
-                        m = (typeof(m)){"LP7000", max_speed,  "PCI"};
+                        m = (typeof(m)){"LP7000", "PCI",
+                                        "Fibre Channel Adapter"};
                 else
-                        m = (typeof(m)){"LP7000E", max_speed, "PCI"};
+                        m = (typeof(m)){"LP7000E", "PCI",
+                                        "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_DRAGONFLY:
-                m = (typeof(m)){"LP8000", max_speed, "PCI"};
+                m = (typeof(m)){"LP8000", "PCI",
+                                "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_CENTAUR:
                 if (FC_JEDEC_ID(vp->rev.biuRev) == CENTAUR_2G_JEDEC_ID)
-                        m = (typeof(m)){"LP9002", max_speed, "PCI"};
+                        m = (typeof(m)){"LP9002", "PCI",
+                                        "Fibre Channel Adapter"};
                 else
-                        m = (typeof(m)){"LP9000", max_speed, "PCI"};
+                        m = (typeof(m)){"LP9000", "PCI",
+                                        "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_RFLY:
-                m = (typeof(m)){"LP952", max_speed, "PCI"};
+                m = (typeof(m)){"LP952", "PCI",
+                                "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_PEGASUS:
-                m = (typeof(m)){"LP9802", max_speed, "PCI-X"};
+                m = (typeof(m)){"LP9802", "PCI-X",
+                                "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_THOR:
-                m = (typeof(m)){"LP10000", max_speed, "PCI-X"};
+                m = (typeof(m)){"LP10000", "PCI-X",
+                                "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_VIPER:
-                m = (typeof(m)){"LPX1000", max_speed,  "PCI-X"};
+                m = (typeof(m)){"LPX1000",  "PCI-X",
+                                "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_PFLY:
-                m = (typeof(m)){"LP982", max_speed, "PCI-X"};
+                m = (typeof(m)){"LP982", "PCI-X",
+                                "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_TFLY:
-                m = (typeof(m)){"LP1050", max_speed, "PCI-X"};
+                m = (typeof(m)){"LP1050", "PCI-X",
+                                "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_HELIOS:
-                m = (typeof(m)){"LP11000", max_speed, "PCI-X2"};
+                m = (typeof(m)){"LP11000", "PCI-X2",
+                                "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_HELIOS_SCSP:
-                m = (typeof(m)){"LP11000-SP", max_speed, "PCI-X2"};
+                m = (typeof(m)){"LP11000-SP", "PCI-X2",
+                                "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_HELIOS_DCSP:
-                m = (typeof(m)){"LP11002-SP", max_speed, "PCI-X2"};
+                m = (typeof(m)){"LP11002-SP",  "PCI-X2",
+                                "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_NEPTUNE:
-                m = (typeof(m)){"LPe1000", max_speed, "PCIe"};
+                m = (typeof(m)){"LPe1000", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_NEPTUNE_SCSP:
-                m = (typeof(m)){"LPe1000-SP", max_speed, "PCIe"};
+                m = (typeof(m)){"LPe1000-SP", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_NEPTUNE_DCSP:
-                m = (typeof(m)){"LPe1002-SP", max_speed, "PCIe"};
+                m = (typeof(m)){"LPe1002-SP", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_BMID:
-                m = (typeof(m)){"LP1150", max_speed, "PCI-X2"};
+                m = (typeof(m)){"LP1150", "PCI-X2", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_BSMB:
-                m = (typeof(m)){"LP111", max_speed, "PCI-X2"};
+                m = (typeof(m)){"LP111", "PCI-X2", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_ZEPHYR:
-                m = (typeof(m)){"LPe11000", max_speed, "PCIe"};
+                m = (typeof(m)){"LPe11000", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_ZEPHYR_SCSP:
-                m = (typeof(m)){"LPe11000", max_speed, "PCIe"};
+                m = (typeof(m)){"LPe11000", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_ZEPHYR_DCSP:
-                m = (typeof(m)){"LP2105", max_speed, "PCIe"};
+                m = (typeof(m)){"LP2105", "PCIe", "FCoE Adapter"};
                 GE = 1;
                 break;
         case PCI_DEVICE_ID_ZMID:
-                m = (typeof(m)){"LPe1150", max_speed, "PCIe"};
+                m = (typeof(m)){"LPe1150", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_ZSMB:
-                m = (typeof(m)){"LPe111", max_speed, "PCIe"};
+                m = (typeof(m)){"LPe111", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_LP101:
-                m = (typeof(m)){"LP101", max_speed, "PCI-X"};
+                m = (typeof(m)){"LP101", "PCI-X", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_LP10000S:
-                m = (typeof(m)){"LP10000-S", max_speed, "PCI"};
+                m = (typeof(m)){"LP10000-S", "PCI", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_LP11000S:
-                m = (typeof(m)){"LP11000-S", max_speed,
-                        "PCI-X2"};
+                m = (typeof(m)){"LP11000-S", "PCI-X2", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_LPE11000S:
-                m = (typeof(m)){"LPe11000-S", max_speed,
-                        "PCIe"};
+                m = (typeof(m)){"LPe11000-S", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_SAT:
-                m = (typeof(m)){"LPe12000", max_speed, "PCIe"};
+                m = (typeof(m)){"LPe12000", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_SAT_MID:
-                m = (typeof(m)){"LPe1250", max_speed, "PCIe"};
+                m = (typeof(m)){"LPe1250", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_SAT_SMB:
-                m = (typeof(m)){"LPe121", max_speed, "PCIe"};
+                m = (typeof(m)){"LPe121", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_SAT_DCSP:
-                m = (typeof(m)){"LPe12002-SP", max_speed, "PCIe"};
+                m = (typeof(m)){"LPe12002-SP", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_SAT_SCSP:
-                m = (typeof(m)){"LPe12000-SP", max_speed, "PCIe"};
+                m = (typeof(m)){"LPe12000-SP", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_SAT_S:
-                m = (typeof(m)){"LPe12000-S", max_speed, "PCIe"};
+                m = (typeof(m)){"LPe12000-S", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_HORNET:
-                m = (typeof(m)){"LP21000", max_speed, "PCIe"};
+                m = (typeof(m)){"LP21000", "PCIe", "FCoE Adapter"};
                 GE = 1;
                 break;
         case PCI_DEVICE_ID_PROTEUS_VF:
-                m = (typeof(m)) {"LPev12000", max_speed, "PCIe IOV"};
+                m = (typeof(m)){"LPev12000", "PCIe IOV",
+                                "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_PROTEUS_PF:
-                m = (typeof(m)) {"LPev12000", max_speed, "PCIe IOV"};
+                m = (typeof(m)){"LPev12000", "PCIe IOV",
+                                "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_PROTEUS_S:
-                m = (typeof(m)) {"LPemv12002-S", max_speed, "PCIe IOV"};
+                m = (typeof(m)){"LPemv12002-S", "PCIe IOV",
+                                "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_TIGERSHARK:
                 oneConnect = 1;
-                m = (typeof(m)) {"OCe10100-F", max_speed, "PCIe"};
+                m = (typeof(m)){"OCe10100", "PCIe", "FCoE"};
+                break;
+        case PCI_DEVICE_ID_TOMCAT:
+                oneConnect = 1;
+                m = (typeof(m)){"OCe11100", "PCIe", "FCoE"};
+                break;
+        case PCI_DEVICE_ID_FALCON:
+                m = (typeof(m)){"LPSe12002-ML1-E", "PCIe",
+                                "EmulexSecure Fibre"};
                 break;
         default:
-                m = (typeof(m)){ NULL };
+                m = (typeof(m)){"Unknown", "", ""};
                 break;
         }
 
@@ -1682,17 +1831,14 @@ lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
         if (descp && descp[0] == '\0') {
                 if (oneConnect)
                         snprintf(descp, 255,
-                                "Emulex OneConnect %s, FCoE Initiator, Port %s",
-                                m.name,
+                                "Emulex OneConnect %s, %s Initiator, Port %s",
+                                m.name, m.function,
                                 phba->Port);
                 else
                         snprintf(descp, 255,
                                 "Emulex %s %d%s %s %s",
-                                m.name, m.max_speed,
-                                (GE) ? "GE" : "Gb",
-                                m.bus,
-                                (GE) ? "FCoE Adapter" :
-                                        "Fibre Channel Adapter");
+                                m.name, max_speed, (GE) ? "GE" : "Gb",
+                                m.bus, m.function);
         }
 }
 
@@ -2045,6 +2191,46 @@ lpfc_stop_vport_timers(struct lpfc_vport *vport)
 }
 
 /**
+ * __lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine stops the SLI4 FCF rediscover wait timer if it's on. The
+ * caller of this routine should already hold the host lock.
+ **/
+void
+__lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba)
+{
+        /* Clear pending FCF rediscovery wait and failover in progress flags */
+        phba->fcf.fcf_flag &= ~(FCF_REDISC_PEND |
+                                FCF_DEAD_DISC |
+                                FCF_ACVL_DISC);
+        /* Now, try to stop the timer */
+        del_timer(&phba->fcf.redisc_wait);
+}
+
+/**
+ * lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine stops the SLI4 FCF rediscover wait timer if it's on. It
+ * checks whether the FCF rediscovery wait timer is pending with the host
+ * lock held before proceeding with disabling the timer and clearing the
+ * wait timer pendig flag.
+ **/
+void
+lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba)
+{
+        spin_lock_irq(&phba->hbalock);
+        if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) {
+                /* FCF rediscovery timer already fired or stopped */
+                spin_unlock_irq(&phba->hbalock);
+                return;
+        }
+        __lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
+        spin_unlock_irq(&phba->hbalock);
+}
+
+/**
  * lpfc_stop_hba_timers - Stop all the timers associated with an HBA
  * @phba: pointer to lpfc hba data structure.
  *
@@ -2068,6 +2254,7 @@ lpfc_stop_hba_timers(struct lpfc_hba *phba)
                 break;
         case LPFC_PCI_DEV_OC:
                 /* Stop any OneConnect device sepcific driver timers */
+                lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
                 break;
         default:
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -2200,6 +2387,7 @@ lpfc_offline_prep(struct lpfc_hba * phba)
         struct lpfc_vport *vport = phba->pport;
         struct lpfc_nodelist  *ndlp, *next_ndlp;
         struct lpfc_vport **vports;
+        struct Scsi_Host *shost;
         int i;
 
         if (vport->fc_flag & FC_OFFLINE_MODE)
@@ -2213,11 +2401,15 @@ lpfc_offline_prep(struct lpfc_hba * phba)
         vports = lpfc_create_vport_work_array(phba);
         if (vports != NULL) {
                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
-                        struct Scsi_Host *shost;
-
                         if (vports[i]->load_flag & FC_UNLOADING)
                                 continue;
-                        vports[i]->vfi_state &= ~LPFC_VFI_REGISTERED;
+                        shost = lpfc_shost_from_vport(vports[i]);
+                        spin_lock_irq(shost->host_lock);
+                        vports[i]->vpi_state &= ~LPFC_VPI_REGISTERED;
+                        vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
+                        vports[i]->fc_flag &= ~FC_VFI_REGISTERED;
+                        spin_unlock_irq(shost->host_lock);
+
                         shost = lpfc_shost_from_vport(vports[i]);
                         list_for_each_entry_safe(ndlp, next_ndlp,
                                                  &vports[i]->fc_nodes,
@@ -2308,6 +2500,7 @@ lpfc_scsi_free(struct lpfc_hba *phba)
 
         spin_lock_irq(&phba->hbalock);
         /* Release all the lpfc_scsi_bufs maintained by this host. */
+        spin_lock(&phba->scsi_buf_list_lock);
         list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list, list) {
                 list_del(&sb->list);
                 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, sb->data,
@@ -2315,6 +2508,7 @@ lpfc_scsi_free(struct lpfc_hba *phba)
                 kfree(sb);
                 phba->total_scsi_bufs--;
         }
+        spin_unlock(&phba->scsi_buf_list_lock);
 
         /* Release all the lpfc_iocbq entries maintained by this host. */
         list_for_each_entry_safe(io, io_next, &phba->lpfc_iocb_list, list) {
@@ -2322,9 +2516,7 @@ lpfc_scsi_free(struct lpfc_hba *phba)
                 kfree(io);
                 phba->total_iocbq_bufs--;
         }
-
         spin_unlock_irq(&phba->hbalock);
-
         return 0;
 }
 
@@ -2373,7 +2565,8 @@ lpfc_create_port(struct lpfc_hba *phba, int instance, struct device *dev)
         shost->this_id = -1;
         shost->max_cmd_len = 16;
         if (phba->sli_rev == LPFC_SLI_REV4) {
-                shost->dma_boundary = LPFC_SLI4_MAX_SEGMENT_SIZE;
+                shost->dma_boundary =
+                        phba->sli4_hba.pc_sli4_params.sge_supp_len;
                 shost->sg_tablesize = phba->cfg_sg_seg_cnt;
         }
 
@@ -2407,8 +2600,16 @@ lpfc_create_port(struct lpfc_hba *phba, int instance, struct device *dev)
         init_timer(&vport->els_tmofunc);
         vport->els_tmofunc.function = lpfc_els_timeout;
         vport->els_tmofunc.data = (unsigned long)vport;
+        if (phba->pcidev->device == PCI_DEVICE_ID_HORNET) {
+                phba->menlo_flag |= HBA_MENLO_SUPPORT;
+                /* check for menlo minimum sg count */
+                if (phba->cfg_sg_seg_cnt < LPFC_DEFAULT_MENLO_SG_SEG_CNT) {
+                        phba->cfg_sg_seg_cnt = LPFC_DEFAULT_MENLO_SG_SEG_CNT;
+                        shost->sg_tablesize = phba->cfg_sg_seg_cnt;
+                }
+        }
 
-        error = scsi_add_host(shost, dev);
+        error = scsi_add_host_with_dma(shost, dev, &phba->pcidev->dev);
         if (error)
                 goto out_put_shost;
 
@@ -2622,8 +2823,6 @@ lpfc_stop_port_s4(struct lpfc_hba *phba)
         lpfc_stop_hba_timers(phba);
         phba->pport->work_port_events = 0;
         phba->sli4_hba.intr_enable = 0;
-        /* Hard clear it for now, shall have more graceful way to wait later */
-        phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
 }
 
 /**
@@ -2675,7 +2874,7 @@ lpfc_sli_remove_dflt_fcf(struct lpfc_hba *phba)
         del_fcf_record = &mboxq->u.mqe.un.del_fcf_entry;
         bf_set(lpfc_mbx_del_fcf_tbl_count, del_fcf_record, 1);
         bf_set(lpfc_mbx_del_fcf_tbl_index, del_fcf_record,
-               phba->fcf.fcf_indx);
+               phba->fcf.current_rec.fcf_indx);
 
         if (!phba->sli4_hba.intr_enable)
                 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
@@ -2699,6 +2898,117 @@ lpfc_sli_remove_dflt_fcf(struct lpfc_hba *phba)
 }
 
 /**
+ * lpfc_fcf_redisc_wait_start_timer - Start fcf rediscover wait timer
+ * @phba: Pointer to hba for which this call is being executed.
+ *
+ * This routine starts the timer waiting for the FCF rediscovery to complete.
+ **/
+void
+lpfc_fcf_redisc_wait_start_timer(struct lpfc_hba *phba)
+{
+        unsigned long fcf_redisc_wait_tmo =
+                (jiffies + msecs_to_jiffies(LPFC_FCF_REDISCOVER_WAIT_TMO));
+        /* Start fcf rediscovery wait period timer */
+        mod_timer(&phba->fcf.redisc_wait, fcf_redisc_wait_tmo);
+        spin_lock_irq(&phba->hbalock);
+        /* Allow action to new fcf asynchronous event */
+        phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_SCAN_DONE);
+        /* Mark the FCF rediscovery pending state */
+        phba->fcf.fcf_flag |= FCF_REDISC_PEND;
+        spin_unlock_irq(&phba->hbalock);
+}
+
+/**
+ * lpfc_sli4_fcf_redisc_wait_tmo - FCF table rediscover wait timeout
+ * @ptr: Map to lpfc_hba data structure pointer.
+ *
+ * This routine is invoked when waiting for FCF table rediscover has been
+ * timed out. If new FCF record(s) has (have) been discovered during the
+ * wait period, a new FCF event shall be added to the FCOE async event
+ * list, and then worker thread shall be waked up for processing from the
+ * worker thread context.
+ **/
+void
+lpfc_sli4_fcf_redisc_wait_tmo(unsigned long ptr)
+{
+        struct lpfc_hba *phba = (struct lpfc_hba *)ptr;
+
+        /* Don't send FCF rediscovery event if timer cancelled */
+        spin_lock_irq(&phba->hbalock);
+        if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) {
+                spin_unlock_irq(&phba->hbalock);
+                return;
+        }
+        /* Clear FCF rediscovery timer pending flag */
+        phba->fcf.fcf_flag &= ~FCF_REDISC_PEND;
+        /* FCF rediscovery event to worker thread */
+        phba->fcf.fcf_flag |= FCF_REDISC_EVT;
+        spin_unlock_irq(&phba->hbalock);
+        lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
+                        "2776 FCF rediscover wait timer expired, post "
+                        "a worker thread event for FCF table scan\n");
+        /* wake up worker thread */
+        lpfc_worker_wake_up(phba);
+}
+
+/**
+ * lpfc_sli4_fw_cfg_check - Read the firmware config and verify FCoE support
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This function uses the QUERY_FW_CFG mailbox command to determine if the
+ * firmware loaded supports FCoE. A return of zero indicates that the mailbox
+ * was successful and the firmware supports FCoE. Any other return indicates
+ * a error. It is assumed that this function will be called before interrupts
+ * are enabled.
+ **/
+static int
+lpfc_sli4_fw_cfg_check(struct lpfc_hba *phba)
+{
+        int rc = 0;
+        LPFC_MBOXQ_t *mboxq;
+        struct lpfc_mbx_query_fw_cfg *query_fw_cfg;
+        uint32_t length;
+        uint32_t shdr_status, shdr_add_status;
+
+        mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mboxq) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "2621 Failed to allocate mbox for "
+                                "query firmware config cmd\n");
+                return -ENOMEM;
+        }
+        query_fw_cfg = &mboxq->u.mqe.un.query_fw_cfg;
+        length = (sizeof(struct lpfc_mbx_query_fw_cfg) -
+                  sizeof(struct lpfc_sli4_cfg_mhdr));
+        lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
+                         LPFC_MBOX_OPCODE_QUERY_FW_CFG,
+                         length, LPFC_SLI4_MBX_EMBED);
+        rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
+        /* The IOCTL status is embedded in the mailbox subheader. */
+        shdr_status = bf_get(lpfc_mbox_hdr_status,
+                             &query_fw_cfg->header.cfg_shdr.response);
+        shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
+                                 &query_fw_cfg->header.cfg_shdr.response);
+        if (shdr_status || shdr_add_status || rc != MBX_SUCCESS) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "2622 Query Firmware Config failed "
+                                "mbx status x%x, status x%x add_status x%x\n",
+                                rc, shdr_status, shdr_add_status);
+                return -EINVAL;
+        }
+        if (!bf_get(lpfc_function_mode_fcoe_i, query_fw_cfg)) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "2623 FCoE Function not supported by firmware. "
+                                "Function mode = %08x\n",
+                                query_fw_cfg->function_mode);
+                return -EINVAL;
+        }
+        if (rc != MBX_TIMEOUT)
+                mempool_free(mboxq, phba->mbox_mem_pool);
+        return 0;
+}
+
+/**
  * lpfc_sli4_parse_latt_fault - Parse sli4 link-attention link fault code
  * @phba: pointer to lpfc hba data structure.
  * @acqe_link: pointer to the async link completion queue entry.
@@ -2893,6 +3203,8 @@ lpfc_sli4_async_link_evt(struct lpfc_hba *phba,
                                 bf_get(lpfc_acqe_link_physical, acqe_link);
         phba->sli4_hba.link_state.fault =
                                 bf_get(lpfc_acqe_link_fault, acqe_link);
+        phba->sli4_hba.link_state.logical_speed =
+                                bf_get(lpfc_acqe_qos_link_speed, acqe_link);
 
         /* Invoke the lpfc_handle_latt mailbox command callback function */
         lpfc_mbx_cmpl_read_la(phba, pmb);
@@ -2906,6 +3218,68 @@ out_free_pmb:
 }
 
 /**
+ * lpfc_sli4_perform_vport_cvl - Perform clear virtual link on a vport
+ * @vport: pointer to vport data structure.
+ *
+ * This routine is to perform Clear Virtual Link (CVL) on a vport in
+ * response to a CVL event.
+ *
+ * Return the pointer to the ndlp with the vport if successful, otherwise
+ * return NULL.
+ **/
+static struct lpfc_nodelist *
+lpfc_sli4_perform_vport_cvl(struct lpfc_vport *vport)
+{
+        struct lpfc_nodelist *ndlp;
+        struct Scsi_Host *shost;
+        struct lpfc_hba *phba;
+
+        if (!vport)
+                return NULL;
+        ndlp = lpfc_findnode_did(vport, Fabric_DID);
+        if (!ndlp)
+                return NULL;
+        phba = vport->phba;
+        if (!phba)
+                return NULL;
+        if (phba->pport->port_state <= LPFC_FLOGI)
+                return NULL;
+        /* If virtual link is not yet instantiated ignore CVL */
+        if (vport->port_state <= LPFC_FDISC)
+                return NULL;
+        shost = lpfc_shost_from_vport(vport);
+        if (!shost)
+                return NULL;
+        lpfc_linkdown_port(vport);
+        lpfc_cleanup_pending_mbox(vport);
+        spin_lock_irq(shost->host_lock);
+        vport->fc_flag |= FC_VPORT_CVL_RCVD;
+        spin_unlock_irq(shost->host_lock);
+
+        return ndlp;
+}
+
+/**
+ * lpfc_sli4_perform_all_vport_cvl - Perform clear virtual link on all vports
+ * @vport: pointer to lpfc hba data structure.
+ *
+ * This routine is to perform Clear Virtual Link (CVL) on all vports in
+ * response to a FCF dead event.
+ **/
+static void
+lpfc_sli4_perform_all_vport_cvl(struct lpfc_hba *phba)
+{
+        struct lpfc_vport **vports;
+        int i;
+
+        vports = lpfc_create_vport_work_array(phba);
+        if (vports)
+                for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
+                        lpfc_sli4_perform_vport_cvl(vports[i]);
+        lpfc_destroy_vport_work_array(phba, vports);
+}
+
+/**
  * lpfc_sli4_async_fcoe_evt - Process the asynchronous fcoe event
  * @phba: pointer to lpfc hba data structure.
  * @acqe_link: pointer to the async fcoe completion queue entry.
@@ -2918,33 +3292,71 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
 {
         uint8_t event_type = bf_get(lpfc_acqe_fcoe_event_type, acqe_fcoe);
         int rc;
+        struct lpfc_vport *vport;
+        struct lpfc_nodelist *ndlp;
+        struct Scsi_Host  *shost;
+        int active_vlink_present;
+        struct lpfc_vport **vports;
+        int i;
 
+        phba->fc_eventTag = acqe_fcoe->event_tag;
         phba->fcoe_eventtag = acqe_fcoe->event_tag;
         switch (event_type) {
         case LPFC_FCOE_EVENT_TYPE_NEW_FCF:
-                lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
-                        "2546 New FCF found index 0x%x tag 0x%x\n",
-                        acqe_fcoe->fcf_index,
-                        acqe_fcoe->event_tag);
-                /*
-                 * If the current FCF is in discovered state, or
-                 * FCF discovery is in progress do nothing.
-                 */
+        case LPFC_FCOE_EVENT_TYPE_FCF_PARAM_MOD:
+                lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
+                        "2546 New FCF found/FCF parameter modified event: "
+                        "evt_tag:x%x, fcf_index:x%x\n",
+                        acqe_fcoe->event_tag, acqe_fcoe->index);
+
                 spin_lock_irq(&phba->hbalock);
-                if ((phba->fcf.fcf_flag & FCF_DISCOVERED) ||
-                   (phba->hba_flag & FCF_DISC_INPROGRESS)) {
+                if ((phba->fcf.fcf_flag & FCF_SCAN_DONE) ||
+                    (phba->hba_flag & FCF_DISC_INPROGRESS)) {
+                        /*
+                         * If the current FCF is in discovered state or
+                         * FCF discovery is in progress, do nothing.
+                         */
+                        spin_unlock_irq(&phba->hbalock);
+                        break;
+                }
+
+                if (phba->fcf.fcf_flag & FCF_REDISC_EVT) {
+                        /*
+                         * If fast FCF failover rescan event is pending,
+                         * do nothing.
+                         */
                         spin_unlock_irq(&phba->hbalock);
                         break;
                 }
                 spin_unlock_irq(&phba->hbalock);
 
-                /* Read the FCF table and re-discover SAN. */
-                rc = lpfc_sli4_read_fcf_record(phba,
-                        LPFC_FCOE_FCF_GET_FIRST);
+                if ((phba->fcf.fcf_flag & FCF_DISCOVERY) &&
+                    !(phba->fcf.fcf_flag & FCF_REDISC_FOV)) {
+                        /*
+                         * During period of FCF discovery, read the FCF
+                         * table record indexed by the event to update
+                         * FCF round robin failover eligible FCF bmask.
+                         */
+                        lpfc_printf_log(phba, KERN_INFO, LOG_FIP |
+                                        LOG_DISCOVERY,
+                                        "2779 Read new FCF record with "
+                                        "fcf_index:x%x for updating FCF "
+                                        "round robin failover bmask\n",
+                                        acqe_fcoe->index);
+                        rc = lpfc_sli4_read_fcf_rec(phba, acqe_fcoe->index);
+                }
+
+                /* Otherwise, scan the entire FCF table and re-discover SAN */
+                lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
+                                "2770 Start FCF table scan due to new FCF "
+                                "event: evt_tag:x%x, fcf_index:x%x\n",
+                                acqe_fcoe->event_tag, acqe_fcoe->index);
+                rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba,
+                                                     LPFC_FCOE_FCF_GET_FIRST);
                 if (rc)
-                        lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
-                                "2547 Read FCF record failed 0x%x\n",
-                                rc);
+                        lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
+                                        "2547 Issue FCF scan read FCF mailbox "
+                                        "command failed 0x%x\n", rc);
                 break;
 
         case LPFC_FCOE_EVENT_TYPE_FCF_TABLE_FULL:
@@ -2955,22 +3367,130 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                 break;
 
         case LPFC_FCOE_EVENT_TYPE_FCF_DEAD:
-                lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
-                        "2549 FCF disconnected fron network index 0x%x"
-                        " tag 0x%x\n", acqe_fcoe->fcf_index,
+                lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
+                        "2549 FCF disconnected from network index 0x%x"
+                        " tag 0x%x\n", acqe_fcoe->index,
                         acqe_fcoe->event_tag);
                 /* If the event is not for currently used fcf do nothing */
-                if (phba->fcf.fcf_indx != acqe_fcoe->fcf_index)
+                if (phba->fcf.current_rec.fcf_indx != acqe_fcoe->index)
                         break;
-                /*
-                 * Currently, driver support only one FCF - so treat this as
-                 * a link down.
+                /* We request port to rediscover the entire FCF table for
+                 * a fast recovery from case that the current FCF record
+                 * is no longer valid if we are not in the middle of FCF
+                 * failover process already.
                  */
-                lpfc_linkdown(phba);
-                /* Unregister FCF if no devices connected to it */
-                lpfc_unregister_unused_fcf(phba);
+                spin_lock_irq(&phba->hbalock);
+                if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
+                        spin_unlock_irq(&phba->hbalock);
+                        /* Update FLOGI FCF failover eligible FCF bmask */
+                        lpfc_sli4_fcf_rr_index_clear(phba, acqe_fcoe->index);
+                        break;
+                }
+                /* Mark the fast failover process in progress */
+                phba->fcf.fcf_flag |= FCF_DEAD_DISC;
+                spin_unlock_irq(&phba->hbalock);
+                lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
+                                "2771 Start FCF fast failover process due to "
+                                "FCF DEAD event: evt_tag:x%x, fcf_index:x%x "
+                                "\n", acqe_fcoe->event_tag, acqe_fcoe->index);
+                rc = lpfc_sli4_redisc_fcf_table(phba);
+                if (rc) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
+                                        LOG_DISCOVERY,
+                                        "2772 Issue FCF rediscover mabilbox "
+                                        "command failed, fail through to FCF "
+                                        "dead event\n");
+                        spin_lock_irq(&phba->hbalock);
+                        phba->fcf.fcf_flag &= ~FCF_DEAD_DISC;
+                        spin_unlock_irq(&phba->hbalock);
+                        /*
+                         * Last resort will fail over by treating this
+                         * as a link down to FCF registration.
+                         */
+                        lpfc_sli4_fcf_dead_failthrough(phba);
+                } else
+                        /* Handling fast FCF failover to a DEAD FCF event
+                         * is considered equalivant to receiving CVL to all
+                         * vports.
+                         */
+                        lpfc_sli4_perform_all_vport_cvl(phba);
                 break;
+        case LPFC_FCOE_EVENT_TYPE_CVL:
+                lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
+                        "2718 Clear Virtual Link Received for VPI 0x%x"
+                        " tag 0x%x\n", acqe_fcoe->index, acqe_fcoe->event_tag);
+                vport = lpfc_find_vport_by_vpid(phba,
+                                acqe_fcoe->index - phba->vpi_base);
+                ndlp = lpfc_sli4_perform_vport_cvl(vport);
+                if (!ndlp)
+                        break;
+                active_vlink_present = 0;
+
+                vports = lpfc_create_vport_work_array(phba);
+                if (vports) {
+                        for (i = 0; i <= phba->max_vports && vports[i] != NULL;
+                                        i++) {
+                                if ((!(vports[i]->fc_flag &
+                                        FC_VPORT_CVL_RCVD)) &&
+                                        (vports[i]->port_state > LPFC_FDISC)) {
+                                        active_vlink_present = 1;
+                                        break;
+                                }
+                        }
+                        lpfc_destroy_vport_work_array(phba, vports);
+                }
 
+                if (active_vlink_present) {
+                        /*
+                         * If there are other active VLinks present,
+                         * re-instantiate the Vlink using FDISC.
+                         */
+                        mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
+                        shost = lpfc_shost_from_vport(vport);
+                        spin_lock_irq(shost->host_lock);
+                        ndlp->nlp_flag |= NLP_DELAY_TMO;
+                        spin_unlock_irq(shost->host_lock);
+                        ndlp->nlp_last_elscmd = ELS_CMD_FDISC;
+                        vport->port_state = LPFC_FDISC;
+                } else {
+                        /*
+                         * Otherwise, we request port to rediscover
+                         * the entire FCF table for a fast recovery
+                         * from possible case that the current FCF
+                         * is no longer valid if we are not already
+                         * in the FCF failover process.
+                         */
+                        spin_lock_irq(&phba->hbalock);
+                        if (phba->fcf.fcf_flag & FCF_DISCOVERY) {
+                                spin_unlock_irq(&phba->hbalock);
+                                break;
+                        }
+                        /* Mark the fast failover process in progress */
+                        phba->fcf.fcf_flag |= FCF_ACVL_DISC;
+                        spin_unlock_irq(&phba->hbalock);
+                        lpfc_printf_log(phba, KERN_INFO, LOG_FIP |
+                                        LOG_DISCOVERY,
+                                        "2773 Start FCF fast failover due "
+                                        "to CVL event: evt_tag:x%x\n",
+                                        acqe_fcoe->event_tag);
+                        rc = lpfc_sli4_redisc_fcf_table(phba);
+                        if (rc) {
+                                lpfc_printf_log(phba, KERN_ERR, LOG_FIP |
+                                                LOG_DISCOVERY,
+                                                "2774 Issue FCF rediscover "
+                                                "mabilbox command failed, "
+                                                "through to CVL event\n");
+                                spin_lock_irq(&phba->hbalock);
+                                phba->fcf.fcf_flag &= ~FCF_ACVL_DISC;
+                                spin_unlock_irq(&phba->hbalock);
+                                /*
+                                 * Last resort will be re-try on the
+                                 * the current registered FCF entry.
+                                 */
+                                lpfc_retry_pport_discovery(phba);
+                        }
+                }
+                break;
         default:
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                         "0288 Unknown FCoE event type 0x%x event tag "
@@ -2990,6 +3510,7 @@ static void
 lpfc_sli4_async_dcbx_evt(struct lpfc_hba *phba,
                          struct lpfc_acqe_dcbx *acqe_dcbx)
 {
+        phba->fc_eventTag = acqe_dcbx->event_tag;
         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                         "0290 The SLI4 DCBX asynchronous event is not "
                         "handled yet\n");
@@ -3044,6 +3565,37 @@ void lpfc_sli4_async_event_proc(struct lpfc_hba *phba)
 }
 
 /**
+ * lpfc_sli4_fcf_redisc_event_proc - Process fcf table rediscovery event
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is invoked by the worker thread to process FCF table
+ * rediscovery pending completion event.
+ **/
+void lpfc_sli4_fcf_redisc_event_proc(struct lpfc_hba *phba)
+{
+        int rc;
+
+        spin_lock_irq(&phba->hbalock);
+        /* Clear FCF rediscovery timeout event */
+        phba->fcf.fcf_flag &= ~FCF_REDISC_EVT;
+        /* Clear driver fast failover FCF record flag */
+        phba->fcf.failover_rec.flag = 0;
+        /* Set state for FCF fast failover */
+        phba->fcf.fcf_flag |= FCF_REDISC_FOV;
+        spin_unlock_irq(&phba->hbalock);
+
+        /* Scan FCF table from the first entry to re-discover SAN */
+        lpfc_printf_log(phba, KERN_INFO, LOG_FIP | LOG_DISCOVERY,
+                        "2777 Start FCF table scan after FCF "
+                        "rediscovery quiescent period over\n");
+        rc = lpfc_sli4_fcf_scan_read_fcf_rec(phba, LPFC_FCOE_FCF_GET_FIRST);
+        if (rc)
+                lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
+                                "2747 Issue FCF scan read FCF mailbox "
+                                "command failed 0x%x\n", rc);
+}
+
+/**
  * lpfc_api_table_setup - Set up per hba pci-device group func api jump table
  * @phba: pointer to lpfc hba data structure.
  * @dev_grp: The HBA PCI-Device group number.
@@ -3124,7 +3676,7 @@ static void lpfc_log_intr_mode(struct lpfc_hba *phba, uint32_t intr_mode)
  * PCI devices.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      other values - error
  **/
 static int
@@ -3220,7 +3772,7 @@ lpfc_reset_hba(struct lpfc_hba *phba)
  * support the SLI-3 HBA device it attached to.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      other values - error
  **/
 static int
@@ -3321,15 +3873,18 @@ lpfc_sli_driver_resource_unset(struct lpfc_hba *phba)
  * support the SLI-4 HBA device it attached to.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      other values - error
  **/
 static int
 lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
 {
         struct lpfc_sli *psli;
-        int rc;
-        int i, hbq_count;
+        LPFC_MBOXQ_t *mboxq;
+        int rc, i, hbq_count, buf_size, dma_buf_size, max_buf_size;
+        uint8_t pn_page[LPFC_MAX_SUPPORTED_PAGES] = {0};
+        struct lpfc_mqe *mqe;
+        int longs;
 
         /* Before proceed, wait for POST done and device ready */
         rc = lpfc_sli4_post_status_check(phba);
@@ -3358,6 +3913,11 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
         init_timer(&phba->eratt_poll);
         phba->eratt_poll.function = lpfc_poll_eratt;
         phba->eratt_poll.data = (unsigned long) phba;
+        /* FCF rediscover timer */
+        init_timer(&phba->fcf.redisc_wait);
+        phba->fcf.redisc_wait.function = lpfc_sli4_fcf_redisc_wait_tmo;
+        phba->fcf.redisc_wait.data = (unsigned long)phba;
+
         /*
          * We need to do a READ_CONFIG mailbox command here before
          * calling lpfc_get_cfgparam. For VFs this will report the
@@ -3382,31 +3942,26 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
          * used to create the sg_dma_buf_pool must be dynamically calculated.
          * 2 segments are added since the IOCB needs a command and response bde.
          * To insure that the scsi sgl does not cross a 4k page boundary only
-         * sgl sizes of 1k, 2k, 4k, and 8k are supported.
-         * Table of sgl sizes and seg_cnt:
-         * sgl size,    sg_seg_cnt      total seg
-         * 1k           50              52
-         * 2k           114             116
-         * 4k           242             244
-         * 8k           498             500
-         * cmd(32) + rsp(160) + (52 * sizeof(sli4_sge)) = 1024
-         * cmd(32) + rsp(160) + (116 * sizeof(sli4_sge)) = 2048
-         * cmd(32) + rsp(160) + (244 * sizeof(sli4_sge)) = 4096
-         * cmd(32) + rsp(160) + (500 * sizeof(sli4_sge)) = 8192
+         * sgl sizes of must be a power of 2.
          */
-        if (phba->cfg_sg_seg_cnt <= LPFC_DEFAULT_SG_SEG_CNT)
-                phba->cfg_sg_seg_cnt = 50;
-        else if (phba->cfg_sg_seg_cnt <= 114)
-                phba->cfg_sg_seg_cnt = 114;
-        else if (phba->cfg_sg_seg_cnt <= 242)
-                phba->cfg_sg_seg_cnt = 242;
+        buf_size = (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp) +
+                    ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct sli4_sge)));
+        /* Feature Level 1 hardware is limited to 2 pages */
+        if ((bf_get(lpfc_sli_intf_featurelevel1, &phba->sli4_hba.sli_intf) ==
+             LPFC_SLI_INTF_FEATURELEVEL1_1))
+                max_buf_size = LPFC_SLI4_FL1_MAX_BUF_SIZE;
         else
-                phba->cfg_sg_seg_cnt = 498;
-
-        phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd)
-                                        + sizeof(struct fcp_rsp);
-        phba->cfg_sg_dma_buf_size +=
-                ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct sli4_sge));
+                max_buf_size = LPFC_SLI4_MAX_BUF_SIZE;
+        for (dma_buf_size = LPFC_SLI4_MIN_BUF_SIZE;
+             dma_buf_size < max_buf_size && buf_size > dma_buf_size;
+             dma_buf_size = dma_buf_size << 1)
+                ;
+        if (dma_buf_size == max_buf_size)
+                phba->cfg_sg_seg_cnt = (dma_buf_size -
+                        sizeof(struct fcp_cmnd) - sizeof(struct fcp_rsp) -
+                        (2 * sizeof(struct sli4_sge))) /
+                                sizeof(struct sli4_sge);
+        phba->cfg_sg_dma_buf_size = dma_buf_size;
 
         /* Initialize buffer queue management fields */
         hbq_count = lpfc_sli_hbq_count();
@@ -3432,7 +3987,7 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
         /* Driver internel slow-path CQ Event pool */
         INIT_LIST_HEAD(&phba->sli4_hba.sp_cqe_event_pool);
         /* Response IOCB work queue list */
-        INIT_LIST_HEAD(&phba->sli4_hba.sp_rspiocb_work_queue);
+        INIT_LIST_HEAD(&phba->sli4_hba.sp_queue_event);
         /* Asynchronous event CQ Event work queue list */
         INIT_LIST_HEAD(&phba->sli4_hba.sp_asynce_work_queue);
         /* Fast-path XRI aborted CQ Event work queue list */
@@ -3461,6 +4016,10 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
         if (unlikely(rc))
                 goto out_free_bsmbx;
 
+        rc = lpfc_sli4_fw_cfg_check(phba);
+        if (unlikely(rc))
+                goto out_free_bsmbx;
+
         /* Set up the hba's configuration parameters. */
         rc = lpfc_sli4_read_config(phba);
         if (unlikely(rc))
@@ -3502,13 +4061,24 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
                 goto out_free_active_sgl;
         }
 
+        /* Allocate eligible FCF bmask memory for FCF round robin failover */
+        longs = (LPFC_SLI4_FCF_TBL_INDX_MAX + BITS_PER_LONG - 1)/BITS_PER_LONG;
+        phba->fcf.fcf_rr_bmask = kzalloc(longs * sizeof(unsigned long),
+                                         GFP_KERNEL);
+        if (!phba->fcf.fcf_rr_bmask) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "2759 Failed allocate memory for FCF round "
+                                "robin failover bmask\n");
+                goto out_remove_rpi_hdrs;
+        }
+
         phba->sli4_hba.fcp_eq_hdl = kzalloc((sizeof(struct lpfc_fcp_eq_hdl) *
                                     phba->cfg_fcp_eq_count), GFP_KERNEL);
         if (!phba->sli4_hba.fcp_eq_hdl) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                 "2572 Failed allocate memory for fast-path "
                                 "per-EQ handle array\n");
-                goto out_remove_rpi_hdrs;
+                goto out_free_fcf_rr_bmask;
         }
 
         phba->sli4_hba.msix_entries = kzalloc((sizeof(struct msix_entry) *
@@ -3520,10 +4090,49 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
                 goto out_free_fcp_eq_hdl;
         }
 
+        mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
+                                                       GFP_KERNEL);
+        if (!mboxq) {
+                rc = -ENOMEM;
+                goto out_free_fcp_eq_hdl;
+        }
+
+        /* Get the Supported Pages. It is always available. */
+        lpfc_supported_pages(mboxq);
+        rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
+        if (unlikely(rc)) {
+                rc = -EIO;
+                mempool_free(mboxq, phba->mbox_mem_pool);
+                goto out_free_fcp_eq_hdl;
+        }
+
+        mqe = &mboxq->u.mqe;
+        memcpy(&pn_page[0], ((uint8_t *)&mqe->un.supp_pages.word3),
+               LPFC_MAX_SUPPORTED_PAGES);
+        for (i = 0; i < LPFC_MAX_SUPPORTED_PAGES; i++) {
+                switch (pn_page[i]) {
+                case LPFC_SLI4_PARAMETERS:
+                        phba->sli4_hba.pc_sli4_params.supported = 1;
+                        break;
+                default:
+                        break;
+                }
+        }
+
+        /* Read the port's SLI4 Parameters capabilities if supported. */
+        if (phba->sli4_hba.pc_sli4_params.supported)
+                rc = lpfc_pc_sli4_params_get(phba, mboxq);
+        mempool_free(mboxq, phba->mbox_mem_pool);
+        if (rc) {
+                rc = -EIO;
+                goto out_free_fcp_eq_hdl;
+        }
         return rc;
 
 out_free_fcp_eq_hdl:
         kfree(phba->sli4_hba.fcp_eq_hdl);
+out_free_fcf_rr_bmask:
+        kfree(phba->fcf.fcf_rr_bmask);
 out_remove_rpi_hdrs:
         lpfc_sli4_remove_rpi_hdrs(phba);
 out_free_active_sgl:
@@ -3569,6 +4178,9 @@ lpfc_sli4_driver_resource_unset(struct lpfc_hba *phba)
         lpfc_sli4_remove_rpi_hdrs(phba);
         lpfc_sli4_remove_rpis(phba);
 
+        /* Free eligible FCF index bmask */
+        kfree(phba->fcf.fcf_rr_bmask);
+
         /* Free the ELS sgl list */
         lpfc_free_active_sgl(phba);
         lpfc_free_sgl_list(phba);
@@ -3594,8 +4206,10 @@ lpfc_sli4_driver_resource_unset(struct lpfc_hba *phba)
 
         /* Free the current connect table */
         list_for_each_entry_safe(conn_entry, next_conn_entry,
-                &phba->fcf_conn_rec_list, list)
+                &phba->fcf_conn_rec_list, list) {
+                list_del_init(&conn_entry->list);
                 kfree(conn_entry);
+        }
 
         return;
 }
@@ -3613,6 +4227,8 @@ lpfc_sli4_driver_resource_unset(struct lpfc_hba *phba)
 int
 lpfc_init_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
 {
+        phba->lpfc_hba_init_link = lpfc_hba_init_link;
+        phba->lpfc_hba_down_link = lpfc_hba_down_link;
         switch (dev_grp) {
         case LPFC_PCI_DEV_LP:
                 phba->lpfc_hba_down_post = lpfc_hba_down_post_s3;
@@ -3642,7 +4258,7 @@ lpfc_init_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
  * device specific resource setup to support the HBA device it attached to.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      other values - error
  **/
 static int
@@ -3688,7 +4304,7 @@ lpfc_setup_driver_resource_phase1(struct lpfc_hba *phba)
  * device specific resource setup to support the HBA device it attached to.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      other values - error
  **/
 static int
@@ -3753,7 +4369,7 @@ lpfc_free_iocb_list(struct lpfc_hba *phba)
  * list and set up the IOCB tag array accordingly.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      other values - error
  **/
 static int
@@ -3824,7 +4440,7 @@ lpfc_free_sgl_list(struct lpfc_hba *phba)
         rc = lpfc_sli4_remove_all_sgl_pages(phba);
         if (rc) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
-                        "2005 Unable to deregister pages from HBA: %x", rc);
+                        "2005 Unable to deregister pages from HBA: %x\n", rc);
         }
         kfree(phba->sli4_hba.lpfc_els_sgl_array);
 }
@@ -3872,7 +4488,7 @@ lpfc_free_active_sgl(struct lpfc_hba *phba)
  * list and set up the sgl xritag tag array accordingly.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      other values - error
  **/
 static int
@@ -3960,6 +4576,7 @@ lpfc_init_sgl_list(struct lpfc_hba *phba)
 
                 /* The list order is used by later block SGL registraton */
                 spin_lock_irq(&phba->hbalock);
+                sglq_entry->state = SGL_FREED;
                 list_add_tail(&sglq_entry->list, &phba->sli4_hba.lpfc_sgl_list);
                 phba->sli4_hba.lpfc_els_sgl_array[i] = sglq_entry;
                 phba->sli4_hba.total_sglq_bufs++;
@@ -3986,7 +4603,7 @@ out_free_mem:
  * enabled and the driver is reinitializing the device.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      ENOMEM - No availble memory
  *      EIO - The mailbox failed to complete successfully.
  **/
@@ -4146,7 +4763,7 @@ lpfc_sli4_remove_rpi_hdrs(struct lpfc_hba *phba)
  * PCI device data structure is set.
  *
  * Return codes
- *      pointer to @phba - sucessful
+ *      pointer to @phba - successful
  *      NULL - error
  **/
 static struct lpfc_hba *
@@ -4171,7 +4788,7 @@ lpfc_hba_alloc(struct pci_dev *pdev)
                 return NULL;
         }
 
-        mutex_init(&phba->ct_event_mutex);
+        spin_lock_init(&phba->ct_ev_lock);
         INIT_LIST_HEAD(&phba->ct_ev_waiters);
 
         return phba;
@@ -4202,7 +4819,7 @@ lpfc_hba_free(struct lpfc_hba *phba)
  * host with it.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      other values - error
  **/
 static int
@@ -4273,7 +4890,8 @@ lpfc_setup_bg(struct lpfc_hba *phba, struct Scsi_Host *shost)
                         _dump_buf_data =
                                 (char *) __get_free_pages(GFP_KERNEL, pagecnt);
                         if (_dump_buf_data) {
-                                printk(KERN_ERR "BLKGRD allocated %d pages for "
+                                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                                        "9043 BLKGRD: allocated %d pages for "
                                        "_dump_buf_data at 0x%p\n",
                                        (1 << pagecnt), _dump_buf_data);
                                 _dump_buf_data_order = pagecnt;
@@ -4284,17 +4902,20 @@ lpfc_setup_bg(struct lpfc_hba *phba, struct Scsi_Host *shost)
                                 --pagecnt;
                 }
                 if (!_dump_buf_data_order)
-                        printk(KERN_ERR "BLKGRD ERROR unable to allocate "
+                        lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                                "9044 BLKGRD: ERROR unable to allocate "
                                "memory for hexdump\n");
         } else
-                printk(KERN_ERR "BLKGRD already allocated _dump_buf_data=0x%p"
+                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                        "9045 BLKGRD: already allocated _dump_buf_data=0x%p"
                        "\n", _dump_buf_data);
         if (!_dump_buf_dif) {
                 while (pagecnt) {
                         _dump_buf_dif =
                                 (char *) __get_free_pages(GFP_KERNEL, pagecnt);
                         if (_dump_buf_dif) {
-                                printk(KERN_ERR "BLKGRD allocated %d pages for "
+                                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                                        "9046 BLKGRD: allocated %d pages for "
                                        "_dump_buf_dif at 0x%p\n",
                                        (1 << pagecnt), _dump_buf_dif);
                                 _dump_buf_dif_order = pagecnt;
@@ -4305,10 +4926,12 @@ lpfc_setup_bg(struct lpfc_hba *phba, struct Scsi_Host *shost)
                                 --pagecnt;
                 }
                 if (!_dump_buf_dif_order)
-                        printk(KERN_ERR "BLKGRD ERROR unable to allocate "
+                        lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                        "9047 BLKGRD: ERROR unable to allocate "
                                "memory for hexdump\n");
         } else
-                printk(KERN_ERR "BLKGRD already allocated _dump_buf_dif=0x%p\n",
+                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                        "9048 BLKGRD: already allocated _dump_buf_dif=0x%p\n",
                        _dump_buf_dif);
 }
 
@@ -4365,7 +4988,7 @@ lpfc_post_init_setup(struct lpfc_hba *phba)
  * with SLI-3 interface spec.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      other values - error
  **/
 static int
@@ -4384,9 +5007,13 @@ lpfc_sli_pci_mem_setup(struct lpfc_hba *phba)
                 pdev = phba->pcidev;
 
         /* Set the device DMA mask size */
-        if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0)
-                if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)
+        if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0
+         || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) {
+                if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0
+                 || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) {
                         return error;
+                }
+        }
 
         /* Get the bus address of Bar0 and Bar2 and the number of bytes
          * required by each mapping.
@@ -4511,8 +5138,7 @@ lpfc_sli_pci_mem_unset(struct lpfc_hba *phba)
 int
 lpfc_sli4_post_status_check(struct lpfc_hba *phba)
 {
-        struct lpfc_register sta_reg, uerrlo_reg, uerrhi_reg, scratchpad;
-        uint32_t onlnreg0, onlnreg1;
+        struct lpfc_register sta_reg, uerrlo_reg, uerrhi_reg;
         int i, port_error = -ENODEV;
 
         if (!phba->sli4_hba.STAregaddr)
@@ -4548,29 +5174,35 @@ lpfc_sli4_post_status_check(struct lpfc_hba *phba)
                         bf_get(lpfc_hst_state_port_status, &sta_reg));
 
         /* Log device information */
-        scratchpad.word0 =  readl(phba->sli4_hba.SCRATCHPADregaddr);
-        lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
-                        "2534 Device Info: ChipType=0x%x, SliRev=0x%x, "
-                        "FeatureL1=0x%x, FeatureL2=0x%x\n",
-                        bf_get(lpfc_scratchpad_chiptype, &scratchpad),
-                        bf_get(lpfc_scratchpad_slirev, &scratchpad),
-                        bf_get(lpfc_scratchpad_featurelevel1, &scratchpad),
-                        bf_get(lpfc_scratchpad_featurelevel2, &scratchpad));
-
+        phba->sli4_hba.sli_intf.word0 = readl(phba->sli4_hba.SLIINTFregaddr);
+        if (bf_get(lpfc_sli_intf_valid,
+                   &phba->sli4_hba.sli_intf) == LPFC_SLI_INTF_VALID) {
+                lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+                                "2534 Device Info: ChipType=0x%x, SliRev=0x%x, "
+                                "FeatureL1=0x%x, FeatureL2=0x%x\n",
+                                bf_get(lpfc_sli_intf_sli_family,
+                                       &phba->sli4_hba.sli_intf),
+                                bf_get(lpfc_sli_intf_slirev,
+                                       &phba->sli4_hba.sli_intf),
+                                bf_get(lpfc_sli_intf_featurelevel1,
+                                       &phba->sli4_hba.sli_intf),
+                                bf_get(lpfc_sli_intf_featurelevel2,
+                                       &phba->sli4_hba.sli_intf));
+        }
+        phba->sli4_hba.ue_mask_lo = readl(phba->sli4_hba.UEMASKLOregaddr);
+        phba->sli4_hba.ue_mask_hi = readl(phba->sli4_hba.UEMASKHIregaddr);
         /* With uncoverable error, log the error message and return error */
-        onlnreg0 = readl(phba->sli4_hba.ONLINE0regaddr);
-        onlnreg1 = readl(phba->sli4_hba.ONLINE1regaddr);
-        if ((onlnreg0 != LPFC_ONLINE_NERR) || (onlnreg1 != LPFC_ONLINE_NERR)) {
-                uerrlo_reg.word0 = readl(phba->sli4_hba.UERRLOregaddr);
-                uerrhi_reg.word0 = readl(phba->sli4_hba.UERRHIregaddr);
-                if (uerrlo_reg.word0 || uerrhi_reg.word0) {
-                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                        "1422 HBA Unrecoverable error: "
-                                        "uerr_lo_reg=0x%x, uerr_hi_reg=0x%x, "
-                                        "online0_reg=0x%x, online1_reg=0x%x\n",
-                                        uerrlo_reg.word0, uerrhi_reg.word0,
-                                        onlnreg0, onlnreg1);
-                }
+        uerrlo_reg.word0 = readl(phba->sli4_hba.UERRLOregaddr);
+        uerrhi_reg.word0 = readl(phba->sli4_hba.UERRHIregaddr);
+        if ((~phba->sli4_hba.ue_mask_lo & uerrlo_reg.word0) ||
+            (~phba->sli4_hba.ue_mask_hi & uerrhi_reg.word0)) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "1422 HBA Unrecoverable error: "
+                                "uerr_lo_reg=0x%x, uerr_hi_reg=0x%x, "
+                                "ue_mask_lo_reg=0x%x, ue_mask_hi_reg=0x%x\n",
+                                uerrlo_reg.word0, uerrhi_reg.word0,
+                                phba->sli4_hba.ue_mask_lo,
+                                phba->sli4_hba.ue_mask_hi);
                 return -ENODEV;
         }
 
@@ -4591,12 +5223,12 @@ lpfc_sli4_bar0_register_memmap(struct lpfc_hba *phba)
                                         LPFC_UERR_STATUS_LO;
         phba->sli4_hba.UERRHIregaddr = phba->sli4_hba.conf_regs_memmap_p +
                                         LPFC_UERR_STATUS_HI;
-        phba->sli4_hba.ONLINE0regaddr = phba->sli4_hba.conf_regs_memmap_p +
-                                        LPFC_ONLINE0;
-        phba->sli4_hba.ONLINE1regaddr = phba->sli4_hba.conf_regs_memmap_p +
-                                        LPFC_ONLINE1;
-        phba->sli4_hba.SCRATCHPADregaddr = phba->sli4_hba.conf_regs_memmap_p +
-                                        LPFC_SCRATCHPAD;
+        phba->sli4_hba.UEMASKLOregaddr = phba->sli4_hba.conf_regs_memmap_p +
+                                        LPFC_UE_MASK_LO;
+        phba->sli4_hba.UEMASKHIregaddr = phba->sli4_hba.conf_regs_memmap_p +
+                                        LPFC_UE_MASK_HI;
+        phba->sli4_hba.SLIINTFregaddr = phba->sli4_hba.conf_regs_memmap_p +
+                                        LPFC_SLI_INTF;
 }
 
 /**
@@ -4662,7 +5294,7 @@ lpfc_sli4_bar2_register_memmap(struct lpfc_hba *phba, uint32_t vf)
  * this routine.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      ENOMEM - could not allocated memory.
  **/
 static int
@@ -4761,7 +5393,7 @@ lpfc_destroy_bootstrap_mbox(struct lpfc_hba *phba)
  * allocation for the port.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      ENOMEM - No availble memory
  *      EIO - The mailbox failed to complete successfully.
  **/
@@ -4825,7 +5457,8 @@ lpfc_sli4_read_config(struct lpfc_hba *phba)
                 phba->vpi_base = phba->sli4_hba.max_cfg_param.vpi_base;
                 phba->vfi_base = phba->sli4_hba.max_cfg_param.vfi_base;
                 phba->sli4_hba.next_rpi = phba->sli4_hba.max_cfg_param.rpi_base;
-                phba->max_vpi = phba->sli4_hba.max_cfg_param.max_vpi;
+                phba->max_vpi = (phba->sli4_hba.max_cfg_param.max_vpi > 0) ?
+                                (phba->sli4_hba.max_cfg_param.max_vpi - 1) : 0;
                 phba->max_vports = phba->max_vpi;
                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
                                 "2003 cfg params XRI(B:%d M:%d), "
@@ -4861,7 +5494,7 @@ lpfc_sli4_read_config(struct lpfc_hba *phba)
  * HBA consistent with the SLI-4 interface spec.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      ENOMEM - No availble memory
  *      EIO - The mailbox failed to complete successfully.
  **/
@@ -4910,7 +5543,7 @@ lpfc_setup_endian_order(struct lpfc_hba *phba)
  * we just use some constant number as place holder.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      ENOMEM - No availble memory
  *      EIO - The mailbox failed to complete successfully.
  **/
@@ -4979,10 +5612,9 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
         /* It does not make sense to have more EQs than WQs */
         if (cfg_fcp_eq_count > phba->cfg_fcp_wq_count) {
                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
-                                "2593 The number of FCP EQs (%d) is more "
-                                "than the number of FCP WQs (%d), take "
-                                "the number of FCP EQs same as than of "
-                                "WQs (%d)\n", cfg_fcp_eq_count,
+                                "2593 The FCP EQ count(%d) cannot be greater "
+                                "than the FCP WQ count(%d), limiting the "
+                                "FCP EQ count to %d\n", cfg_fcp_eq_count,
                                 phba->cfg_fcp_wq_count,
                                 phba->cfg_fcp_wq_count);
                 cfg_fcp_eq_count = phba->cfg_fcp_wq_count;
@@ -5058,15 +5690,6 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
         }
         phba->sli4_hba.els_cq = qdesc;
 
-        /* Create slow-path Unsolicited Receive Complete Queue */
-        qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
-                                      phba->sli4_hba.cq_ecount);
-        if (!qdesc) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "0502 Failed allocate slow-path USOL RX CQ\n");
-                goto out_free_els_cq;
-        }
-        phba->sli4_hba.rxq_cq = qdesc;
 
         /* Create fast-path FCP Completion Queue(s), one-to-one with EQs */
         phba->sli4_hba.fcp_cq = kzalloc((sizeof(struct lpfc_queue *) *
@@ -5075,7 +5698,7 @@ lpfc_sli4_queue_create(struct lpfc_hba *phba)
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                 "2577 Failed allocate memory for fast-path "
                                 "CQ record array\n");
-                goto out_free_rxq_cq;
+                goto out_free_els_cq;
         }
         for (fcp_cqidx = 0; fcp_cqidx < phba->cfg_fcp_eq_count; fcp_cqidx++) {
                 qdesc = lpfc_sli4_queue_alloc(phba, phba->sli4_hba.cq_esize,
@@ -5188,9 +5811,6 @@ out_free_fcp_cq:
                 phba->sli4_hba.fcp_cq[fcp_cqidx] = NULL;
         }
         kfree(phba->sli4_hba.fcp_cq);
-out_free_rxq_cq:
-        lpfc_sli4_queue_free(phba->sli4_hba.rxq_cq);
-        phba->sli4_hba.rxq_cq = NULL;
 out_free_els_cq:
         lpfc_sli4_queue_free(phba->sli4_hba.els_cq);
         phba->sli4_hba.els_cq = NULL;
@@ -5218,7 +5838,7 @@ out_error:
  * operation.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      ENOMEM - No availble memory
  *      EIO - The mailbox failed to complete successfully.
  **/
@@ -5247,10 +5867,6 @@ lpfc_sli4_queue_destroy(struct lpfc_hba *phba)
         lpfc_sli4_queue_free(phba->sli4_hba.dat_rq);
         phba->sli4_hba.dat_rq = NULL;
 
-        /* Release unsolicited receive complete queue */
-        lpfc_sli4_queue_free(phba->sli4_hba.rxq_cq);
-        phba->sli4_hba.rxq_cq = NULL;
-
         /* Release ELS complete queue */
         lpfc_sli4_queue_free(phba->sli4_hba.els_cq);
         phba->sli4_hba.els_cq = NULL;
@@ -5286,7 +5902,7 @@ lpfc_sli4_queue_destroy(struct lpfc_hba *phba)
  * operation.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      ENOMEM - No availble memory
  *      EIO - The mailbox failed to complete successfully.
  **/
@@ -5383,25 +5999,6 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba)
                         phba->sli4_hba.els_cq->queue_id,
                         phba->sli4_hba.sp_eq->queue_id);
 
-        /* Set up slow-path Unsolicited Receive Complete Queue */
-        if (!phba->sli4_hba.rxq_cq) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "0532 USOL RX CQ not allocated\n");
-                goto out_destroy_els_cq;
-        }
-        rc = lpfc_cq_create(phba, phba->sli4_hba.rxq_cq, phba->sli4_hba.sp_eq,
-                            LPFC_RCQ, LPFC_USOL);
-        if (rc) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "0533 Failed setup of slow-path USOL RX CQ: "
-                                "rc = 0x%x\n", rc);
-                goto out_destroy_els_cq;
-        }
-        lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
-                        "2587 USL CQ setup: cq-id=%d, parent eq-id=%d\n",
-                        phba->sli4_hba.rxq_cq->queue_id,
-                        phba->sli4_hba.sp_eq->queue_id);
-
         /* Set up fast-path FCP Response Complete Queue */
         for (fcp_cqidx = 0; fcp_cqidx < phba->cfg_fcp_eq_count; fcp_cqidx++) {
                 if (!phba->sli4_hba.fcp_cq[fcp_cqidx]) {
@@ -5507,7 +6104,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba)
                 goto out_destroy_fcp_wq;
         }
         rc = lpfc_rq_create(phba, phba->sli4_hba.hdr_rq, phba->sli4_hba.dat_rq,
-                            phba->sli4_hba.rxq_cq, LPFC_USOL);
+                            phba->sli4_hba.els_cq, LPFC_USOL);
         if (rc) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                 "0541 Failed setup of Receive Queue: "
@@ -5519,7 +6116,7 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba)
                         "parent cq-id=%d\n",
                         phba->sli4_hba.hdr_rq->queue_id,
                         phba->sli4_hba.dat_rq->queue_id,
-                        phba->sli4_hba.rxq_cq->queue_id);
+                        phba->sli4_hba.els_cq->queue_id);
         return 0;
 
 out_destroy_fcp_wq:
@@ -5531,8 +6128,6 @@ out_destroy_mbx_wq:
 out_destroy_fcp_cq:
         for (--fcp_cqidx; fcp_cqidx >= 0; fcp_cqidx--)
                 lpfc_cq_destroy(phba, phba->sli4_hba.fcp_cq[fcp_cqidx]);
-        lpfc_cq_destroy(phba, phba->sli4_hba.rxq_cq);
-out_destroy_els_cq:
         lpfc_cq_destroy(phba, phba->sli4_hba.els_cq);
 out_destroy_mbx_cq:
         lpfc_cq_destroy(phba, phba->sli4_hba.mbx_cq);
@@ -5552,7 +6147,7 @@ out_error:
  * operation.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      ENOMEM - No availble memory
  *      EIO - The mailbox failed to complete successfully.
  **/
@@ -5574,8 +6169,6 @@ lpfc_sli4_queue_unset(struct lpfc_hba *phba)
         lpfc_cq_destroy(phba, phba->sli4_hba.mbx_cq);
         /* Unset ELS complete queue */
         lpfc_cq_destroy(phba, phba->sli4_hba.els_cq);
-        /* Unset unsolicited receive complete queue */
-        lpfc_cq_destroy(phba, phba->sli4_hba.rxq_cq);
         /* Unset FCP response complete queue */
         for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++)
                 lpfc_cq_destroy(phba, phba->sli4_hba.fcp_cq[fcp_qidx]);
@@ -5599,7 +6192,7 @@ lpfc_sli4_queue_unset(struct lpfc_hba *phba)
  * Later, this can be used for all the slow-path events.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      -ENOMEM - No availble memory
  **/
 static int
@@ -5760,7 +6353,7 @@ lpfc_sli4_cq_event_release_all(struct lpfc_hba *phba)
  * all resources assigned to the PCI function which originates this request.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      ENOMEM - No availble memory
  *      EIO - The mailbox failed to complete successfully.
  **/
@@ -5910,7 +6503,7 @@ lpfc_sli4_fcfi_unreg(struct lpfc_hba *phba, uint16_t fcfi)
                 spin_lock_irqsave(&phba->hbalock, flags);
                 /* Mark the FCFI is no longer registered */
                 phba->fcf.fcf_flag &=
-                        ~(FCF_AVAILABLE | FCF_REGISTERED | FCF_DISCOVERED);
+                        ~(FCF_AVAILABLE | FCF_REGISTERED | FCF_SCAN_DONE);
                 spin_unlock_irqrestore(&phba->hbalock, flags);
         }
 }
@@ -5923,7 +6516,7 @@ lpfc_sli4_fcfi_unreg(struct lpfc_hba *phba, uint16_t fcfi)
  * with SLI-4 interface spec.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      other values - error
  **/
 static int
@@ -5940,22 +6533,30 @@ lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba)
                 pdev = phba->pcidev;
 
         /* Set the device DMA mask size */
-        if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0)
-                if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)
+        if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0
+         || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(64)) != 0) {
+                if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0
+                 || pci_set_consistent_dma_mask(pdev,DMA_BIT_MASK(32)) != 0) {
                         return error;
+                }
+        }
 
         /* Get the bus address of SLI4 device Bar0, Bar1, and Bar2 and the
          * number of bytes required by each mapping. They are actually
-         * mapping to the PCI BAR regions 1, 2, and 4 by the SLI4 device.
+         * mapping to the PCI BAR regions 0 or 1, 2, and 4 by the SLI4 device.
          */
-        phba->pci_bar0_map = pci_resource_start(pdev, LPFC_SLI4_BAR0);
-        bar0map_len = pci_resource_len(pdev, LPFC_SLI4_BAR0);
-
-        phba->pci_bar1_map = pci_resource_start(pdev, LPFC_SLI4_BAR1);
-        bar1map_len = pci_resource_len(pdev, LPFC_SLI4_BAR1);
+        if (pci_resource_start(pdev, 0)) {
+                phba->pci_bar0_map = pci_resource_start(pdev, 0);
+                bar0map_len = pci_resource_len(pdev, 0);
+        } else {
+                phba->pci_bar0_map = pci_resource_start(pdev, 1);
+                bar0map_len = pci_resource_len(pdev, 1);
+        }
+        phba->pci_bar1_map = pci_resource_start(pdev, 2);
+        bar1map_len = pci_resource_len(pdev, 2);
 
-        phba->pci_bar2_map = pci_resource_start(pdev, LPFC_SLI4_BAR2);
-        bar2map_len = pci_resource_len(pdev, LPFC_SLI4_BAR2);
+        phba->pci_bar2_map = pci_resource_start(pdev, 4);
+        bar2map_len = pci_resource_len(pdev, 4);
 
         /* Map SLI4 PCI Config Space Register base to a kernel virtual addr */
         phba->sli4_hba.conf_regs_memmap_p =
@@ -6052,7 +6653,7 @@ lpfc_sli4_pci_mem_unset(struct lpfc_hba *phba)
  * will be left with MSI-X enabled and leaks its vectors.
  *
  * Return codes
- *   0 - sucessful
+ *   0 - successful
  *   other values - error
  **/
 static int
@@ -6184,7 +6785,7 @@ lpfc_sli_disable_msix(struct lpfc_hba *phba)
  * is done in this function.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      other values - error
  */
 static int
@@ -6243,7 +6844,7 @@ lpfc_sli_disable_msi(struct lpfc_hba *phba)
  * MSI-X -> MSI -> IRQ.
  *
  * Return codes
- *   0 - sucessful
+ *   0 - successful
  *   other values - error
  **/
 static uint32_t
@@ -6333,7 +6934,7 @@ lpfc_sli_disable_intr(struct lpfc_hba *phba)
  * enabled and leaks its vectors.
  *
  * Return codes
- * 0 - sucessful
+ * 0 - successful
  * other values - error
  **/
 static int
@@ -6443,7 +7044,7 @@ lpfc_sli4_disable_msix(struct lpfc_hba *phba)
  * which is done in this function.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      other values - error
  **/
 static int
@@ -6508,7 +7109,7 @@ lpfc_sli4_disable_msi(struct lpfc_hba *phba)
  * MSI-X -> MSI -> IRQ.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      other values - error
  **/
 static uint32_t
@@ -6700,6 +7301,73 @@ lpfc_sli4_hba_unset(struct lpfc_hba *phba)
         phba->pport->work_port_events = 0;
 }
 
+ /**
+ * lpfc_pc_sli4_params_get - Get the SLI4_PARAMS port capabilities.
+ * @phba: Pointer to HBA context object.
+ * @mboxq: Pointer to the mailboxq memory for the mailbox command response.
+ *
+ * This function is called in the SLI4 code path to read the port's
+ * sli4 capabilities.
+ *
+ * This function may be be called from any context that can block-wait
+ * for the completion.  The expectation is that this routine is called
+ * typically from probe_one or from the online routine.
+ **/
+int
+lpfc_pc_sli4_params_get(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
+{
+        int rc;
+        struct lpfc_mqe *mqe;
+        struct lpfc_pc_sli4_params *sli4_params;
+        uint32_t mbox_tmo;
+
+        rc = 0;
+        mqe = &mboxq->u.mqe;
+
+        /* Read the port's SLI4 Parameters port capabilities */
+        lpfc_sli4_params(mboxq);
+        if (!phba->sli4_hba.intr_enable)
+                rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
+        else {
+                mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_PORT_CAPABILITIES);
+                rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
+        }
+
+        if (unlikely(rc))
+                return 1;
+
+        sli4_params = &phba->sli4_hba.pc_sli4_params;
+        sli4_params->if_type = bf_get(if_type, &mqe->un.sli4_params);
+        sli4_params->sli_rev = bf_get(sli_rev, &mqe->un.sli4_params);
+        sli4_params->sli_family = bf_get(sli_family, &mqe->un.sli4_params);
+        sli4_params->featurelevel_1 = bf_get(featurelevel_1,
+                                             &mqe->un.sli4_params);
+        sli4_params->featurelevel_2 = bf_get(featurelevel_2,
+                                             &mqe->un.sli4_params);
+        sli4_params->proto_types = mqe->un.sli4_params.word3;
+        sli4_params->sge_supp_len = mqe->un.sli4_params.sge_supp_len;
+        sli4_params->if_page_sz = bf_get(if_page_sz, &mqe->un.sli4_params);
+        sli4_params->rq_db_window = bf_get(rq_db_window, &mqe->un.sli4_params);
+        sli4_params->loopbk_scope = bf_get(loopbk_scope, &mqe->un.sli4_params);
+        sli4_params->eq_pages_max = bf_get(eq_pages, &mqe->un.sli4_params);
+        sli4_params->eqe_size = bf_get(eqe_size, &mqe->un.sli4_params);
+        sli4_params->cq_pages_max = bf_get(cq_pages, &mqe->un.sli4_params);
+        sli4_params->cqe_size = bf_get(cqe_size, &mqe->un.sli4_params);
+        sli4_params->mq_pages_max = bf_get(mq_pages, &mqe->un.sli4_params);
+        sli4_params->mqe_size = bf_get(mqe_size, &mqe->un.sli4_params);
+        sli4_params->mq_elem_cnt = bf_get(mq_elem_cnt, &mqe->un.sli4_params);
+        sli4_params->wq_pages_max = bf_get(wq_pages, &mqe->un.sli4_params);
+        sli4_params->wqe_size = bf_get(wqe_size, &mqe->un.sli4_params);
+        sli4_params->rq_pages_max = bf_get(rq_pages, &mqe->un.sli4_params);
+        sli4_params->rqe_size = bf_get(rqe_size, &mqe->un.sli4_params);
+        sli4_params->hdr_pages_max = bf_get(hdr_pages, &mqe->un.sli4_params);
+        sli4_params->hdr_size = bf_get(hdr_size, &mqe->un.sli4_params);
+        sli4_params->hdr_pp_align = bf_get(hdr_pp_align, &mqe->un.sli4_params);
+        sli4_params->sgl_pages_max = bf_get(sgl_pages, &mqe->un.sli4_params);
+        sli4_params->sgl_pp_align = bf_get(sgl_pp_align, &mqe->un.sli4_params);
+        return rc;
+}
+
 /**
  * lpfc_pci_probe_one_s3 - PCI probe func to reg SLI-3 device to PCI subsystem.
  * @pdev: pointer to PCI device
@@ -6722,6 +7390,7 @@ lpfc_pci_probe_one_s3(struct pci_dev *pdev, const struct pci_device_id *pid)
 {
         struct lpfc_hba   *phba;
         struct lpfc_vport *vport = NULL;
+        struct Scsi_Host  *shost = NULL;
         int error;
         uint32_t cfg_mode, intr_mode;
 
@@ -6800,6 +7469,7 @@ lpfc_pci_probe_one_s3(struct pci_dev *pdev, const struct pci_device_id *pid)
                 goto out_destroy_shost;
         }
 
+        shost = lpfc_shost_from_vport(vport); /* save shost for error cleanup */
         /* Now, trying to enable interrupt and bring up the device */
         cfg_mode = phba->cfg_use_msi;
         while (true) {
@@ -6866,6 +7536,8 @@ out_unset_pci_mem_s3:
         lpfc_sli_pci_mem_unset(phba);
 out_disable_pci_dev:
         lpfc_disable_pci_dev(phba);
+        if (shost)
+                scsi_host_put(shost);
 out_free_phba:
         lpfc_hba_free(phba);
         return error;
@@ -7036,6 +7708,13 @@ lpfc_pci_resume_one_s3(struct pci_dev *pdev)
         /* Restore device state from PCI config space */
         pci_set_power_state(pdev, PCI_D0);
         pci_restore_state(pdev);
+
+        /*
+         * As the new kernel behavior of pci_restore_state() API call clears
+         * device saved_state flag, need to save the restored state again.
+         */
+        pci_save_state(pdev);
+
         if (pdev->is_busmaster)
                 pci_set_master(pdev);
 
@@ -7070,6 +7749,73 @@ lpfc_pci_resume_one_s3(struct pci_dev *pdev)
 }
 
 /**
+ * lpfc_sli_prep_dev_for_recover - Prepare SLI3 device for pci slot recover
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is called to prepare the SLI3 device for PCI slot recover. It
+ * aborts and stops all the on-going I/Os on the pci device.
+ **/
+static void
+lpfc_sli_prep_dev_for_recover(struct lpfc_hba *phba)
+{
+        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                        "2723 PCI channel I/O abort preparing for recovery\n");
+        /* Prepare for bringing HBA offline */
+        lpfc_offline_prep(phba);
+        /* Clear sli active flag to prevent sysfs access to HBA */
+        spin_lock_irq(&phba->hbalock);
+        phba->sli.sli_flag &= ~LPFC_SLI_ACTIVE;
+        spin_unlock_irq(&phba->hbalock);
+        /* Stop and flush all I/Os and bring HBA offline */
+        lpfc_offline(phba);
+}
+
+/**
+ * lpfc_sli_prep_dev_for_reset - Prepare SLI3 device for pci slot reset
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is called to prepare the SLI3 device for PCI slot reset. It
+ * disables the device interrupt and pci device, and aborts the internal FCP
+ * pending I/Os.
+ **/
+static void
+lpfc_sli_prep_dev_for_reset(struct lpfc_hba *phba)
+{
+        struct lpfc_sli *psli = &phba->sli;
+        struct lpfc_sli_ring  *pring;
+
+        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                        "2710 PCI channel disable preparing for reset\n");
+        /* Disable interrupt and pci device */
+        lpfc_sli_disable_intr(phba);
+        pci_disable_device(phba->pcidev);
+        /*
+         * There may be I/Os dropped by the firmware.
+         * Error iocb (I/O) on txcmplq and let the SCSI layer
+         * retry it after re-establishing link.
+         */
+        pring = &psli->ring[psli->fcp_ring];
+        lpfc_sli_abort_iocb_ring(phba, pring);
+}
+
+/**
+ * lpfc_sli_prep_dev_for_perm_failure - Prepare SLI3 dev for pci slot disable
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is called to prepare the SLI3 device for PCI slot permanently
+ * disabling. It blocks the SCSI transport layer traffic and flushes the FCP
+ * pending I/Os.
+ **/
+static void
+lpfc_prep_dev_for_perm_failure(struct lpfc_hba *phba)
+{
+        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                        "2711 PCI channel permanent disable for failure\n");
+        /* Clean up all driver's outstanding SCSI I/Os */
+        lpfc_sli_flush_fcp_rings(phba);
+}
+
+/**
  * lpfc_io_error_detected_s3 - Method for handling SLI-3 device PCI I/O error
  * @pdev: pointer to PCI device.
  * @state: the current PCI connection state.
@@ -7083,6 +7829,7 @@ lpfc_pci_resume_one_s3(struct pci_dev *pdev)
  * as desired.
  *
  * Return codes
+ *      PCI_ERS_RESULT_CAN_RECOVER - can be recovered with reset_link
  *      PCI_ERS_RESULT_NEED_RESET - need to reset before recovery
  *      PCI_ERS_RESULT_DISCONNECT - device could not be recovered
  **/
@@ -7091,33 +7838,30 @@ lpfc_io_error_detected_s3(struct pci_dev *pdev, pci_channel_state_t state)
 {
         struct Scsi_Host *shost = pci_get_drvdata(pdev);
         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
-        struct lpfc_sli *psli = &phba->sli;
-        struct lpfc_sli_ring  *pring;
 
-        if (state == pci_channel_io_perm_failure) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "0472 PCI channel I/O permanent failure\n");
-                /* Block all SCSI devices' I/Os on the host */
-                lpfc_scsi_dev_block(phba);
-                /* Clean up all driver's outstanding SCSI I/Os */
-                lpfc_sli_flush_fcp_rings(phba);
+        /* Block all SCSI devices' I/Os on the host */
+        lpfc_scsi_dev_block(phba);
+
+        switch (state) {
+        case pci_channel_io_normal:
+                /* Non-fatal error, prepare for recovery */
+                lpfc_sli_prep_dev_for_recover(phba);
+                return PCI_ERS_RESULT_CAN_RECOVER;
+        case pci_channel_io_frozen:
+                /* Fatal error, prepare for slot reset */
+                lpfc_sli_prep_dev_for_reset(phba);
+                return PCI_ERS_RESULT_NEED_RESET;
+        case pci_channel_io_perm_failure:
+                /* Permanent failure, prepare for device down */
+                lpfc_prep_dev_for_perm_failure(phba);
                 return PCI_ERS_RESULT_DISCONNECT;
+        default:
+                /* Unknown state, prepare and request slot reset */
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "0472 Unknown PCI error state: x%x\n", state);
+                lpfc_sli_prep_dev_for_reset(phba);
+                return PCI_ERS_RESULT_NEED_RESET;
         }
-
-        pci_disable_device(pdev);
-        /*
-         * There may be I/Os dropped by the firmware.
-         * Error iocb (I/O) on txcmplq and let the SCSI layer
-         * retry it after re-establishing link.
-         */
-        pring = &psli->ring[psli->fcp_ring];
-        lpfc_sli_abort_iocb_ring(phba, pring);
-
-        /* Disable interrupt */
-        lpfc_sli_disable_intr(phba);
-
-        /* Request a slot reset. */
-        return PCI_ERS_RESULT_NEED_RESET;
 }
 
 /**
@@ -7154,6 +7898,13 @@ lpfc_io_slot_reset_s3(struct pci_dev *pdev)
         }
 
         pci_restore_state(pdev);
+
+        /*
+         * As the new kernel behavior of pci_restore_state() API call clears
+         * device saved_state flag, need to save the restored state again.
+         */
+        pci_save_state(pdev);
+
         if (pdev->is_busmaster)
                 pci_set_master(pdev);
 
@@ -7197,7 +7948,12 @@ lpfc_io_resume_s3(struct pci_dev *pdev)
         struct Scsi_Host *shost = pci_get_drvdata(pdev);
         struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
 
+        /* Bring the device online */
         lpfc_online(phba);
+
+        /* Clean up Advanced Error Reporting (AER) if needed */
+        if (phba->hba_flag & HBA_AER_ENABLED)
+                pci_cleanup_aer_uncorrect_error_status(pdev);
 }
 
 /**
@@ -7213,15 +7969,15 @@ lpfc_sli4_get_els_iocb_cnt(struct lpfc_hba *phba)
 
         if (phba->sli_rev == LPFC_SLI_REV4) {
                 if (max_xri <= 100)
-                        return 4;
+                        return 10;
                 else if (max_xri <= 256)
-                        return 8;
+                        return 25;
                 else if (max_xri <= 512)
-                        return 16;
+                        return 50;
                 else if (max_xri <= 1024)
-                        return 32;
+                        return 100;
                 else
-                        return 48;
+                        return 150;
         } else
                 return 0;
 }
@@ -7249,6 +8005,7 @@ lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
 {
         struct lpfc_hba   *phba;
         struct lpfc_vport *vport = NULL;
+        struct Scsi_Host  *shost = NULL;
         int error;
         uint32_t cfg_mode, intr_mode;
         int mcnt;
@@ -7329,6 +8086,7 @@ lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
                 goto out_destroy_shost;
         }
 
+        shost = lpfc_shost_from_vport(vport); /* save shost for error cleanup */
         /* Now, trying to enable interrupt and bring up the device */
         cfg_mode = phba->cfg_use_msi;
         while (true) {
@@ -7342,6 +8100,9 @@ lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
                         error = -ENODEV;
                         goto out_free_sysfs_attr;
                 }
+                /* Default to single FCP EQ for non-MSI-X */
+                if (phba->intr_type != MSIX)
+                        phba->cfg_fcp_eq_count = 1;
                 /* Set up SLI-4 HBA */
                 if (lpfc_sli4_hba_setup(phba)) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -7397,6 +8158,8 @@ out_unset_pci_mem_s4:
         lpfc_sli4_pci_mem_unset(phba);
 out_disable_pci_dev:
         lpfc_disable_pci_dev(phba);
+        if (shost)
+                scsi_host_put(shost);
 out_free_phba:
         lpfc_hba_free(phba);
         return error;
@@ -7551,6 +8314,13 @@ lpfc_pci_resume_one_s4(struct pci_dev *pdev)
         /* Restore device state from PCI config space */
         pci_set_power_state(pdev, PCI_D0);
         pci_restore_state(pdev);
+
+        /*
+         * As the new kernel behavior of pci_restore_state() API call clears
+         * device saved_state flag, need to save the restored state again.
+         */
+        pci_save_state(pdev);
+
         if (pdev->is_busmaster)
                 pci_set_master(pdev);
 
@@ -7670,11 +8440,11 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
         int rc;
         struct lpfc_sli_intf intf;
 
-        if (pci_read_config_dword(pdev, LPFC_SLIREV_CONF_WORD, &intf.word0))
+        if (pci_read_config_dword(pdev, LPFC_SLI_INTF, &intf.word0))
                 return -ENODEV;
 
         if ((bf_get(lpfc_sli_intf_valid, &intf) == LPFC_SLI_INTF_VALID) &&
-                (bf_get(lpfc_sli_intf_rev, &intf) == LPFC_SLIREV_CONF_SLI4))
+            (bf_get(lpfc_sli_intf_slirev, &intf) == LPFC_SLI_INTF_REV_SLI4))
                 rc = lpfc_pci_probe_one_s4(pdev, pid);
         else
                 rc = lpfc_pci_probe_one_s3(pdev, pid);
@@ -7971,6 +8741,10 @@ static struct pci_device_id lpfc_id_table[] = {
                 PCI_ANY_ID, PCI_ANY_ID, },
         {PCI_VENDOR_ID_SERVERENGINE, PCI_DEVICE_ID_TIGERSHARK,
                 PCI_ANY_ID, PCI_ANY_ID, },
+        {PCI_VENDOR_ID_SERVERENGINE, PCI_DEVICE_ID_TOMCAT,
+                PCI_ANY_ID, PCI_ANY_ID, },
+        {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_FALCON,
+                PCI_ANY_ID, PCI_ANY_ID, },
         { 0 }
 };
 
@@ -8053,15 +8827,15 @@ lpfc_exit(void)
         if (lpfc_enable_npiv)
                 fc_release_transport(lpfc_vport_transport_template);
         if (_dump_buf_data) {
-                printk(KERN_ERR "BLKGRD freeing %lu pages for _dump_buf_data "
-                                "at 0x%p\n",
+                printk(KERN_ERR "9062 BLKGRD: freeing %lu pages for "
+                                "_dump_buf_data at 0x%p\n",
                                 (1L << _dump_buf_data_order), _dump_buf_data);
                 free_pages((unsigned long)_dump_buf_data, _dump_buf_data_order);
         }
 
         if (_dump_buf_dif) {
-                printk(KERN_ERR "BLKGRD freeing %lu pages for _dump_buf_dif "
-                                "at 0x%p\n",
+                printk(KERN_ERR "9049 BLKGRD: freeing %lu pages for "
+                                "_dump_buf_dif at 0x%p\n",
                                 (1L << _dump_buf_dif_order), _dump_buf_dif);
                 free_pages((unsigned long)_dump_buf_dif, _dump_buf_dif_order);
         }
diff --git a/drivers/scsi/lpfc/lpfc_logmsg.h b/drivers/scsi/lpfc/lpfc_logmsg.h
index 954ba57970a3..bb59e9273126 100644
--- a/drivers/scsi/lpfc/lpfc_logmsg.h
+++ b/drivers/scsi/lpfc/lpfc_logmsg.h
@@ -35,6 +35,7 @@
 #define LOG_VPORT       0x00004000      /* NPIV events */
 #define LOF_SECURITY    0x00008000      /* Security events */
 #define LOG_EVENT       0x00010000      /* CT,TEMP,DUMP, logging */
+#define LOG_FIP         0x00020000      /* FIP events */
 #define LOG_ALL_MSG     0xffffffff      /* LOG all messages */
 
 #define lpfc_printf_vlog(vport, level, mask, fmt, arg...) \
diff --git a/drivers/scsi/lpfc/lpfc_mbox.c b/drivers/scsi/lpfc/lpfc_mbox.c
index 1ab405902a18..72e6adb0643e 100644
--- a/drivers/scsi/lpfc/lpfc_mbox.c
+++ b/drivers/scsi/lpfc/lpfc_mbox.c
@@ -21,12 +21,13 @@
 
 #include <linux/blkdev.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <linux/interrupt.h>
 
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_transport_fc.h>
-
 #include <scsi/scsi.h>
+#include <scsi/fc/fc_fs.h>
 
 #include "lpfc_hw4.h"
 #include "lpfc_hw.h"
@@ -820,6 +821,10 @@ lpfc_reg_vpi(struct lpfc_vport *vport, LPFC_MBOXQ_t *pmb)
         mb->un.varRegVpi.vpi = vport->vpi + vport->phba->vpi_base;
         mb->un.varRegVpi.sid = vport->fc_myDID;
         mb->un.varRegVpi.vfi = vport->vfi + vport->phba->vfi_base;
+        memcpy(mb->un.varRegVpi.wwn, &vport->fc_portname,
+               sizeof(struct lpfc_name));
+        mb->un.varRegVpi.wwn[0] = cpu_to_le32(mb->un.varRegVpi.wwn[0]);
+        mb->un.varRegVpi.wwn[1] = cpu_to_le32(mb->un.varRegVpi.wwn[1]);
 
         mb->mbxCommand = MBX_REG_VPI;
         mb->mbxOwner = OWN_HOST;
@@ -849,7 +854,10 @@ lpfc_unreg_vpi(struct lpfc_hba *phba, uint16_t vpi, LPFC_MBOXQ_t *pmb)
         MAILBOX_t *mb = &pmb->u.mb;
         memset(pmb, 0, sizeof (LPFC_MBOXQ_t));
 
-        mb->un.varUnregVpi.vpi = vpi + phba->vpi_base;
+        if (phba->sli_rev < LPFC_SLI_REV4)
+                mb->un.varUnregVpi.vpi = vpi + phba->vpi_base;
+        else
+                mb->un.varUnregVpi.sli4_vpi = vpi + phba->vpi_base;
 
         mb->mbxCommand = MBX_UNREG_VPI;
         mb->mbxOwner = OWN_HOST;
@@ -1132,7 +1140,7 @@ lpfc_config_ring(struct lpfc_hba * phba, int ring, LPFC_MBOXQ_t * pmb)
         /* Otherwise we setup specific rctl / type masks for this ring */
         for (i = 0; i < pring->num_mask; i++) {
                 mb->un.varCfgRing.rrRegs[i].rval = pring->prt[i].rctl;
-                if (mb->un.varCfgRing.rrRegs[i].rval != FC_ELS_REQ)
+                if (mb->un.varCfgRing.rrRegs[i].rval != FC_RCTL_ELS_REQ)
                         mb->un.varCfgRing.rrRegs[i].rmask = 0xff;
                 else
                         mb->un.varCfgRing.rrRegs[i].rmask = 0xfe;
@@ -1654,9 +1662,12 @@ lpfc_sli4_config(struct lpfc_hba *phba, struct lpfcMboxq *mbox,
         /* Allocate record for keeping SGE virtual addresses */
         mbox->sge_array = kmalloc(sizeof(struct lpfc_mbx_nembed_sge_virt),
                                   GFP_KERNEL);
-        if (!mbox->sge_array)
+        if (!mbox->sge_array) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
+                                "2527 Failed to allocate non-embedded SGE "
+                                "array.\n");
                 return 0;
-
+        }
         for (pagen = 0, alloc_len = 0; pagen < pcount; pagen++) {
                 /* The DMA memory is always allocated in the length of a
                  * page even though the last SGE might not fill up to a
@@ -1697,7 +1708,8 @@ lpfc_sli4_config(struct lpfc_hba *phba, struct lpfcMboxq *mbox,
                                 alloc_len - sizeof(union  lpfc_sli4_cfg_shdr);
         }
         /* The sub-header is in DMA memory, which needs endian converstion */
-        lpfc_sli_pcimem_bcopy(cfg_shdr, cfg_shdr,
+        if (cfg_shdr)
+                lpfc_sli_pcimem_bcopy(cfg_shdr, cfg_shdr,
                               sizeof(union  lpfc_sli4_cfg_shdr));
 
         return alloc_len;
@@ -1737,6 +1749,65 @@ lpfc_sli4_mbox_opcode_get(struct lpfc_hba *phba, struct lpfcMboxq *mbox)
 }
 
 /**
+ * lpfc_sli4_mbx_read_fcf_rec - Allocate and construct read fcf mbox cmd
+ * @phba: pointer to lpfc hba data structure.
+ * @fcf_index: index to fcf table.
+ *
+ * This routine routine allocates and constructs non-embedded mailbox command
+ * for reading a FCF table entry refered by @fcf_index.
+ *
+ * Return: pointer to the mailbox command constructed if successful, otherwise
+ * NULL.
+ **/
+int
+lpfc_sli4_mbx_read_fcf_rec(struct lpfc_hba *phba,
+                           struct lpfcMboxq *mboxq,
+                           uint16_t fcf_index)
+{
+        void *virt_addr;
+        dma_addr_t phys_addr;
+        uint8_t *bytep;
+        struct lpfc_mbx_sge sge;
+        uint32_t alloc_len, req_len;
+        struct lpfc_mbx_read_fcf_tbl *read_fcf;
+
+        if (!mboxq)
+                return -ENOMEM;
+
+        req_len = sizeof(struct fcf_record) +
+                  sizeof(union lpfc_sli4_cfg_shdr) + 2 * sizeof(uint32_t);
+
+        /* Set up READ_FCF SLI4_CONFIG mailbox-ioctl command */
+        alloc_len = lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
+                        LPFC_MBOX_OPCODE_FCOE_READ_FCF_TABLE, req_len,
+                        LPFC_SLI4_MBX_NEMBED);
+
+        if (alloc_len < req_len) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
+                                "0291 Allocated DMA memory size (x%x) is "
+                                "less than the requested DMA memory "
+                                "size (x%x)\n", alloc_len, req_len);
+                return -ENOMEM;
+        }
+
+        /* Get the first SGE entry from the non-embedded DMA memory. This
+         * routine only uses a single SGE.
+         */
+        lpfc_sli4_mbx_sge_get(mboxq, 0, &sge);
+        phys_addr = getPaddr(sge.pa_hi, sge.pa_lo);
+        virt_addr = mboxq->sge_array->addr[0];
+        read_fcf = (struct lpfc_mbx_read_fcf_tbl *)virt_addr;
+
+        /* Set up command fields */
+        bf_set(lpfc_mbx_read_fcf_tbl_indx, &read_fcf->u.request, fcf_index);
+        /* Perform necessary endian conversion */
+        bytep = virt_addr + sizeof(union lpfc_sli4_cfg_shdr);
+        lpfc_sli_pcimem_bcopy(bytep, bytep, sizeof(uint32_t));
+
+        return 0;
+}
+
+/**
  * lpfc_request_features: Configure SLI4 REQUEST_FEATURES mailbox
  * @mboxq: pointer to lpfc mbox command.
  *
@@ -1753,11 +1824,6 @@ lpfc_request_features(struct lpfc_hba *phba, struct lpfcMboxq *mboxq)
         /* Set up host requested features. */
         bf_set(lpfc_mbx_rq_ftr_rq_fcpi, &mboxq->u.mqe.un.req_ftrs, 1);
 
-        if (phba->cfg_enable_fip)
-                bf_set(lpfc_mbx_rq_ftr_rq_ifip, &mboxq->u.mqe.un.req_ftrs, 0);
-        else
-                bf_set(lpfc_mbx_rq_ftr_rq_ifip, &mboxq->u.mqe.un.req_ftrs, 1);
-
         /* Enable DIF (block guard) only if configured to do so. */
         if (phba->cfg_enable_bg)
                 bf_set(lpfc_mbx_rq_ftr_rq_dif, &mboxq->u.mqe.un.req_ftrs, 1);
@@ -1817,6 +1883,9 @@ lpfc_reg_vfi(struct lpfcMboxq *mbox, struct lpfc_vport *vport, dma_addr_t phys)
         bf_set(lpfc_reg_vfi_vfi, reg_vfi, vport->vfi + vport->phba->vfi_base);
         bf_set(lpfc_reg_vfi_fcfi, reg_vfi, vport->phba->fcf.fcfi);
         bf_set(lpfc_reg_vfi_vpi, reg_vfi, vport->vpi + vport->phba->vpi_base);
+        memcpy(reg_vfi->wwn, &vport->fc_portname, sizeof(struct lpfc_name));
+        reg_vfi->wwn[0] = cpu_to_le32(reg_vfi->wwn[0]);
+        reg_vfi->wwn[1] = cpu_to_le32(reg_vfi->wwn[1]);
         reg_vfi->bde.addrHigh = putPaddrHigh(phys);
         reg_vfi->bde.addrLow = putPaddrLow(phys);
         reg_vfi->bde.tus.f.bdeSize = sizeof(vport->fc_sparam);
@@ -1850,7 +1919,7 @@ lpfc_init_vpi(struct lpfc_hba *phba, struct lpfcMboxq *mbox, uint16_t vpi)
 /**
  * lpfc_unreg_vfi - Initialize the UNREG_VFI mailbox command
  * @mbox: pointer to lpfc mbox command to initialize.
- * @vfi: VFI to be unregistered.
+ * @vport: vport associated with the VF.
  *
  * The UNREG_VFI mailbox command causes the SLI Host to put a virtual fabric
  * (logical NPort) into the inactive state. The SLI Host must have logged out
@@ -1859,11 +1928,12 @@ lpfc_init_vpi(struct lpfc_hba *phba, struct lpfcMboxq *mbox, uint16_t vpi)
  * fabric inactive.
  **/
 void
-lpfc_unreg_vfi(struct lpfcMboxq *mbox, uint16_t vfi)
+lpfc_unreg_vfi(struct lpfcMboxq *mbox, struct lpfc_vport *vport)
 {
         memset(mbox, 0, sizeof(*mbox));
         bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_UNREG_VFI);
-        bf_set(lpfc_unreg_vfi_vfi, &mbox->u.mqe.un.unreg_vfi, vfi);
+        bf_set(lpfc_unreg_vfi_vfi, &mbox->u.mqe.un.unreg_vfi,
+               vport->vfi + vport->phba->vfi_base);
 }
 
 /**
@@ -1937,13 +2007,14 @@ lpfc_reg_fcfi(struct lpfc_hba *phba, struct lpfcMboxq *mbox)
         bf_set(lpfc_reg_fcfi_rq_id1, reg_fcfi, REG_FCF_INVALID_QID);
         bf_set(lpfc_reg_fcfi_rq_id2, reg_fcfi, REG_FCF_INVALID_QID);
         bf_set(lpfc_reg_fcfi_rq_id3, reg_fcfi, REG_FCF_INVALID_QID);
-        bf_set(lpfc_reg_fcfi_info_index, reg_fcfi, phba->fcf.fcf_indx);
+        bf_set(lpfc_reg_fcfi_info_index, reg_fcfi,
+               phba->fcf.current_rec.fcf_indx);
         /* reg_fcf addr mode is bit wise inverted value of fcf addr_mode */
-        bf_set(lpfc_reg_fcfi_mam, reg_fcfi,
-                (~phba->fcf.addr_mode) & 0x3);
-        if (phba->fcf.fcf_flag & FCF_VALID_VLAN) {
+        bf_set(lpfc_reg_fcfi_mam, reg_fcfi, (~phba->fcf.addr_mode) & 0x3);
+        if (phba->fcf.current_rec.vlan_id != 0xFFFF) {
                 bf_set(lpfc_reg_fcfi_vv, reg_fcfi, 1);
-                bf_set(lpfc_reg_fcfi_vlan_tag, reg_fcfi, phba->fcf.vlan_id);
+                bf_set(lpfc_reg_fcfi_vlan_tag, reg_fcfi,
+                       phba->fcf.current_rec.vlan_id);
         }
 }
 
@@ -1983,3 +2054,41 @@ lpfc_resume_rpi(struct lpfcMboxq *mbox, struct lpfc_nodelist *ndlp)
         bf_set(lpfc_resume_rpi_ii, resume_rpi, RESUME_INDEX_RPI);
         resume_rpi->event_tag = ndlp->phba->fc_eventTag;
 }
+
+/**
+ * lpfc_supported_pages - Initialize the PORT_CAPABILITIES supported pages
+ *                        mailbox command.
+ * @mbox: pointer to lpfc mbox command to initialize.
+ *
+ * The PORT_CAPABILITIES supported pages mailbox command is issued to
+ * retrieve the particular feature pages supported by the port.
+ **/
+void
+lpfc_supported_pages(struct lpfcMboxq *mbox)
+{
+        struct lpfc_mbx_supp_pages *supp_pages;
+
+        memset(mbox, 0, sizeof(*mbox));
+        supp_pages = &mbox->u.mqe.un.supp_pages;
+        bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_PORT_CAPABILITIES);
+        bf_set(cpn, supp_pages, LPFC_SUPP_PAGES);
+}
+
+/**
+ * lpfc_sli4_params - Initialize the PORT_CAPABILITIES SLI4 Params
+ *                    mailbox command.
+ * @mbox: pointer to lpfc mbox command to initialize.
+ *
+ * The PORT_CAPABILITIES SLI4 parameters mailbox command is issued to
+ * retrieve the particular SLI4 features supported by the port.
+ **/
+void
+lpfc_sli4_params(struct lpfcMboxq *mbox)
+{
+        struct lpfc_mbx_sli4_params *sli4_params;
+
+        memset(mbox, 0, sizeof(*mbox));
+        sli4_params = &mbox->u.mqe.un.sli4_params;
+        bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_PORT_CAPABILITIES);
+        bf_set(cpn, sli4_params, LPFC_SLI4_PARAMETERS);
+}
diff --git a/drivers/scsi/lpfc/lpfc_mem.c b/drivers/scsi/lpfc/lpfc_mem.c
index a1b6db6016da..8f879e477e9d 100644
--- a/drivers/scsi/lpfc/lpfc_mem.c
+++ b/drivers/scsi/lpfc/lpfc_mem.c
@@ -20,6 +20,7 @@
  *******************************************************************/
 
 #include <linux/mempool.h>
+#include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/interrupt.h>
 
diff --git a/drivers/scsi/lpfc/lpfc_nl.h b/drivers/scsi/lpfc/lpfc_nl.h
index d655ed3eebef..f3cfbe2ce986 100644
--- a/drivers/scsi/lpfc/lpfc_nl.h
+++ b/drivers/scsi/lpfc/lpfc_nl.h
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2008 Emulex.  All rights reserved.                *
+ * Copyright (C) 2010 Emulex.  All rights reserved.                *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -177,23 +177,3 @@ struct temp_event {
         uint32_t data;
 };
 
-/* bsg definitions */
-#define LPFC_BSG_VENDOR_SET_CT_EVENT    1
-#define LPFC_BSG_VENDOR_GET_CT_EVENT    2
-
-struct set_ct_event {
-        uint32_t command;
-        uint32_t ev_req_id;
-        uint32_t ev_reg_id;
-};
-
-struct get_ct_event {
-        uint32_t command;
-        uint32_t ev_reg_id;
-        uint32_t ev_req_id;
-};
-
-struct get_ct_event_reply {
-        uint32_t immed_data;
-        uint32_t type;
-};
diff --git a/drivers/scsi/lpfc/lpfc_nportdisc.c b/drivers/scsi/lpfc/lpfc_nportdisc.c
index 3e74136f1ede..e331204a4d56 100644
--- a/drivers/scsi/lpfc/lpfc_nportdisc.c
+++ b/drivers/scsi/lpfc/lpfc_nportdisc.c
@@ -21,6 +21,7 @@
 
 #include <linux/blkdev.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <linux/interrupt.h>
 
 #include <scsi/scsi.h>
@@ -62,7 +63,7 @@ lpfc_check_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 
 int
 lpfc_check_sparm(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
-                 struct serv_parm * sp, uint32_t class)
+                 struct serv_parm *sp, uint32_t class, int flogi)
 {
         volatile struct serv_parm *hsp = &vport->fc_sparam;
         uint16_t hsp_value, ssp_value = 0;
@@ -75,49 +76,56 @@ lpfc_check_sparm(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
          * correcting the byte values.
          */
         if (sp->cls1.classValid) {
-                hsp_value = (hsp->cls1.rcvDataSizeMsb << 8) |
-                                hsp->cls1.rcvDataSizeLsb;
-                ssp_value = (sp->cls1.rcvDataSizeMsb << 8) |
-                                sp->cls1.rcvDataSizeLsb;
-                if (!ssp_value)
-                        goto bad_service_param;
-                if (ssp_value > hsp_value) {
-                        sp->cls1.rcvDataSizeLsb = hsp->cls1.rcvDataSizeLsb;
-                        sp->cls1.rcvDataSizeMsb = hsp->cls1.rcvDataSizeMsb;
+                if (!flogi) {
+                        hsp_value = ((hsp->cls1.rcvDataSizeMsb << 8) |
+                                     hsp->cls1.rcvDataSizeLsb);
+                        ssp_value = ((sp->cls1.rcvDataSizeMsb << 8) |
+                                     sp->cls1.rcvDataSizeLsb);
+                        if (!ssp_value)
+                                goto bad_service_param;
+                        if (ssp_value > hsp_value) {
+                                sp->cls1.rcvDataSizeLsb =
+                                        hsp->cls1.rcvDataSizeLsb;
+                                sp->cls1.rcvDataSizeMsb =
+                                        hsp->cls1.rcvDataSizeMsb;
+                        }
                 }
-        } else if (class == CLASS1) {
+        } else if (class == CLASS1)
                 goto bad_service_param;
-        }
-
         if (sp->cls2.classValid) {
-                hsp_value = (hsp->cls2.rcvDataSizeMsb << 8) |
-                                hsp->cls2.rcvDataSizeLsb;
-                ssp_value = (sp->cls2.rcvDataSizeMsb << 8) |
-                                sp->cls2.rcvDataSizeLsb;
-                if (!ssp_value)
-                        goto bad_service_param;
-                if (ssp_value > hsp_value) {
-                        sp->cls2.rcvDataSizeLsb = hsp->cls2.rcvDataSizeLsb;
-                        sp->cls2.rcvDataSizeMsb = hsp->cls2.rcvDataSizeMsb;
+                if (!flogi) {
+                        hsp_value = ((hsp->cls2.rcvDataSizeMsb << 8) |
+                                     hsp->cls2.rcvDataSizeLsb);
+                        ssp_value = ((sp->cls2.rcvDataSizeMsb << 8) |
+                                     sp->cls2.rcvDataSizeLsb);
+                        if (!ssp_value)
+                                goto bad_service_param;
+                        if (ssp_value > hsp_value) {
+                                sp->cls2.rcvDataSizeLsb =
+                                        hsp->cls2.rcvDataSizeLsb;
+                                sp->cls2.rcvDataSizeMsb =
+                                        hsp->cls2.rcvDataSizeMsb;
+                        }
                 }
-        } else if (class == CLASS2) {
+        } else if (class == CLASS2)
                 goto bad_service_param;
-        }
-
         if (sp->cls3.classValid) {
-                hsp_value = (hsp->cls3.rcvDataSizeMsb << 8) |
-                                hsp->cls3.rcvDataSizeLsb;
-                ssp_value = (sp->cls3.rcvDataSizeMsb << 8) |
-                                sp->cls3.rcvDataSizeLsb;
-                if (!ssp_value)
-                        goto bad_service_param;
-                if (ssp_value > hsp_value) {
-                        sp->cls3.rcvDataSizeLsb = hsp->cls3.rcvDataSizeLsb;
-                        sp->cls3.rcvDataSizeMsb = hsp->cls3.rcvDataSizeMsb;
+                if (!flogi) {
+                        hsp_value = ((hsp->cls3.rcvDataSizeMsb << 8) |
+                                     hsp->cls3.rcvDataSizeLsb);
+                        ssp_value = ((sp->cls3.rcvDataSizeMsb << 8) |
+                                     sp->cls3.rcvDataSizeLsb);
+                        if (!ssp_value)
+                                goto bad_service_param;
+                        if (ssp_value > hsp_value) {
+                                sp->cls3.rcvDataSizeLsb =
+                                        hsp->cls3.rcvDataSizeLsb;
+                                sp->cls3.rcvDataSizeMsb =
+                                        hsp->cls3.rcvDataSizeMsb;
+                        }
                 }
-        } else if (class == CLASS3) {
+        } else if (class == CLASS3)
                 goto bad_service_param;
-        }
 
         /*
          * Preserve the upper four bits of the MSB from the PLOGI response.
@@ -247,7 +255,7 @@ lpfc_rcv_plogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         int rc;
 
         memset(&stat, 0, sizeof (struct ls_rjt));
-        if (vport->port_state <= LPFC_FLOGI) {
+        if (vport->port_state <= LPFC_FDISC) {
                 /* Before responding to PLOGI, check for pt2pt mode.
                  * If we are pt2pt, with an outstanding FLOGI, abort
                  * the FLOGI and resend it first.
@@ -295,7 +303,7 @@ lpfc_rcv_plogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                         NULL);
                 return 0;
         }
-        if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3) == 0)) {
+        if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3, 0) == 0)) {
                 /* Reject this request because invalid parameters */
                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
                 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS;
@@ -831,7 +839,7 @@ lpfc_cmpl_plogi_plogi_issue(struct lpfc_vport *vport,
                                  "0142 PLOGI RSP: Invalid WWN.\n");
                 goto out;
         }
-        if (!lpfc_check_sparm(vport, ndlp, sp, CLASS3))
+        if (!lpfc_check_sparm(vport, ndlp, sp, CLASS3, 0))
                 goto out;
         /* PLOGI chkparm OK */
         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
@@ -1223,6 +1231,12 @@ lpfc_rcv_logo_reglogin_issue(struct lpfc_vport *vport,
         list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) {
                 if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) &&
                    (ndlp == (struct lpfc_nodelist *) mb->context2)) {
+                        if (phba->sli_rev == LPFC_SLI_REV4) {
+                                spin_unlock_irq(&phba->hbalock);
+                                lpfc_sli4_free_rpi(phba,
+                                        mb->u.mb.un.varRegLogin.rpi);
+                                spin_lock_irq(&phba->hbalock);
+                        }
                         mp = (struct lpfc_dmabuf *) (mb->context1);
                         if (mp) {
                                 __lpfc_mbuf_free(phba, mp->virt, mp->phys);
@@ -1230,6 +1244,7 @@ lpfc_rcv_logo_reglogin_issue(struct lpfc_vport *vport,
                         }
                         lpfc_nlp_put(ndlp);
                         list_del(&mb->list);
+                        phba->sli.mboxq_cnt--;
                         mempool_free(mb, phba->mbox_mem_pool);
                 }
         }
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index c88f59f0ce30..dccdb822328c 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -19,6 +19,7 @@
  * included with this package.                                     *
  *******************************************************************/
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <asm/unaligned.h>
@@ -59,22 +60,26 @@ static char *dif_op_str[] = {
 };
 static void
 lpfc_release_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb);
+static void
+lpfc_release_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb);
 
 static void
-lpfc_debug_save_data(struct scsi_cmnd *cmnd)
+lpfc_debug_save_data(struct lpfc_hba *phba, struct scsi_cmnd *cmnd)
 {
         void *src, *dst;
         struct scatterlist *sgde = scsi_sglist(cmnd);
 
         if (!_dump_buf_data) {
-                printk(KERN_ERR "BLKGRD ERROR %s _dump_buf_data is NULL\n",
+                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                        "9050 BLKGRD: ERROR %s _dump_buf_data is NULL\n",
                                 __func__);
                 return;
         }
 
 
         if (!sgde) {
-                printk(KERN_ERR "BLKGRD ERROR: data scatterlist is null\n");
+                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                        "9051 BLKGRD: ERROR: data scatterlist is null\n");
                 return;
         }
 
@@ -88,19 +93,21 @@ lpfc_debug_save_data(struct scsi_cmnd *cmnd)
 }
 
 static void
-lpfc_debug_save_dif(struct scsi_cmnd *cmnd)
+lpfc_debug_save_dif(struct lpfc_hba *phba, struct scsi_cmnd *cmnd)
 {
         void *src, *dst;
         struct scatterlist *sgde = scsi_prot_sglist(cmnd);
 
         if (!_dump_buf_dif) {
-                printk(KERN_ERR "BLKGRD ERROR %s _dump_buf_data is NULL\n",
+                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                        "9052 BLKGRD: ERROR %s _dump_buf_data is NULL\n",
                                 __func__);
                 return;
         }
 
         if (!sgde) {
-                printk(KERN_ERR "BLKGRD ERROR: prot scatterlist is null\n");
+                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                        "9053 BLKGRD: ERROR: prot scatterlist is null\n");
                 return;
         }
 
@@ -242,6 +249,36 @@ lpfc_send_sdev_queuedepth_change_event(struct lpfc_hba *phba,
 }
 
 /**
+ * lpfc_change_queue_depth - Alter scsi device queue depth
+ * @sdev: Pointer the scsi device on which to change the queue depth.
+ * @qdepth: New queue depth to set the sdev to.
+ * @reason: The reason for the queue depth change.
+ *
+ * This function is called by the midlayer and the LLD to alter the queue
+ * depth for a scsi device. This function sets the queue depth to the new
+ * value and sends an event out to log the queue depth change.
+ **/
+int
+lpfc_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
+{
+        struct lpfc_vport *vport = (struct lpfc_vport *) sdev->host->hostdata;
+        struct lpfc_hba   *phba = vport->phba;
+        struct lpfc_rport_data *rdata;
+        unsigned long new_queue_depth, old_queue_depth;
+
+        old_queue_depth = sdev->queue_depth;
+        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+        new_queue_depth = sdev->queue_depth;
+        rdata = sdev->hostdata;
+        if (rdata)
+                lpfc_send_sdev_queuedepth_change_event(phba, vport,
+                                                       rdata->pnode, sdev->lun,
+                                                       old_queue_depth,
+                                                       new_queue_depth);
+        return sdev->queue_depth;
+}
+
+/**
  * lpfc_rampdown_queue_depth - Post RAMP_DOWN_QUEUE event to worker thread
  * @phba: The Hba for which this call is being executed.
  *
@@ -305,8 +342,10 @@ lpfc_rampup_queue_depth(struct lpfc_vport  *vport,
         if (vport->cfg_lun_queue_depth <= queue_depth)
                 return;
         spin_lock_irqsave(&phba->hbalock, flags);
-        if (((phba->last_ramp_up_time + QUEUE_RAMP_UP_INTERVAL) > jiffies) ||
-         ((phba->last_rsrc_error_time + QUEUE_RAMP_UP_INTERVAL ) > jiffies)) {
+        if (time_before(jiffies,
+                        phba->last_ramp_up_time + QUEUE_RAMP_UP_INTERVAL) ||
+            time_before(jiffies,
+                        phba->last_rsrc_error_time + QUEUE_RAMP_UP_INTERVAL)) {
                 spin_unlock_irqrestore(&phba->hbalock, flags);
                 return;
         }
@@ -338,10 +377,9 @@ lpfc_ramp_down_queue_handler(struct lpfc_hba *phba)
         struct lpfc_vport **vports;
         struct Scsi_Host  *shost;
         struct scsi_device *sdev;
-        unsigned long new_queue_depth, old_queue_depth;
+        unsigned long new_queue_depth;
         unsigned long num_rsrc_err, num_cmd_success;
         int i;
-        struct lpfc_rport_data *rdata;
 
         num_rsrc_err = atomic_read(&phba->num_rsrc_err);
         num_cmd_success = atomic_read(&phba->num_cmd_success);
@@ -359,22 +397,8 @@ lpfc_ramp_down_queue_handler(struct lpfc_hba *phba)
                                 else
                                         new_queue_depth = sdev->queue_depth -
                                                                 new_queue_depth;
-                                old_queue_depth = sdev->queue_depth;
-                                if (sdev->ordered_tags)
-                                        scsi_adjust_queue_depth(sdev,
-                                                        MSG_ORDERED_TAG,
-                                                        new_queue_depth);
-                                else
-                                        scsi_adjust_queue_depth(sdev,
-                                                        MSG_SIMPLE_TAG,
-                                                        new_queue_depth);
-                                rdata = sdev->hostdata;
-                                if (rdata)
-                                        lpfc_send_sdev_queuedepth_change_event(
-                                                phba, vports[i],
-                                                rdata->pnode,
-                                                sdev->lun, old_queue_depth,
-                                                new_queue_depth);
+                                lpfc_change_queue_depth(sdev, new_queue_depth,
+                                                        SCSI_QDEPTH_DEFAULT);
                         }
                 }
         lpfc_destroy_vport_work_array(phba, vports);
@@ -398,7 +422,6 @@ lpfc_ramp_up_queue_handler(struct lpfc_hba *phba)
         struct Scsi_Host  *shost;
         struct scsi_device *sdev;
         int i;
-        struct lpfc_rport_data *rdata;
 
         vports = lpfc_create_vport_work_array(phba);
         if (vports != NULL)
@@ -408,22 +431,9 @@ lpfc_ramp_up_queue_handler(struct lpfc_hba *phba)
                                 if (vports[i]->cfg_lun_queue_depth <=
                                     sdev->queue_depth)
                                         continue;
-                                if (sdev->ordered_tags)
-                                        scsi_adjust_queue_depth(sdev,
-                                                        MSG_ORDERED_TAG,
-                                                        sdev->queue_depth+1);
-                                else
-                                        scsi_adjust_queue_depth(sdev,
-                                                        MSG_SIMPLE_TAG,
-                                                        sdev->queue_depth+1);
-                                rdata = sdev->hostdata;
-                                if (rdata)
-                                        lpfc_send_sdev_queuedepth_change_event(
-                                                phba, vports[i],
-                                                rdata->pnode,
-                                                sdev->lun,
-                                                sdev->queue_depth - 1,
-                                                sdev->queue_depth);
+                                lpfc_change_queue_depth(sdev,
+                                                        sdev->queue_depth+1,
+                                                        SCSI_QDEPTH_RAMP_UP);
                         }
                 }
         lpfc_destroy_vport_work_array(phba, vports);
@@ -589,7 +599,7 @@ lpfc_new_scsi_buf_s3(struct lpfc_vport *vport, int num_to_alloc)
                 iocb->ulpClass = CLASS3;
                 psb->status = IOSTAT_SUCCESS;
                 /* Put it back into the SCSI buffer list */
-                lpfc_release_scsi_buf_s4(phba, psb);
+                lpfc_release_scsi_buf_s3(phba, psb);
 
         }
 
@@ -611,22 +621,40 @@ lpfc_sli4_fcp_xri_aborted(struct lpfc_hba *phba,
         uint16_t xri = bf_get(lpfc_wcqe_xa_xri, axri);
         struct lpfc_scsi_buf *psb, *next_psb;
         unsigned long iflag = 0;
+        struct lpfc_iocbq *iocbq;
+        int i;
 
-        spin_lock_irqsave(&phba->sli4_hba.abts_scsi_buf_list_lock, iflag);
+        spin_lock_irqsave(&phba->hbalock, iflag);
+        spin_lock(&phba->sli4_hba.abts_scsi_buf_list_lock);
         list_for_each_entry_safe(psb, next_psb,
                 &phba->sli4_hba.lpfc_abts_scsi_buf_list, list) {
                 if (psb->cur_iocbq.sli4_xritag == xri) {
                         list_del(&psb->list);
+                        psb->exch_busy = 0;
                         psb->status = IOSTAT_SUCCESS;
-                        spin_unlock_irqrestore(
-                                &phba->sli4_hba.abts_scsi_buf_list_lock,
-                                iflag);
+                        spin_unlock(
+                                &phba->sli4_hba.abts_scsi_buf_list_lock);
+                        spin_unlock_irqrestore(&phba->hbalock, iflag);
                         lpfc_release_scsi_buf_s4(phba, psb);
                         return;
                 }
         }
-        spin_unlock_irqrestore(&phba->sli4_hba.abts_scsi_buf_list_lock,
-                                iflag);
+        spin_unlock(&phba->sli4_hba.abts_scsi_buf_list_lock);
+        for (i = 1; i <= phba->sli.last_iotag; i++) {
+                iocbq = phba->sli.iocbq_lookup[i];
+
+                if (!(iocbq->iocb_flag &  LPFC_IO_FCP) ||
+                        (iocbq->iocb_flag & LPFC_IO_LIBDFC))
+                        continue;
+                if (iocbq->sli4_xritag != xri)
+                        continue;
+                psb = container_of(iocbq, struct lpfc_scsi_buf, cur_iocbq);
+                psb->exch_busy = 0;
+                spin_unlock_irqrestore(&phba->hbalock, iflag);
+                return;
+
+        }
+        spin_unlock_irqrestore(&phba->hbalock, iflag);
 }
 
 /**
@@ -679,11 +707,12 @@ lpfc_sli4_repost_scsi_sgl_list(struct lpfc_hba *phba)
                                          list);
                         if (status) {
                                 /* Put this back on the abort scsi list */
-                                psb->status = IOSTAT_LOCAL_REJECT;
-                                psb->result = IOERR_ABORT_REQUESTED;
+                                psb->exch_busy = 1;
                                 rc++;
-                        } else
+                        } else {
+                                psb->exch_busy = 0;
                                 psb->status = IOSTAT_SUCCESS;
+                        }
                         /* Put it back into the SCSI buffer list */
                         lpfc_release_scsi_buf_s4(phba, psb);
                 }
@@ -787,19 +816,17 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                  */
                 sgl->addr_hi = cpu_to_le32(putPaddrHigh(pdma_phys_fcp_cmd));
                 sgl->addr_lo = cpu_to_le32(putPaddrLow(pdma_phys_fcp_cmd));
-                bf_set(lpfc_sli4_sge_len, sgl, sizeof(struct fcp_cmnd));
                 bf_set(lpfc_sli4_sge_last, sgl, 0);
                 sgl->word2 = cpu_to_le32(sgl->word2);
-                sgl->word3 = cpu_to_le32(sgl->word3);
+                sgl->sge_len = cpu_to_le32(sizeof(struct fcp_cmnd));
                 sgl++;
 
                 /* Setup the physical region for the FCP RSP */
                 sgl->addr_hi = cpu_to_le32(putPaddrHigh(pdma_phys_fcp_rsp));
                 sgl->addr_lo = cpu_to_le32(putPaddrLow(pdma_phys_fcp_rsp));
-                bf_set(lpfc_sli4_sge_len, sgl, sizeof(struct fcp_rsp));
                 bf_set(lpfc_sli4_sge_last, sgl, 1);
                 sgl->word2 = cpu_to_le32(sgl->word2);
-                sgl->word3 = cpu_to_le32(sgl->word3);
+                sgl->sge_len = cpu_to_le32(sizeof(struct fcp_rsp));
 
                 /*
                  * Since the IOCB for the FCP I/O is built into this
@@ -830,11 +857,12 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                                                 psb->cur_iocbq.sli4_xritag);
                         if (status) {
                                 /* Put this back on the abort scsi list */
-                                psb->status = IOSTAT_LOCAL_REJECT;
-                                psb->result = IOERR_ABORT_REQUESTED;
+                                psb->exch_busy = 1;
                                 rc++;
-                        } else
+                        } else {
+                                psb->exch_busy = 0;
                                 psb->status = IOSTAT_SUCCESS;
+                        }
                         /* Put it back into the SCSI buffer list */
                         lpfc_release_scsi_buf_s4(phba, psb);
                         break;
@@ -848,11 +876,12 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                                  list);
                         if (status) {
                                 /* Put this back on the abort scsi list */
-                                psb->status = IOSTAT_LOCAL_REJECT;
-                                psb->result = IOERR_ABORT_REQUESTED;
+                                psb->exch_busy = 1;
                                 rc++;
-                        } else
+                        } else {
+                                psb->exch_busy = 0;
                                 psb->status = IOSTAT_SUCCESS;
+                        }
                         /* Put it back into the SCSI buffer list */
                         lpfc_release_scsi_buf_s4(phba, psb);
                 }
@@ -942,8 +971,7 @@ lpfc_release_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
 {
         unsigned long iflag = 0;
 
-        if (psb->status == IOSTAT_LOCAL_REJECT
-                && psb->result == IOERR_ABORT_REQUESTED) {
+        if (psb->exch_busy) {
                 spin_lock_irqsave(&phba->sli4_hba.abts_scsi_buf_list_lock,
                                         iflag);
                 psb->pCmd = NULL;
@@ -996,6 +1024,7 @@ lpfc_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
         struct scatterlist *sgel = NULL;
         struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
         struct ulp_bde64 *bpl = lpfc_cmd->fcp_bpl;
+        struct lpfc_iocbq *iocbq = &lpfc_cmd->cur_iocbq;
         IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
         struct ulp_bde64 *data_bde = iocb_cmd->unsli3.fcp_ext.dbde;
         dma_addr_t physaddr;
@@ -1024,7 +1053,8 @@ lpfc_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
 
                 lpfc_cmd->seg_cnt = nseg;
                 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
-                        printk(KERN_ERR "%s: Too many sg segments from "
+                        lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                                "9064 BLKGRD: %s: Too many sg segments from "
                                "dma_map_sg.  Config %d, seg_cnt %d\n",
                                __func__, phba->cfg_sg_seg_cnt,
                                lpfc_cmd->seg_cnt);
@@ -1045,6 +1075,7 @@ lpfc_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
                         physaddr = sg_dma_address(sgel);
                         if (phba->sli_rev == 3 &&
                             !(phba->sli3_options & LPFC_SLI3_BG_ENABLED) &&
+                            !(iocbq->iocb_flag & DSS_SECURITY_OP) &&
                             nseg <= LPFC_EXT_DATA_BDE_COUNT) {
                                 data_bde->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
                                 data_bde->tus.f.bdeSize = sg_dma_len(sgel);
@@ -1071,7 +1102,8 @@ lpfc_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
          * explicitly reinitialized since all iocb memory resources are reused.
          */
         if (phba->sli_rev == 3 &&
-            !(phba->sli3_options & LPFC_SLI3_BG_ENABLED)) {
+            !(phba->sli3_options & LPFC_SLI3_BG_ENABLED) &&
+            !(iocbq->iocb_flag & DSS_SECURITY_OP)) {
                 if (num_bde > LPFC_EXT_DATA_BDE_COUNT) {
                         /*
                          * The extended IOCB format can only fit 3 BDE or a BPL.
@@ -1096,6 +1128,7 @@ lpfc_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
         } else {
                 iocb_cmd->un.fcpi64.bdl.bdeSize =
                         ((num_bde + 2) * sizeof(struct ulp_bde64));
+                iocb_cmd->unsli3.fcp_ext.ebde_count = (num_bde + 1);
         }
         fcp_cmnd->fcpDl = cpu_to_be32(scsi_bufflen(scsi_cmnd));
 
@@ -1112,7 +1145,7 @@ lpfc_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
  * with the cmd
  */
 static int
-lpfc_sc_to_sli_prof(struct scsi_cmnd *sc)
+lpfc_sc_to_sli_prof(struct lpfc_hba *phba, struct scsi_cmnd *sc)
 {
         uint8_t guard_type = scsi_host_get_guard(sc->device->host);
         uint8_t ret_prof = LPFC_PROF_INVALID;
@@ -1136,7 +1169,8 @@ lpfc_sc_to_sli_prof(struct scsi_cmnd *sc)
 
                 case SCSI_PROT_NORMAL:
                 default:
-                        printk(KERN_ERR "Bad op/guard:%d/%d combination\n",
+                        lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                                "9063 BLKGRD:Bad op/guard:%d/%d combination\n",
                                         scsi_get_prot_op(sc), guard_type);
                         break;
 
@@ -1157,7 +1191,8 @@ lpfc_sc_to_sli_prof(struct scsi_cmnd *sc)
                 case SCSI_PROT_WRITE_STRIP:
                 case SCSI_PROT_NORMAL:
                 default:
-                        printk(KERN_ERR "Bad op/guard:%d/%d combination\n",
+                        lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                                "9075 BLKGRD: Bad op/guard:%d/%d combination\n",
                                         scsi_get_prot_op(sc), guard_type);
                         break;
                 }
@@ -1259,7 +1294,7 @@ lpfc_bg_setup_bpl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
         uint16_t apptagmask, apptagval;
 
         pde1 = (struct lpfc_pde *) bpl;
-        prof = lpfc_sc_to_sli_prof(sc);
+        prof = lpfc_sc_to_sli_prof(phba, sc);
 
         if (prof == LPFC_PROF_INVALID)
                 goto out;
@@ -1359,7 +1394,7 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
                 return 0;
         }
 
-        prof = lpfc_sc_to_sli_prof(sc);
+        prof = lpfc_sc_to_sli_prof(phba, sc);
         if (prof == LPFC_PROF_INVALID)
                 goto out;
 
@@ -1408,7 +1443,8 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
                 subtotal = 0; /* total bytes processed for current prot grp */
                 while (!pgdone) {
                         if (!sgde) {
-                                printk(KERN_ERR "%s Invalid data segment\n",
+                                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                                        "9065 BLKGRD:%s Invalid data segment\n",
                                                 __func__);
                                 return 0;
                         }
@@ -1462,7 +1498,8 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
                         reftag += protgrp_blks;
                 } else {
                         /* if we're here, we have a bug */
-                        printk(KERN_ERR "BLKGRD: bug in %s\n", __func__);
+                        lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                                "9054 BLKGRD: bug in %s\n", __func__);
                 }
 
         } while (!alldone);
@@ -1544,8 +1581,10 @@ lpfc_bg_scsi_prep_dma_buf(struct lpfc_hba *phba,
 
                 lpfc_cmd->seg_cnt = datasegcnt;
                 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
-                        printk(KERN_ERR "%s: Too many sg segments from "
-                                        "dma_map_sg.  Config %d, seg_cnt %d\n",
+                        lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                                        "9067 BLKGRD: %s: Too many sg segments"
+                                        " from dma_map_sg.  Config %d, seg_cnt"
+                                        " %d\n",
                                         __func__, phba->cfg_sg_seg_cnt,
                                         lpfc_cmd->seg_cnt);
                         scsi_dma_unmap(scsi_cmnd);
@@ -1558,7 +1597,7 @@ lpfc_bg_scsi_prep_dma_buf(struct lpfc_hba *phba,
                 case LPFC_PG_TYPE_NO_DIF:
                         num_bde = lpfc_bg_setup_bpl(phba, scsi_cmnd, bpl,
                                         datasegcnt);
-                        /* we shoud have 2 or more entries in buffer list */
+                        /* we should have 2 or more entries in buffer list */
                         if (num_bde < 2)
                                 goto err;
                         break;
@@ -1579,8 +1618,9 @@ lpfc_bg_scsi_prep_dma_buf(struct lpfc_hba *phba,
                         lpfc_cmd->prot_seg_cnt = protsegcnt;
                         if (lpfc_cmd->prot_seg_cnt
                             > phba->cfg_prot_sg_seg_cnt) {
-                                printk(KERN_ERR "%s: Too many prot sg segments "
-                                                "from dma_map_sg.  Config %d,"
+                                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                                        "9068 BLKGRD: %s: Too many prot sg "
+                                        "segments from dma_map_sg.  Config %d,"
                                                 "prot_seg_cnt %d\n", __func__,
                                                 phba->cfg_prot_sg_seg_cnt,
                                                 lpfc_cmd->prot_seg_cnt);
@@ -1594,7 +1634,7 @@ lpfc_bg_scsi_prep_dma_buf(struct lpfc_hba *phba,
 
                         num_bde = lpfc_bg_setup_bpl_prot(phba, scsi_cmnd, bpl,
                                         datasegcnt, protsegcnt);
-                        /* we shoud have 3 or more entries in buffer list */
+                        /* we should have 3 or more entries in buffer list */
                         if (num_bde < 3)
                                 goto err;
                         break;
@@ -1671,23 +1711,26 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
         uint32_t bgstat = bgf->bgstat;
         uint64_t failing_sector = 0;
 
-        printk(KERN_ERR "BG ERROR in cmd 0x%x lba 0x%llx blk cnt 0x%x "
+        lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9069 BLKGRD: BG ERROR in cmd"
+                        " 0x%x lba 0x%llx blk cnt 0x%x "
                         "bgstat=0x%x bghm=0x%x\n",
                         cmd->cmnd[0], (unsigned long long)scsi_get_lba(cmd),
                         blk_rq_sectors(cmd->request), bgstat, bghm);
 
         spin_lock(&_dump_buf_lock);
         if (!_dump_buf_done) {
-                printk(KERN_ERR "Saving Data for %u blocks to debugfs\n",
+                lpfc_printf_log(phba, KERN_ERR, LOG_BG,  "9070 BLKGRD: Saving"
+                        " Data for %u blocks to debugfs\n",
                                 (cmd->cmnd[7] << 8 | cmd->cmnd[8]));
-                lpfc_debug_save_data(cmd);
+                lpfc_debug_save_data(phba, cmd);
 
                 /* If we have a prot sgl, save the DIF buffer */
                 if (lpfc_prot_group_type(phba, cmd) ==
                                 LPFC_PG_TYPE_DIF_BUF) {
-                        printk(KERN_ERR "Saving DIF for %u blocks to debugfs\n",
-                                        (cmd->cmnd[7] << 8 | cmd->cmnd[8]));
-                        lpfc_debug_save_dif(cmd);
+                        lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9071 BLKGRD: "
+                                "Saving DIF for %u blocks to debugfs\n",
+                                (cmd->cmnd[7] << 8 | cmd->cmnd[8]));
+                        lpfc_debug_save_dif(phba, cmd);
                 }
 
                 _dump_buf_done = 1;
@@ -1696,15 +1739,17 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
 
         if (lpfc_bgs_get_invalid_prof(bgstat)) {
                 cmd->result = ScsiResult(DID_ERROR, 0);
-                printk(KERN_ERR "Invalid BlockGuard profile. bgstat:0x%x\n",
-                                bgstat);
+                lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9072 BLKGRD: Invalid"
+                        " BlockGuard profile. bgstat:0x%x\n",
+                        bgstat);
                 ret = (-1);
                 goto out;
         }
 
         if (lpfc_bgs_get_uninit_dif_block(bgstat)) {
                 cmd->result = ScsiResult(DID_ERROR, 0);
-                printk(KERN_ERR "Invalid BlockGuard DIF Block. bgstat:0x%x\n",
+                lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9073 BLKGRD: "
+                                "Invalid BlockGuard DIF Block. bgstat:0x%x\n",
                                 bgstat);
                 ret = (-1);
                 goto out;
@@ -1718,7 +1763,8 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
                 cmd->result = DRIVER_SENSE << 24
                         | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
                 phba->bg_guard_err_cnt++;
-                printk(KERN_ERR "BLKGRD: guard_tag error\n");
+                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                        "9055 BLKGRD: guard_tag error\n");
         }
 
         if (lpfc_bgs_get_reftag_err(bgstat)) {
@@ -1730,7 +1776,8 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
                         | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
 
                 phba->bg_reftag_err_cnt++;
-                printk(KERN_ERR "BLKGRD: ref_tag error\n");
+                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                        "9056 BLKGRD: ref_tag error\n");
         }
 
         if (lpfc_bgs_get_apptag_err(bgstat)) {
@@ -1742,7 +1789,8 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
                         | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
 
                 phba->bg_apptag_err_cnt++;
-                printk(KERN_ERR "BLKGRD: app_tag error\n");
+                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                        "9061 BLKGRD: app_tag error\n");
         }
 
         if (lpfc_bgs_get_hi_water_mark_present(bgstat)) {
@@ -1763,7 +1811,8 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
         if (!ret) {
                 /* No error was reported - problem in FW? */
                 cmd->result = ScsiResult(DID_ERROR, 0);
-                printk(KERN_ERR "BLKGRD: no errors reported!\n");
+                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                        "9057 BLKGRD: no errors reported!\n");
         }
 
 out:
@@ -1822,9 +1871,10 @@ lpfc_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
 
                 lpfc_cmd->seg_cnt = nseg;
                 if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
-                        printk(KERN_ERR "%s: Too many sg segments from "
-                               "dma_map_sg.  Config %d, seg_cnt %d\n",
-                               __func__, phba->cfg_sg_seg_cnt,
+                        lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9074 BLKGRD:"
+                                " %s: Too many sg segments from "
+                                "dma_map_sg.  Config %d, seg_cnt %d\n",
+                                __func__, phba->cfg_sg_seg_cnt,
                                lpfc_cmd->seg_cnt);
                         scsi_dma_unmap(scsi_cmnd);
                         return 1;
@@ -1842,7 +1892,6 @@ lpfc_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
                 scsi_for_each_sg(scsi_cmnd, sgel, nseg, num_bde) {
                         physaddr = sg_dma_address(sgel);
                         dma_len = sg_dma_len(sgel);
-                        bf_set(lpfc_sli4_sge_len, sgl, sg_dma_len(sgel));
                         sgl->addr_lo = cpu_to_le32(putPaddrLow(physaddr));
                         sgl->addr_hi = cpu_to_le32(putPaddrHigh(physaddr));
                         if ((num_bde + 1) == nseg)
@@ -1851,7 +1900,7 @@ lpfc_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
                                 bf_set(lpfc_sli4_sge_last, sgl, 0);
                         bf_set(lpfc_sli4_sge_offset, sgl, dma_offset);
                         sgl->word2 = cpu_to_le32(sgl->word2);
-                        sgl->word3 = cpu_to_le32(sgl->word3);
+                        sgl->sge_len = cpu_to_le32(dma_len);
                         dma_offset += dma_len;
                         sgl++;
                 }
@@ -2050,6 +2099,31 @@ lpfc_handle_fcp_err(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
                 goto out;
         }
 
+        if (resp_info & RSP_LEN_VALID) {
+                rsplen = be32_to_cpu(fcprsp->rspRspLen);
+                if (rsplen != 0 && rsplen != 4 && rsplen != 8) {
+                        lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+                                 "2719 Invalid response length: "
+                                 "tgt x%x lun x%x cmnd x%x rsplen x%x\n",
+                                 cmnd->device->id,
+                                 cmnd->device->lun, cmnd->cmnd[0],
+                                 rsplen);
+                        host_status = DID_ERROR;
+                        goto out;
+                }
+                if (fcprsp->rspInfo3 != RSP_NO_FAILURE) {
+                        lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+                                 "2757 Protocol failure detected during "
+                                 "processing of FCP I/O op: "
+                                 "tgt x%x lun x%x cmnd x%x rspInfo3 x%x\n",
+                                 cmnd->device->id,
+                                 cmnd->device->lun, cmnd->cmnd[0],
+                                 fcprsp->rspInfo3);
+                        host_status = DID_ERROR;
+                        goto out;
+                }
+        }
+
         if ((resp_info & SNS_LEN_VALID) && fcprsp->rspSnsLen) {
                 uint32_t snslen = be32_to_cpu(fcprsp->rspSnsLen);
                 if (snslen > SCSI_SENSE_BUFFERSIZE)
@@ -2074,15 +2148,6 @@ lpfc_handle_fcp_err(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
                          be32_to_cpu(fcprsp->rspRspLen),
                          fcprsp->rspInfo3);
 
-        if (resp_info & RSP_LEN_VALID) {
-                rsplen = be32_to_cpu(fcprsp->rspRspLen);
-                if ((rsplen != 0 && rsplen != 4 && rsplen != 8) ||
-                    (fcprsp->rspInfo3 != RSP_NO_FAILURE)) {
-                        host_status = DID_ERROR;
-                        goto out;
-                }
-        }
-
         scsi_set_resid(cmnd, 0);
         if (resp_info & RESID_UNDER) {
                 scsi_set_resid(cmnd, be32_to_cpu(fcprsp->rspResId));
@@ -2180,7 +2245,7 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
         struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
         int result;
         struct scsi_device *tmp_sdev;
-        int depth = 0;
+        int depth;
         unsigned long flags;
         struct lpfc_fast_path_event *fast_path_evt;
         struct Scsi_Host *shost = cmd->device->host;
@@ -2188,6 +2253,9 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
 
         lpfc_cmd->result = pIocbOut->iocb.un.ulpWord[4];
         lpfc_cmd->status = pIocbOut->iocb.ulpStatus;
+        /* pick up SLI4 exhange busy status from HBA */
+        lpfc_cmd->exch_busy = pIocbOut->iocb_flag & LPFC_EXCHANGE_BUSY;
+
         if (pnode && NLP_CHK_NODE_ACT(pnode))
                 atomic_dec(&pnode->cmd_pending);
 
@@ -2264,7 +2332,7 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
                                         lpfc_printf_vlog(vport, KERN_WARNING,
                                                         LOG_BG,
                                                         "9031 non-zero BGSTAT "
-                                                        "on unprotected cmd");
+                                                        "on unprotected cmd\n");
                                 }
                         }
 
@@ -2347,67 +2415,29 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
                 return;
         }
 
-
         if (!result)
                 lpfc_rampup_queue_depth(vport, queue_depth);
 
-        if (!result && pnode && NLP_CHK_NODE_ACT(pnode) &&
-           ((jiffies - pnode->last_ramp_up_time) >
-                LPFC_Q_RAMP_UP_INTERVAL * HZ) &&
-           ((jiffies - pnode->last_q_full_time) >
-                LPFC_Q_RAMP_UP_INTERVAL * HZ) &&
-           (vport->cfg_lun_queue_depth > queue_depth)) {
-                shost_for_each_device(tmp_sdev, shost) {
-                        if (vport->cfg_lun_queue_depth > tmp_sdev->queue_depth){
-                                if (tmp_sdev->id != scsi_id)
-                                        continue;
-                                if (tmp_sdev->ordered_tags)
-                                        scsi_adjust_queue_depth(tmp_sdev,
-                                                MSG_ORDERED_TAG,
-                                                tmp_sdev->queue_depth+1);
-                                else
-                                        scsi_adjust_queue_depth(tmp_sdev,
-                                                MSG_SIMPLE_TAG,
-                                                tmp_sdev->queue_depth+1);
-
-                                pnode->last_ramp_up_time = jiffies;
-                        }
-                }
-                lpfc_send_sdev_queuedepth_change_event(phba, vport, pnode,
-                        0xFFFFFFFF,
-                        queue_depth , queue_depth + 1);
-        }
-
         /*
          * Check for queue full.  If the lun is reporting queue full, then
          * back off the lun queue depth to prevent target overloads.
          */
         if (result == SAM_STAT_TASK_SET_FULL && pnode &&
             NLP_CHK_NODE_ACT(pnode)) {
-                pnode->last_q_full_time = jiffies;
-
                 shost_for_each_device(tmp_sdev, shost) {
                         if (tmp_sdev->id != scsi_id)
                                 continue;
                         depth = scsi_track_queue_full(tmp_sdev,
-                                        tmp_sdev->queue_depth - 1);
-                }
-                /*
-                 * The queue depth cannot be lowered any more.
-                 * Modify the returned error code to store
-                 * the final depth value set by
-                 * scsi_track_queue_full.
-                 */
-                if (depth == -1)
-                        depth = shost->cmd_per_lun;
-
-                if (depth) {
+                                                      tmp_sdev->queue_depth-1);
+                        if (depth <= 0)
+                                continue;
                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
                                          "0711 detected queue full - lun queue "
                                          "depth adjusted to %d.\n", depth);
                         lpfc_send_sdev_queuedepth_change_event(phba, vport,
-                                pnode, 0xFFFFFFFF,
-                                depth+1, depth);
+                                                               pnode,
+                                                               tmp_sdev->lun,
+                                                               depth+1, depth);
                 }
         }
 
@@ -2642,6 +2672,7 @@ lpfc_scsi_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
         }
         phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf;
         phba->lpfc_rampdown_queue_depth = lpfc_rampdown_queue_depth;
+        phba->lpfc_scsi_cmd_iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl;
         return 0;
 }
 
@@ -2700,6 +2731,13 @@ lpfc_info(struct Scsi_Host *host)
                                  " port %s",
                                  phba->Port);
                 }
+                len = strlen(lpfcinfobuf);
+                if (phba->sli4_hba.link_state.logical_speed) {
+                        snprintf(lpfcinfobuf + len,
+                                 384-len,
+                                 " Logical Link Speed: %d Mbps",
+                                 phba->sli4_hba.link_state.logical_speed * 10);
+                }
         }
         return lpfcinfobuf;
 }
@@ -2745,7 +2783,9 @@ void lpfc_poll_timeout(unsigned long ptr)
         struct lpfc_hba *phba = (struct lpfc_hba *) ptr;
 
         if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
-                lpfc_sli_poll_fcp_ring (phba);
+                lpfc_sli_handle_fast_ring_event(phba,
+                        &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ);
+
                 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
                         lpfc_poll_rearm_timer(phba);
         }
@@ -2771,7 +2811,7 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_hba   *phba = vport->phba;
         struct lpfc_rport_data *rdata = cmnd->device->hostdata;
-        struct lpfc_nodelist *ndlp = rdata->pnode;
+        struct lpfc_nodelist *ndlp;
         struct lpfc_scsi_buf *lpfc_cmd;
         struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
         int err;
@@ -2781,13 +2821,15 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
                 cmnd->result = err;
                 goto out_fail_command;
         }
+        ndlp = rdata->pnode;
 
         if (!(phba->sli3_options & LPFC_SLI3_BG_ENABLED) &&
                 scsi_get_prot_op(cmnd) != SCSI_PROT_NORMAL) {
 
-                printk(KERN_ERR "BLKGRD ERROR: rcvd protected cmd:%02x op:%02x "
-                                "str=%s without registering for BlockGuard - "
-                                "Rejecting command\n",
+                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
+                                "9058 BLKGRD: ERROR: rcvd protected cmd:%02x"
+                                " op:%02x str=%s without registering for"
+                                " BlockGuard - Rejecting command\n",
                                 cmnd->cmnd[0], scsi_get_prot_op(cmnd),
                                 dif_op_str[scsi_get_prot_op(cmnd)]);
                 goto out_fail_command;
@@ -2827,61 +2869,66 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
         cmnd->scsi_done = done;
 
         if (scsi_get_prot_op(cmnd) != SCSI_PROT_NORMAL) {
-                lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
+                if (vport->phba->cfg_enable_bg) {
+                        lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                 "9033 BLKGRD: rcvd protected cmd:%02x op:%02x "
                                 "str=%s\n",
                                 cmnd->cmnd[0], scsi_get_prot_op(cmnd),
                                 dif_op_str[scsi_get_prot_op(cmnd)]);
-                lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
+                        lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                 "9034 BLKGRD: CDB: %02x %02x %02x %02x %02x "
                                 "%02x %02x %02x %02x %02x\n",
                                 cmnd->cmnd[0], cmnd->cmnd[1], cmnd->cmnd[2],
                                 cmnd->cmnd[3], cmnd->cmnd[4], cmnd->cmnd[5],
                                 cmnd->cmnd[6], cmnd->cmnd[7], cmnd->cmnd[8],
                                 cmnd->cmnd[9]);
-                if (cmnd->cmnd[0] == READ_10)
-                        lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
+                        if (cmnd->cmnd[0] == READ_10)
+                                lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                         "9035 BLKGRD: READ @ sector %llu, "
                                         "count %u\n",
                                         (unsigned long long)scsi_get_lba(cmnd),
                                         blk_rq_sectors(cmnd->request));
-                else if (cmnd->cmnd[0] == WRITE_10)
-                        lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
+                        else if (cmnd->cmnd[0] == WRITE_10)
+                                lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                         "9036 BLKGRD: WRITE @ sector %llu, "
                                         "count %u cmd=%p\n",
                                         (unsigned long long)scsi_get_lba(cmnd),
                                         blk_rq_sectors(cmnd->request),
                                         cmnd);
+                }
 
                 err = lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
         } else {
-                lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
-                                "9038 BLKGRD: rcvd unprotected cmd:%02x op:%02x"
-                                " str=%s\n",
-                                cmnd->cmnd[0], scsi_get_prot_op(cmnd),
-                                dif_op_str[scsi_get_prot_op(cmnd)]);
-                lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
-                                 "9039 BLKGRD: CDB: %02x %02x %02x %02x %02x "
-                                 "%02x %02x %02x %02x %02x\n",
-                                 cmnd->cmnd[0], cmnd->cmnd[1], cmnd->cmnd[2],
-                                 cmnd->cmnd[3], cmnd->cmnd[4], cmnd->cmnd[5],
-                                 cmnd->cmnd[6], cmnd->cmnd[7], cmnd->cmnd[8],
-                                 cmnd->cmnd[9]);
-                if (cmnd->cmnd[0] == READ_10)
+                if (vport->phba->cfg_enable_bg) {
                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
-                                         "9040 dbg: READ @ sector %llu, "
-                                         "count %u\n",
-                                         (unsigned long long)scsi_get_lba(cmnd),
+                                        "9038 BLKGRD: rcvd unprotected cmd:"
+                                        "%02x op:%02x str=%s\n",
+                                        cmnd->cmnd[0], scsi_get_prot_op(cmnd),
+                                        dif_op_str[scsi_get_prot_op(cmnd)]);
+                                lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
+                                        "9039 BLKGRD: CDB: %02x %02x %02x "
+                                        "%02x %02x %02x %02x %02x %02x %02x\n",
+                                        cmnd->cmnd[0], cmnd->cmnd[1],
+                                        cmnd->cmnd[2], cmnd->cmnd[3],
+                                        cmnd->cmnd[4], cmnd->cmnd[5],
+                                        cmnd->cmnd[6], cmnd->cmnd[7],
+                                        cmnd->cmnd[8], cmnd->cmnd[9]);
+                        if (cmnd->cmnd[0] == READ_10)
+                                lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
+                                        "9040 dbg: READ @ sector %llu, "
+                                        "count %u\n",
+                                        (unsigned long long)scsi_get_lba(cmnd),
                                          blk_rq_sectors(cmnd->request));
-                else if (cmnd->cmnd[0] == WRITE_10)
-                        lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
+                        else if (cmnd->cmnd[0] == WRITE_10)
+                                lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                          "9041 dbg: WRITE @ sector %llu, "
                                          "count %u cmd=%p\n",
                                          (unsigned long long)scsi_get_lba(cmnd),
                                          blk_rq_sectors(cmnd->request), cmnd);
-                else
-                        lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
+                        else
+                                lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                          "9042 dbg: parser not implemented\n");
+                }
                 err = lpfc_scsi_prep_dma_buf(phba, lpfc_cmd);
         }
 
@@ -2898,7 +2945,11 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
                 goto out_host_busy_free_buf;
         }
         if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
-                lpfc_sli_poll_fcp_ring(phba);
+                spin_unlock(shost->host_lock);
+                lpfc_sli_handle_fast_ring_event(phba,
+                        &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ);
+
+                spin_lock(shost->host_lock);
                 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
                         lpfc_poll_rearm_timer(phba);
         }
@@ -2917,28 +2968,6 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
 }
 
 /**
- * lpfc_block_error_handler - Routine to block error  handler
- * @cmnd: Pointer to scsi_cmnd data structure.
- *
- *  This routine blocks execution till fc_rport state is not FC_PORSTAT_BLCOEKD.
- **/
-static void
-lpfc_block_error_handler(struct scsi_cmnd *cmnd)
-{
-        struct Scsi_Host *shost = cmnd->device->host;
-        struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
-
-        spin_lock_irq(shost->host_lock);
-        while (rport->port_state == FC_PORTSTATE_BLOCKED) {
-                spin_unlock_irq(shost->host_lock);
-                msleep(1000);
-                spin_lock_irq(shost->host_lock);
-        }
-        spin_unlock_irq(shost->host_lock);
-        return;
-}
-
-/**
  * lpfc_abort_handler - scsi_host_template eh_abort_handler entry point
  * @cmnd: Pointer to scsi_cmnd data structure.
  *
@@ -2961,7 +2990,7 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
         int ret = SUCCESS;
         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(waitq);
 
-        lpfc_block_error_handler(cmnd);
+        fc_block_scsi_eh(cmnd);
         lpfc_cmd = (struct lpfc_scsi_buf *)cmnd->host_scribble;
         BUG_ON(!lpfc_cmd);
 
@@ -3001,6 +3030,11 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
 
         icmd->ulpLe = 1;
         icmd->ulpClass = cmd->ulpClass;
+
+        /* ABTS WQE must go to the same WQ as the WQE to be aborted */
+        abtsiocb->fcp_wqidx = iocb->fcp_wqidx;
+        abtsiocb->iocb_flag |= LPFC_USE_FCPWQIDX;
+
         if (lpfc_is_link_up(phba))
                 icmd->ulpCommand = CMD_ABORT_XRI_CN;
         else
@@ -3016,7 +3050,8 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
         }
 
         if (phba->cfg_poll & DISABLE_FCP_RING_INT)
-                lpfc_sli_poll_fcp_ring (phba);
+                lpfc_sli_handle_fast_ring_event(phba,
+                        &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ);
 
         lpfc_cmd->waitq = &waitq;
         /* Wait for abort to complete */
@@ -3166,9 +3201,15 @@ static int
 lpfc_chk_tgt_mapped(struct lpfc_vport *vport, struct scsi_cmnd *cmnd)
 {
         struct lpfc_rport_data *rdata = cmnd->device->hostdata;
-        struct lpfc_nodelist *pnode = rdata->pnode;
+        struct lpfc_nodelist *pnode;
         unsigned long later;
 
+        if (!rdata) {
+                lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
+                        "0797 Tgt Map rport failure: rdata x%p\n", rdata);
+                return FAILED;
+        }
+        pnode = rdata->pnode;
         /*
          * If target is not in a MAPPED state, delay until
          * target is rediscovered or devloss timeout expires.
@@ -3253,13 +3294,19 @@ lpfc_device_reset_handler(struct scsi_cmnd *cmnd)
         struct Scsi_Host  *shost = cmnd->device->host;
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_rport_data *rdata = cmnd->device->hostdata;
-        struct lpfc_nodelist *pnode = rdata->pnode;
+        struct lpfc_nodelist *pnode;
         unsigned tgt_id = cmnd->device->id;
         unsigned int lun_id = cmnd->device->lun;
         struct lpfc_scsi_event_header scsi_event;
         int status;
 
-        lpfc_block_error_handler(cmnd);
+        if (!rdata) {
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+                        "0798 Device Reset rport failure: rdata x%p\n", rdata);
+                return FAILED;
+        }
+        pnode = rdata->pnode;
+        fc_block_scsi_eh(cmnd);
 
         status = lpfc_chk_tgt_mapped(vport, cmnd);
         if (status == FAILED) {
@@ -3312,13 +3359,19 @@ lpfc_target_reset_handler(struct scsi_cmnd *cmnd)
         struct Scsi_Host  *shost = cmnd->device->host;
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
         struct lpfc_rport_data *rdata = cmnd->device->hostdata;
-        struct lpfc_nodelist *pnode = rdata->pnode;
+        struct lpfc_nodelist *pnode;
         unsigned tgt_id = cmnd->device->id;
         unsigned int lun_id = cmnd->device->lun;
         struct lpfc_scsi_event_header scsi_event;
         int status;
 
-        lpfc_block_error_handler(cmnd);
+        if (!rdata) {
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+                        "0799 Target Reset rport failure: rdata x%p\n", rdata);
+                return FAILED;
+        }
+        pnode = rdata->pnode;
+        fc_block_scsi_eh(cmnd);
 
         status = lpfc_chk_tgt_mapped(vport, cmnd);
         if (status == FAILED) {
@@ -3384,7 +3437,7 @@ lpfc_bus_reset_handler(struct scsi_cmnd *cmnd)
         fc_host_post_vendor_event(shost, fc_get_event_number(),
                 sizeof(scsi_event), (char *)&scsi_event, LPFC_NL_VENDOR_ID);
 
-        lpfc_block_error_handler(cmnd);
+        fc_block_scsi_eh(cmnd);
 
         /*
          * Since the driver manages a single bus device, reset all
@@ -3498,6 +3551,8 @@ lpfc_slave_alloc(struct scsi_device *sdev)
                                  "Allocated %d buffers.\n",
                                  num_to_alloc, num_allocated);
         }
+        if (num_allocated > 0)
+                phba->total_scsi_bufs += num_allocated;
         return 0;
 }
 
@@ -3534,7 +3589,8 @@ lpfc_slave_configure(struct scsi_device *sdev)
         rport->dev_loss_tmo = vport->cfg_devloss_tmo;
 
         if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
-                lpfc_sli_poll_fcp_ring(phba);
+                lpfc_sli_handle_fast_ring_event(phba,
+                        &phba->sli.ring[LPFC_FCP_RING], HA_R0RE_REQ);
                 if (phba->cfg_poll & DISABLE_FCP_RING_INT)
                         lpfc_poll_rearm_timer(phba);
         }
@@ -3576,6 +3632,7 @@ struct scsi_host_template lpfc_template = {
         .shost_attrs            = lpfc_hba_attrs,
         .max_sectors            = 0xFFFF,
         .vendor_id              = LPFC_NL_VENDOR_ID,
+        .change_queue_depth     = lpfc_change_queue_depth,
 };
 
 struct scsi_host_template lpfc_vport_template = {
@@ -3597,4 +3654,5 @@ struct scsi_host_template lpfc_vport_template = {
         .use_clustering         = ENABLE_CLUSTERING,
         .shost_attrs            = lpfc_vport_attrs,
         .max_sectors            = 0xFFFF,
+        .change_queue_depth     = lpfc_change_queue_depth,
 };
diff --git a/drivers/scsi/lpfc/lpfc_scsi.h b/drivers/scsi/lpfc/lpfc_scsi.h
index 65dfc8bd5b49..5932273870a5 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.h
+++ b/drivers/scsi/lpfc/lpfc_scsi.h
@@ -118,6 +118,7 @@ struct lpfc_scsi_buf {
 
         uint32_t timeout;
 
+        uint16_t exch_busy;     /* SLI4 hba reported XB on complete WCQE */
         uint16_t status;        /* From IOCB Word 7- ulpStatus */
         uint32_t result;        /* From IOCB Word 4. */
 
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index 43cbe336f1f8..049fb9a17b3f 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -23,6 +23,7 @@
 #include <linux/pci.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -30,6 +31,7 @@
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_transport_fc.h>
 #include <scsi/fc/fc_fs.h>
+#include <linux/aer.h>
 
 #include "lpfc_hw4.h"
 #include "lpfc_hw.h"
@@ -58,8 +60,11 @@ typedef enum _lpfc_iocb_type {
 static int lpfc_sli_issue_mbox_s4(struct lpfc_hba *, LPFC_MBOXQ_t *,
                                   uint32_t);
 static int lpfc_sli4_read_rev(struct lpfc_hba *, LPFC_MBOXQ_t *,
-                            uint8_t *, uint32_t *);
-
+                              uint8_t *, uint32_t *);
+static struct lpfc_iocbq *lpfc_sli4_els_wcqe_to_rspiocbq(struct lpfc_hba *,
+                                                         struct lpfc_iocbq *);
+static void lpfc_sli4_send_seq_to_ulp(struct lpfc_vport *,
+                                      struct hbq_dmabuf *);
 static IOCB_t *
 lpfc_get_iocb_from_iocbq(struct lpfc_iocbq *iocbq)
 {
@@ -259,6 +264,9 @@ lpfc_sli4_eq_release(struct lpfc_queue *q, bool arm)
         bf_set(lpfc_eqcq_doorbell_qt, &doorbell, LPFC_QUEUE_TYPE_EVENT);
         bf_set(lpfc_eqcq_doorbell_eqid, &doorbell, q->queue_id);
         writel(doorbell.word0, q->phba->sli4_hba.EQCQDBregaddr);
+        /* PCI read to flush PCI pipeline on re-arming for INTx mode */
+        if ((q->phba->intr_type == INTx) && (arm == LPFC_QUEUE_REARM))
+                readl(q->phba->sli4_hba.EQCQDBregaddr);
         return released;
 }
 
@@ -487,7 +495,7 @@ __lpfc_clear_active_sglq(struct lpfc_hba *phba, uint16_t xritag)
  *
  * Returns sglq ponter = success, NULL = Failure.
  **/
-static struct lpfc_sglq *
+struct lpfc_sglq *
 __lpfc_get_active_sglq(struct lpfc_hba *phba, uint16_t xritag)
 {
         uint16_t adj_xri;
@@ -515,8 +523,11 @@ __lpfc_sli_get_sglq(struct lpfc_hba *phba)
         struct lpfc_sglq *sglq = NULL;
         uint16_t adj_xri;
         list_remove_head(lpfc_sgl_list, sglq, struct lpfc_sglq, list);
+        if (!sglq)
+                return NULL;
         adj_xri = sglq->sli4_xritag - phba->sli4_hba.max_cfg_param.xri_base;
         phba->sli4_hba.lpfc_sglq_active_list[adj_xri] = sglq;
+        sglq->state = SGL_ALLOCATED;
         return sglq;
 }
 
@@ -571,18 +582,18 @@ __lpfc_sli_release_iocbq_s4(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
         else
                 sglq = __lpfc_clear_active_sglq(phba, iocbq->sli4_xritag);
         if (sglq)  {
-                if (iocbq->iocb_flag & LPFC_DRIVER_ABORTED
-                        || ((iocbq->iocb.ulpStatus == IOSTAT_LOCAL_REJECT)
-                        && (iocbq->iocb.un.ulpWord[4]
-                                == IOERR_SLI_ABORTED))) {
+                if ((iocbq->iocb_flag & LPFC_EXCHANGE_BUSY) &&
+                        (sglq->state != SGL_XRI_ABORTED)) {
                         spin_lock_irqsave(&phba->sli4_hba.abts_sgl_list_lock,
                                         iflag);
                         list_add(&sglq->list,
                                 &phba->sli4_hba.lpfc_abts_els_sgl_list);
                         spin_unlock_irqrestore(
                                 &phba->sli4_hba.abts_sgl_list_lock, iflag);
-                } else
+                } else {
+                        sglq->state = SGL_FREED;
                         list_add(&sglq->list, &phba->sli4_hba.lpfc_sgl_list);
+                }
         }
 
 
@@ -755,10 +766,6 @@ lpfc_sli_iocb_cmd_type(uint8_t iocb_cmnd)
         case DSSCMD_IWRITE64_CX:
         case DSSCMD_IREAD64_CR:
         case DSSCMD_IREAD64_CX:
-        case DSSCMD_INVALIDATE_DEK:
-        case DSSCMD_SET_KEK:
-        case DSSCMD_GET_KEK_ID:
-        case DSSCMD_GEN_XFER:
                 type = LPFC_SOL_IOCB;
                 break;
         case CMD_ABORT_XRI_CN:
@@ -767,6 +774,7 @@ lpfc_sli_iocb_cmd_type(uint8_t iocb_cmnd)
         case CMD_CLOSE_XRI_CX:
         case CMD_XRI_ABORTED_CX:
         case CMD_ABORT_MXRI64_CN:
+        case CMD_XMIT_BLS_RSP64_CX:
                 type = LPFC_ABORT_IOCB;
                 break;
         case CMD_RCV_SEQUENCE_CX:
@@ -1373,7 +1381,7 @@ lpfc_sli_hbq_to_firmware_s4(struct lpfc_hba *phba, uint32_t hbqno,
 /* HBQ for ELS and CT traffic. */
 static struct lpfc_hbq_init lpfc_els_hbq = {
         .rn = 1,
-        .entry_count = 200,
+        .entry_count = 256,
         .mask_count = 0,
         .profile = 0,
         .ring_mask = (1 << LPFC_ELS_RING),
@@ -1472,8 +1480,11 @@ err:
 int
 lpfc_sli_hbqbuf_add_hbqs(struct lpfc_hba *phba, uint32_t qno)
 {
-        return(lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
-                                         lpfc_hbq_defs[qno]->add_count));
+        if (phba->sli_rev == LPFC_SLI_REV4)
+                return 0;
+        else
+                return lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
+                                         lpfc_hbq_defs[qno]->add_count);
 }
 
 /**
@@ -1488,8 +1499,12 @@ lpfc_sli_hbqbuf_add_hbqs(struct lpfc_hba *phba, uint32_t qno)
 static int
 lpfc_sli_hbqbuf_init_hbqs(struct lpfc_hba *phba, uint32_t qno)
 {
-        return(lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
-                                         lpfc_hbq_defs[qno]->init_count));
+        if (phba->sli_rev == LPFC_SLI_REV4)
+                return lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
+                                         lpfc_hbq_defs[qno]->entry_count);
+        else
+                return lpfc_sli_hbqbuf_fill_hbqs(phba, qno,
+                                         lpfc_hbq_defs[qno]->init_count);
 }
 
 /**
@@ -1700,6 +1715,7 @@ lpfc_sli_def_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         struct lpfc_dmabuf *mp;
         uint16_t rpi, vpi;
         int rc;
+        struct lpfc_vport  *vport = pmb->vport;
 
         mp = (struct lpfc_dmabuf *) (pmb->context1);
 
@@ -1728,6 +1744,18 @@ lpfc_sli_def_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                         return;
         }
 
+        /* Unreg VPI, if the REG_VPI succeed after VLink failure */
+        if ((pmb->u.mb.mbxCommand == MBX_REG_VPI) &&
+                !(phba->pport->load_flag & FC_UNLOADING) &&
+                !pmb->u.mb.mbxStatus) {
+                lpfc_unreg_vpi(phba, pmb->u.mb.un.varRegVpi.vpi, pmb);
+                pmb->vport = vport;
+                pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
+                rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
+                if (rc != MBX_NOT_FINISHED)
+                        return;
+        }
+
         if (bf_get(lpfc_mqe_command, &pmb->u.mqe) == MBX_SLI4_CONFIG)
                 lpfc_sli4_mbox_cmd_free(phba, pmb);
         else
@@ -1794,7 +1822,7 @@ lpfc_sli_handle_mb_event(struct lpfc_hba *phba)
                  */
                 if (lpfc_sli_chk_mbx_command(pmbox->mbxCommand) ==
                     MBX_SHUTDOWN) {
-                        /* Unknow mailbox command compl */
+                        /* Unknown mailbox command compl */
                         lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
                                         "(%d):0323 Unknown Mailbox command "
                                         "x%x (x%x) Cmpl\n",
@@ -2068,8 +2096,8 @@ lpfc_sli_process_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
         if ((irsp->ulpCommand == CMD_RCV_ELS_REQ64_CX) ||
             (irsp->ulpCommand == CMD_RCV_ELS_REQ_CX) ||
             (irsp->ulpCommand == CMD_IOCB_RCV_ELS64_CX)) {
-                Rctl = FC_ELS_REQ;
-                Type = FC_ELS_DATA;
+                Rctl = FC_RCTL_ELS_REQ;
+                Type = FC_TYPE_ELS;
         } else {
                 w5p = (WORD5 *)&(saveq->iocb.un.ulpWord[5]);
                 Rctl = w5p->hcsw.Rctl;
@@ -2079,8 +2107,8 @@ lpfc_sli_process_unsol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                 if ((Rctl == 0) && (pring->ringno == LPFC_ELS_RING) &&
                         (irsp->ulpCommand == CMD_RCV_SEQUENCE64_CX ||
                          irsp->ulpCommand == CMD_IOCB_RCV_SEQ64_CX)) {
-                        Rctl = FC_ELS_REQ;
-                        Type = FC_ELS_DATA;
+                        Rctl = FC_RCTL_ELS_REQ;
+                        Type = FC_TYPE_ELS;
                         w5p->hcsw.Rctl = Rctl;
                         w5p->hcsw.Type = Type;
                 }
@@ -2211,9 +2239,15 @@ lpfc_sli_process_sol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                          * All other are passed to the completion callback.
                          */
                         if (pring->ringno == LPFC_ELS_RING) {
-                                if (cmdiocbp->iocb_flag & LPFC_DRIVER_ABORTED) {
+                                if ((phba->sli_rev < LPFC_SLI_REV4) &&
+                                    (cmdiocbp->iocb_flag &
+                                                        LPFC_DRIVER_ABORTED)) {
+                                        spin_lock_irqsave(&phba->hbalock,
+                                                          iflag);
                                         cmdiocbp->iocb_flag &=
                                                 ~LPFC_DRIVER_ABORTED;
+                                        spin_unlock_irqrestore(&phba->hbalock,
+                                                               iflag);
                                         saveq->iocb.ulpStatus =
                                                 IOSTAT_LOCAL_REJECT;
                                         saveq->iocb.un.ulpWord[4] =
@@ -2223,7 +2257,62 @@ lpfc_sli_process_sol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                                          * of DMAing payload, so don't free data
                                          * buffer till after a hbeat.
                                          */
+                                        spin_lock_irqsave(&phba->hbalock,
+                                                          iflag);
                                         saveq->iocb_flag |= LPFC_DELAY_MEM_FREE;
+                                        spin_unlock_irqrestore(&phba->hbalock,
+                                                               iflag);
+                                }
+                                if (phba->sli_rev == LPFC_SLI_REV4) {
+                                        if (saveq->iocb_flag &
+                                            LPFC_EXCHANGE_BUSY) {
+                                                /* Set cmdiocb flag for the
+                                                 * exchange busy so sgl (xri)
+                                                 * will not be released until
+                                                 * the abort xri is received
+                                                 * from hba.
+                                                 */
+                                                spin_lock_irqsave(
+                                                        &phba->hbalock, iflag);
+                                                cmdiocbp->iocb_flag |=
+                                                        LPFC_EXCHANGE_BUSY;
+                                                spin_unlock_irqrestore(
+                                                        &phba->hbalock, iflag);
+                                        }
+                                        if (cmdiocbp->iocb_flag &
+                                            LPFC_DRIVER_ABORTED) {
+                                                /*
+                                                 * Clear LPFC_DRIVER_ABORTED
+                                                 * bit in case it was driver
+                                                 * initiated abort.
+                                                 */
+                                                spin_lock_irqsave(
+                                                        &phba->hbalock, iflag);
+                                                cmdiocbp->iocb_flag &=
+                                                        ~LPFC_DRIVER_ABORTED;
+                                                spin_unlock_irqrestore(
+                                                        &phba->hbalock, iflag);
+                                                cmdiocbp->iocb.ulpStatus =
+                                                        IOSTAT_LOCAL_REJECT;
+                                                cmdiocbp->iocb.un.ulpWord[4] =
+                                                        IOERR_ABORT_REQUESTED;
+                                                /*
+                                                 * For SLI4, irsiocb contains
+                                                 * NO_XRI in sli_xritag, it
+                                                 * shall not affect releasing
+                                                 * sgl (xri) process.
+                                                 */
+                                                saveq->iocb.ulpStatus =
+                                                        IOSTAT_LOCAL_REJECT;
+                                                saveq->iocb.un.ulpWord[4] =
+                                                        IOERR_SLI_ABORTED;
+                                                spin_lock_irqsave(
+                                                        &phba->hbalock, iflag);
+                                                saveq->iocb_flag |=
+                                                        LPFC_DELAY_MEM_FREE;
+                                                spin_unlock_irqrestore(
+                                                        &phba->hbalock, iflag);
+                                        }
                                 }
                         }
                         (cmdiocbp->iocb_cmpl) (phba, cmdiocbp, saveq);
@@ -2324,168 +2413,6 @@ void lpfc_poll_eratt(unsigned long ptr)
         return;
 }
 
-/**
- * lpfc_sli_poll_fcp_ring - Handle FCP ring completion in polling mode
- * @phba: Pointer to HBA context object.
- *
- * This function is called from lpfc_queuecommand, lpfc_poll_timeout,
- * lpfc_abort_handler and lpfc_slave_configure when FCP_RING_POLLING
- * is enabled.
- *
- * The caller does not hold any lock.
- * The function processes each response iocb in the response ring until it
- * finds an iocb with LE bit set and chains all the iocbs upto the iocb with
- * LE bit set. The function will call the completion handler of the command iocb
- * if the response iocb indicates a completion for a command iocb or it is
- * an abort completion.
- **/
-void lpfc_sli_poll_fcp_ring(struct lpfc_hba *phba)
-{
-        struct lpfc_sli      *psli  = &phba->sli;
-        struct lpfc_sli_ring *pring = &psli->ring[LPFC_FCP_RING];
-        IOCB_t *irsp = NULL;
-        IOCB_t *entry = NULL;
-        struct lpfc_iocbq *cmdiocbq = NULL;
-        struct lpfc_iocbq rspiocbq;
-        struct lpfc_pgp *pgp = &phba->port_gp[pring->ringno];
-        uint32_t status;
-        uint32_t portRspPut, portRspMax;
-        int type;
-        uint32_t rsp_cmpl = 0;
-        uint32_t ha_copy;
-        unsigned long iflags;
-
-        pring->stats.iocb_event++;
-
-        /*
-         * The next available response entry should never exceed the maximum
-         * entries.  If it does, treat it as an adapter hardware error.
-         */
-        portRspMax = pring->numRiocb;
-        portRspPut = le32_to_cpu(pgp->rspPutInx);
-        if (unlikely(portRspPut >= portRspMax)) {
-                lpfc_sli_rsp_pointers_error(phba, pring);
-                return;
-        }
-
-        rmb();
-        while (pring->rspidx != portRspPut) {
-                entry = lpfc_resp_iocb(phba, pring);
-                if (++pring->rspidx >= portRspMax)
-                        pring->rspidx = 0;
-
-                lpfc_sli_pcimem_bcopy((uint32_t *) entry,
-                                      (uint32_t *) &rspiocbq.iocb,
-                                      phba->iocb_rsp_size);
-                irsp = &rspiocbq.iocb;
-                type = lpfc_sli_iocb_cmd_type(irsp->ulpCommand & CMD_IOCB_MASK);
-                pring->stats.iocb_rsp++;
-                rsp_cmpl++;
-
-                if (unlikely(irsp->ulpStatus)) {
-                        /* Rsp ring <ringno> error: IOCB */
-                        lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
-                                        "0326 Rsp Ring %d error: IOCB Data: "
-                                        "x%x x%x x%x x%x x%x x%x x%x x%x\n",
-                                        pring->ringno,
-                                        irsp->un.ulpWord[0],
-                                        irsp->un.ulpWord[1],
-                                        irsp->un.ulpWord[2],
-                                        irsp->un.ulpWord[3],
-                                        irsp->un.ulpWord[4],
-                                        irsp->un.ulpWord[5],
-                                        *(uint32_t *)&irsp->un1,
-                                        *((uint32_t *)&irsp->un1 + 1));
-                }
-
-                switch (type) {
-                case LPFC_ABORT_IOCB:
-                case LPFC_SOL_IOCB:
-                        /*
-                         * Idle exchange closed via ABTS from port.  No iocb
-                         * resources need to be recovered.
-                         */
-                        if (unlikely(irsp->ulpCommand == CMD_XRI_ABORTED_CX)) {
-                                lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
-                                                "0314 IOCB cmd 0x%x "
-                                                "processed. Skipping "
-                                                "completion",
-                                                irsp->ulpCommand);
-                                break;
-                        }
-
-                        spin_lock_irqsave(&phba->hbalock, iflags);
-                        cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
-                                                         &rspiocbq);
-                        spin_unlock_irqrestore(&phba->hbalock, iflags);
-                        if ((cmdiocbq) && (cmdiocbq->iocb_cmpl)) {
-                                (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
-                                                      &rspiocbq);
-                        }
-                        break;
-                default:
-                        if (irsp->ulpCommand == CMD_ADAPTER_MSG) {
-                                char adaptermsg[LPFC_MAX_ADPTMSG];
-                                memset(adaptermsg, 0, LPFC_MAX_ADPTMSG);
-                                memcpy(&adaptermsg[0], (uint8_t *) irsp,
-                                       MAX_MSG_DATA);
-                                dev_warn(&((phba->pcidev)->dev),
-                                         "lpfc%d: %s\n",
-                                         phba->brd_no, adaptermsg);
-                        } else {
-                                /* Unknown IOCB command */
-                                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
-                                                "0321 Unknown IOCB command "
-                                                "Data: x%x, x%x x%x x%x x%x\n",
-                                                type, irsp->ulpCommand,
-                                                irsp->ulpStatus,
-                                                irsp->ulpIoTag,
-                                                irsp->ulpContext);
-                        }
-                        break;
-                }
-
-                /*
-                 * The response IOCB has been processed.  Update the ring
-                 * pointer in SLIM.  If the port response put pointer has not
-                 * been updated, sync the pgp->rspPutInx and fetch the new port
-                 * response put pointer.
-                 */
-                writel(pring->rspidx, &phba->host_gp[pring->ringno].rspGetInx);
-
-                if (pring->rspidx == portRspPut)
-                        portRspPut = le32_to_cpu(pgp->rspPutInx);
-        }
-
-        ha_copy = readl(phba->HAregaddr);
-        ha_copy >>= (LPFC_FCP_RING * 4);
-
-        if ((rsp_cmpl > 0) && (ha_copy & HA_R0RE_REQ)) {
-                spin_lock_irqsave(&phba->hbalock, iflags);
-                pring->stats.iocb_rsp_full++;
-                status = ((CA_R0ATT | CA_R0RE_RSP) << (LPFC_FCP_RING * 4));
-                writel(status, phba->CAregaddr);
-                readl(phba->CAregaddr);
-                spin_unlock_irqrestore(&phba->hbalock, iflags);
-        }
-        if ((ha_copy & HA_R0CE_RSP) &&
-            (pring->flag & LPFC_CALL_RING_AVAILABLE)) {
-                spin_lock_irqsave(&phba->hbalock, iflags);
-                pring->flag &= ~LPFC_CALL_RING_AVAILABLE;
-                pring->stats.iocb_cmd_empty++;
-
-                /* Force update of the local copy of cmdGetInx */
-                pring->local_getidx = le32_to_cpu(pgp->cmdGetInx);
-                lpfc_sli_resume_iocb(phba, pring);
-
-                if ((pring->lpfc_sli_cmd_available))
-                        (pring->lpfc_sli_cmd_available) (phba, pring);
-
-                spin_unlock_irqrestore(&phba->hbalock, iflags);
-        }
-
-        return;
-}
 
 /**
  * lpfc_sli_handle_fast_ring_event - Handle ring events on FCP ring
@@ -2502,9 +2429,9 @@ void lpfc_sli_poll_fcp_ring(struct lpfc_hba *phba)
  * an abort completion. The function will call lpfc_sli_process_unsol_iocb
  * function if this is an unsolicited iocb.
  * This routine presumes LPFC_FCP_RING handling and doesn't bother
- * to check it explicitly. This function always returns 1.
- **/
-static int
+ * to check it explicitly.
+ */
+int
 lpfc_sli_handle_fast_ring_event(struct lpfc_hba *phba,
                                 struct lpfc_sli_ring *pring, uint32_t mask)
 {
@@ -2534,6 +2461,11 @@ lpfc_sli_handle_fast_ring_event(struct lpfc_hba *phba,
                 spin_unlock_irqrestore(&phba->hbalock, iflag);
                 return 1;
         }
+        if (phba->fcp_ring_in_use) {
+                spin_unlock_irqrestore(&phba->hbalock, iflag);
+                return 1;
+        } else
+                phba->fcp_ring_in_use = 1;
 
         rmb();
         while (pring->rspidx != portRspPut) {
@@ -2603,18 +2535,15 @@ lpfc_sli_handle_fast_ring_event(struct lpfc_hba *phba,
 
                         cmdiocbq = lpfc_sli_iocbq_lookup(phba, pring,
                                                          &rspiocbq);
-                        if ((cmdiocbq) && (cmdiocbq->iocb_cmpl)) {
-                                if (phba->cfg_poll & ENABLE_FCP_RING_POLLING) {
-                                        (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
-                                                              &rspiocbq);
-                                } else {
-                                        spin_unlock_irqrestore(&phba->hbalock,
-                                                               iflag);
-                                        (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
-                                                              &rspiocbq);
-                                        spin_lock_irqsave(&phba->hbalock,
-                                                          iflag);
-                                }
+                        if (unlikely(!cmdiocbq))
+                                break;
+                        if (cmdiocbq->iocb_flag & LPFC_DRIVER_ABORTED)
+                                cmdiocbq->iocb_flag &= ~LPFC_DRIVER_ABORTED;
+                        if (cmdiocbq->iocb_cmpl) {
+                                spin_unlock_irqrestore(&phba->hbalock, iflag);
+                                (cmdiocbq->iocb_cmpl)(phba, cmdiocbq,
+                                                      &rspiocbq);
+                                spin_lock_irqsave(&phba->hbalock, iflag);
                         }
                         break;
                 case LPFC_UNSOL_IOCB:
@@ -2675,6 +2604,7 @@ lpfc_sli_handle_fast_ring_event(struct lpfc_hba *phba,
 
         }
 
+        phba->fcp_ring_in_use = 0;
         spin_unlock_irqrestore(&phba->hbalock, iflag);
         return rc;
 }
@@ -3018,16 +2948,39 @@ lpfc_sli_handle_slow_ring_event_s4(struct lpfc_hba *phba,
                                    struct lpfc_sli_ring *pring, uint32_t mask)
 {
         struct lpfc_iocbq *irspiocbq;
+        struct hbq_dmabuf *dmabuf;
+        struct lpfc_cq_event *cq_event;
         unsigned long iflag;
 
-        while (!list_empty(&phba->sli4_hba.sp_rspiocb_work_queue)) {
+        spin_lock_irqsave(&phba->hbalock, iflag);
+        phba->hba_flag &= ~HBA_SP_QUEUE_EVT;
+        spin_unlock_irqrestore(&phba->hbalock, iflag);
+        while (!list_empty(&phba->sli4_hba.sp_queue_event)) {
                 /* Get the response iocb from the head of work queue */
                 spin_lock_irqsave(&phba->hbalock, iflag);
-                list_remove_head(&phba->sli4_hba.sp_rspiocb_work_queue,
-                                 irspiocbq, struct lpfc_iocbq, list);
+                list_remove_head(&phba->sli4_hba.sp_queue_event,
+                                 cq_event, struct lpfc_cq_event, list);
                 spin_unlock_irqrestore(&phba->hbalock, iflag);
-                /* Process the response iocb */
-                lpfc_sli_sp_handle_rspiocb(phba, pring, irspiocbq);
+
+                switch (bf_get(lpfc_wcqe_c_code, &cq_event->cqe.wcqe_cmpl)) {
+                case CQE_CODE_COMPL_WQE:
+                        irspiocbq = container_of(cq_event, struct lpfc_iocbq,
+                                                 cq_event);
+                        /* Translate ELS WCQE to response IOCBQ */
+                        irspiocbq = lpfc_sli4_els_wcqe_to_rspiocbq(phba,
+                                                                   irspiocbq);
+                        if (irspiocbq)
+                                lpfc_sli_sp_handle_rspiocb(phba, pring,
+                                                           irspiocbq);
+                        break;
+                case CQE_CODE_RECEIVE:
+                        dmabuf = container_of(cq_event, struct hbq_dmabuf,
+                                              cq_event);
+                        lpfc_sli4_handle_received_buffer(phba, dmabuf);
+                        break;
+                default:
+                        break;
+                }
         }
 }
 
@@ -3160,6 +3113,12 @@ lpfc_sli_brdready_s3(struct lpfc_hba *phba, uint32_t mask)
 
         /* Check to see if any errors occurred during init */
         if ((status & HS_FFERM) || (i >= 20)) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "2751 Adapter failed to restart, "
+                                "status reg x%x, FW Data: A8 x%x AC x%x\n",
+                                status,
+                                readl(phba->MBslimaddr + 0xa8),
+                                readl(phba->MBslimaddr + 0xac));
                 phba->link_state = LPFC_HBA_ERROR;
                 retval = 1;
         }
@@ -3347,6 +3306,9 @@ lpfc_sli_brdkill(struct lpfc_hba *phba)
         if (retval != MBX_SUCCESS) {
                 if (retval != MBX_BUSY)
                         mempool_free(pmb, phba->mbox_mem_pool);
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "2752 KILL_BOARD command failed retval %d\n",
+                                retval);
                 spin_lock_irq(&phba->hbalock);
                 phba->link_flag &= ~LS_IGNORE_ERATT;
                 spin_unlock_irq(&phba->hbalock);
@@ -3416,6 +3378,7 @@ lpfc_sli_brdreset(struct lpfc_hba *phba)
 
         /* perform board reset */
         phba->fc_eventTag = 0;
+        phba->link_events = 0;
         phba->pport->fc_myDID = 0;
         phba->pport->fc_prevDID = 0;
 
@@ -3476,6 +3439,7 @@ lpfc_sli4_brdreset(struct lpfc_hba *phba)
 
         /* perform board reset */
         phba->fc_eventTag = 0;
+        phba->link_events = 0;
         phba->pport->fc_myDID = 0;
         phba->pport->fc_prevDID = 0;
 
@@ -3495,7 +3459,6 @@ lpfc_sli4_brdreset(struct lpfc_hba *phba)
         list_del_init(&phba->sli4_hba.dat_rq->list);
         list_del_init(&phba->sli4_hba.mbx_cq->list);
         list_del_init(&phba->sli4_hba.els_cq->list);
-        list_del_init(&phba->sli4_hba.rxq_cq->list);
         for (qindx = 0; qindx < phba->cfg_fcp_wq_count; qindx++)
                 list_del_init(&phba->sli4_hba.fcp_wq[qindx]->list);
         for (qindx = 0; qindx < phba->cfg_fcp_eq_count; qindx++)
@@ -3531,9 +3494,13 @@ lpfc_sli_brdrestart_s3(struct lpfc_hba *phba)
         struct lpfc_sli *psli;
         volatile uint32_t word0;
         void __iomem *to_slim;
+        uint32_t hba_aer_enabled;
 
         spin_lock_irq(&phba->hbalock);
 
+        /* Take PCIe device Advanced Error Reporting (AER) state */
+        hba_aer_enabled = phba->hba_flag & HBA_AER_ENABLED;
+
         psli = &phba->sli;
 
         /* Restart HBA */
@@ -3573,6 +3540,10 @@ lpfc_sli_brdrestart_s3(struct lpfc_hba *phba)
         /* Give the INITFF and Post time to settle. */
         mdelay(100);
 
+        /* Reset HBA AER if it was enabled, note hba_flag was reset above */
+        if (hba_aer_enabled)
+                pci_disable_pcie_error_reporting(phba->pcidev);
+
         lpfc_hba_down_post(phba);
 
         return 0;
@@ -4042,6 +4013,24 @@ lpfc_sli_hba_setup(struct lpfc_hba *phba)
         if (rc)
                 goto lpfc_sli_hba_setup_error;
 
+        /* Enable PCIe device Advanced Error Reporting (AER) if configured */
+        if (phba->cfg_aer_support == 1 && !(phba->hba_flag & HBA_AER_ENABLED)) {
+                rc = pci_enable_pcie_error_reporting(phba->pcidev);
+                if (!rc) {
+                        lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+                                        "2709 This device supports "
+                                        "Advanced Error Reporting (AER)\n");
+                        spin_lock_irq(&phba->hbalock);
+                        phba->hba_flag |= HBA_AER_ENABLED;
+                        spin_unlock_irq(&phba->hbalock);
+                } else {
+                        lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+                                        "2708 This device does not support "
+                                        "Advanced Error Reporting (AER)\n");
+                        phba->cfg_aer_support = 0;
+                }
+        }
+
         if (phba->sli_rev == 3) {
                 phba->iocb_cmd_size = SLI3_IOCB_CMD_SIZE;
                 phba->iocb_rsp_size = SLI3_IOCB_RSP_SIZE;
@@ -4077,7 +4066,7 @@ lpfc_sli_hba_setup(struct lpfc_hba *phba)
 
 lpfc_sli_hba_setup_error:
         phba->link_state = LPFC_HBA_ERROR;
-        lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                         "0445 Firmware initialization failed\n");
         return rc;
 }
@@ -4163,7 +4152,7 @@ lpfc_sli4_read_fcoe_params(struct lpfc_hba *phba,
  * addition, this routine gets the port vpd data.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      ENOMEM - could not allocated memory.
  **/
 static int
@@ -4211,6 +4200,7 @@ lpfc_sli4_read_rev(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq,
         if (rc) {
                 dma_free_coherent(&phba->pcidev->dev, dma_size,
                                   dmabuf->virt, dmabuf->phys);
+                kfree(dmabuf);
                 return -EIO;
         }
 
@@ -4243,7 +4233,6 @@ lpfc_sli4_arm_cqeq_intr(struct lpfc_hba *phba)
 
         lpfc_sli4_cq_release(phba->sli4_hba.mbx_cq, LPFC_QUEUE_REARM);
         lpfc_sli4_cq_release(phba->sli4_hba.els_cq, LPFC_QUEUE_REARM);
-        lpfc_sli4_cq_release(phba->sli4_hba.rxq_cq, LPFC_QUEUE_REARM);
         for (fcp_eqidx = 0; fcp_eqidx < phba->cfg_fcp_eq_count; fcp_eqidx++)
                 lpfc_sli4_cq_release(phba->sli4_hba.fcp_cq[fcp_eqidx],
                                      LPFC_QUEUE_REARM);
@@ -4322,6 +4311,13 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         phba->sli_rev = bf_get(lpfc_mbx_rd_rev_sli_lvl, &mqe->un.read_rev);
         if (bf_get(lpfc_mbx_rd_rev_fcoe, &mqe->un.read_rev))
                 phba->hba_flag |= HBA_FCOE_SUPPORT;
+
+        if (bf_get(lpfc_mbx_rd_rev_cee_ver, &mqe->un.read_rev) ==
+                LPFC_DCBX_CEE_MODE)
+                phba->hba_flag |= HBA_FIP_SUPPORT;
+        else
+                phba->hba_flag &= ~HBA_FIP_SUPPORT;
+
         if (phba->sli_rev != LPFC_SLI_REV4 ||
             !(phba->hba_flag & HBA_FCOE_SUPPORT)) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
@@ -4423,7 +4419,13 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         spin_unlock_irq(&phba->hbalock);
 
         /* Read the port's service parameters. */
-        lpfc_read_sparam(phba, mboxq, vport->vpi);
+        rc = lpfc_read_sparam(phba, mboxq, vport->vpi);
+        if (rc) {
+                phba->link_state = LPFC_HBA_ERROR;
+                rc = -ENOMEM;
+                goto out_free_vpd;
+        }
+
         mboxq->vport = vport;
         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
         mp = (struct lpfc_dmabuf *) mboxq->context1;
@@ -4468,7 +4470,8 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         rc = lpfc_sli4_post_sgl_list(phba);
         if (unlikely(rc)) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
-                                "0582 Error %d during sgl post operation", rc);
+                                "0582 Error %d during sgl post operation\n",
+                                        rc);
                 rc = -ENODEV;
                 goto out_free_vpd;
         }
@@ -4477,8 +4480,8 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         rc = lpfc_sli4_repost_scsi_sgl_list(phba);
         if (unlikely(rc)) {
                 lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX | LOG_SLI,
-                                "0383 Error %d during scsi sgl post opeation",
-                                rc);
+                                "0383 Error %d during scsi sgl post "
+                                "operation\n", rc);
                 /* Some Scsi buffers were moved to the abort scsi list */
                 /* A pci function reset will repost them */
                 rc = -ENODEV;
@@ -4494,10 +4497,6 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
                 rc = -ENODEV;
                 goto out_free_vpd;
         }
-        if (phba->cfg_enable_fip)
-                bf_set(lpfc_fip_flag, &phba->sli4_hba.sli4_flags, 1);
-        else
-                bf_set(lpfc_fip_flag, &phba->sli4_hba.sli4_flags, 0);
 
         /* Set up all the queues to the device */
         rc = lpfc_sli4_queue_setup(phba);
@@ -4521,6 +4520,10 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         /* Post receive buffers to the device */
         lpfc_sli4_rb_setup(phba);
 
+        /* Reset HBA FCF states after HBA reset */
+        phba->fcf.fcf_flag = 0;
+        phba->fcf.current_rec.flag = 0;
+
         /* Start the ELS watchdog timer */
         mod_timer(&vport->els_tmofunc,
                   jiffies + HZ * (phba->fc_ratov * 2));
@@ -5669,7 +5672,7 @@ __lpfc_sli_issue_iocb_s3(struct lpfc_hba *phba, uint32_t ring_number,
                 case CMD_GEN_REQUEST64_CX:
                         if (!(phba->sli.sli_flag & LPFC_MENLO_MAINT) ||
                                 (piocb->iocb.un.genreq64.w5.hcsw.Rctl !=
-                                        FC_FCP_CMND) ||
+                                        FC_RCTL_DD_UNSOL_CMD) ||
                                 (piocb->iocb.un.genreq64.w5.hcsw.Type !=
                                         MENLO_TRANSPORT_TYPE))
 
@@ -5777,19 +5780,19 @@ lpfc_sli4_bpl2sgl(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
 
                 for (i = 0; i < numBdes; i++) {
                         /* Should already be byte swapped. */
-                        sgl->addr_hi =  bpl->addrHigh;
-                        sgl->addr_lo =  bpl->addrLow;
-                        /* swap the size field back to the cpu so we
-                         * can assign it to the sgl.
-                         */
-                        bde.tus.w  = le32_to_cpu(bpl->tus.w);
-                        bf_set(lpfc_sli4_sge_len, sgl, bde.tus.f.bdeSize);
+                        sgl->addr_hi = bpl->addrHigh;
+                        sgl->addr_lo = bpl->addrLow;
+
                         if ((i+1) == numBdes)
                                 bf_set(lpfc_sli4_sge_last, sgl, 1);
                         else
                                 bf_set(lpfc_sli4_sge_last, sgl, 0);
                         sgl->word2 = cpu_to_le32(sgl->word2);
-                        sgl->word3 = cpu_to_le32(sgl->word3);
+                        /* swap the size field back to the cpu so we
+                         * can assign it to the sgl.
+                         */
+                        bde.tus.w = le32_to_cpu(bpl->tus.w);
+                        sgl->sge_len = cpu_to_le32(bde.tus.f.bdeSize);
                         bpl++;
                         sgl++;
                 }
@@ -5802,11 +5805,10 @@ lpfc_sli4_bpl2sgl(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
                                 cpu_to_le32(icmd->un.genreq64.bdl.addrHigh);
                         sgl->addr_lo =
                                 cpu_to_le32(icmd->un.genreq64.bdl.addrLow);
-                        bf_set(lpfc_sli4_sge_len, sgl,
-                                icmd->un.genreq64.bdl.bdeSize);
                         bf_set(lpfc_sli4_sge_last, sgl, 1);
                         sgl->word2 = cpu_to_le32(sgl->word2);
-                        sgl->word3 = cpu_to_le32(sgl->word3);
+                        sgl->sge_len =
+                                cpu_to_le32(icmd->un.genreq64.bdl.bdeSize);
         }
         return sglq->sli4_xritag;
 }
@@ -5849,7 +5851,7 @@ static int
 lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 union lpfc_wqe *wqe)
 {
-        uint32_t payload_len = 0;
+        uint32_t xmit_len = 0, total_len = 0;
         uint8_t ct = 0;
         uint32_t fip;
         uint32_t abort_tag;
@@ -5857,12 +5859,15 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
         uint8_t cmnd;
         uint16_t xritag;
         struct ulp_bde64 *bpl = NULL;
+        uint32_t els_id = ELS_ID_DEFAULT;
+        int numBdes, i;
+        struct ulp_bde64 bde;
 
-        fip = bf_get(lpfc_fip_flag, &phba->sli4_hba.sli4_flags);
+        fip = phba->hba_flag & HBA_FIP_SUPPORT;
         /* The fcp commands will set command type */
         if (iocbq->iocb_flag &  LPFC_IO_FCP)
                 command_type = FCP_COMMAND;
-        else if (fip && (iocbq->iocb_flag & LPFC_FIP_ELS))
+        else if (fip && (iocbq->iocb_flag & LPFC_FIP_ELS_ID_MASK))
                 command_type = ELS_COMMAND_FIP;
         else
                 command_type = ELS_COMMAND_NON_FIP;
@@ -5874,6 +5879,8 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
         wqe->words[7] = 0; /* The ct field has moved so reset */
         /* words0-2 bpl convert bde */
         if (iocbq->iocb.un.genreq64.bdl.bdeFlags == BUFF_TYPE_BLP_64) {
+                numBdes = iocbq->iocb.un.genreq64.bdl.bdeSize /
+                                sizeof(struct ulp_bde64);
                 bpl  = (struct ulp_bde64 *)
                         ((struct lpfc_dmabuf *)iocbq->context3)->virt;
                 if (!bpl)
@@ -5886,9 +5893,14 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                  * can assign it to the sgl.
                  */
                 wqe->generic.bde.tus.w  = le32_to_cpu(bpl->tus.w);
-                payload_len = wqe->generic.bde.tus.f.bdeSize;
+                xmit_len = wqe->generic.bde.tus.f.bdeSize;
+                total_len = 0;
+                for (i = 0; i < numBdes; i++) {
+                        bde.tus.w  = le32_to_cpu(bpl[i].tus.w);
+                        total_len += bde.tus.f.bdeSize;
+                }
         } else
-                payload_len = iocbq->iocb.un.fcpi64.bdl.bdeSize;
+                xmit_len = iocbq->iocb.un.fcpi64.bdl.bdeSize;
 
         iocbq->iocb.ulpIoTag = iocbq->iotag;
         cmnd = iocbq->iocb.ulpCommand;
@@ -5902,7 +5914,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                                 iocbq->iocb.ulpCommand);
                         return IOCB_ERROR;
                 }
-                wqe->els_req.payload_len = payload_len;
+                wqe->els_req.payload_len = xmit_len;
                 /* Els_reguest64 has a TMO */
                 bf_set(wqe_tmo, &wqe->els_req.wqe_com,
                         iocbq->iocb.ulpTimeout);
@@ -5923,7 +5935,22 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(lpfc_wqe_gen_ct, &wqe->generic, ct);
                 bf_set(lpfc_wqe_gen_pu, &wqe->generic, 0);
                 /* CCP CCPE PV PRI in word10 were set in the memcpy */
+
+                if (command_type == ELS_COMMAND_FIP) {
+                        els_id = ((iocbq->iocb_flag & LPFC_FIP_ELS_ID_MASK)
+                                        >> LPFC_FIP_ELS_ID_SHIFT);
+                }
+                bf_set(lpfc_wqe_gen_els_id, &wqe->generic, els_id);
+
         break;
+        case CMD_XMIT_SEQUENCE64_CX:
+                bf_set(lpfc_wqe_gen_context, &wqe->generic,
+                                        iocbq->iocb.un.ulpWord[3]);
+                wqe->generic.word3 = 0;
+                bf_set(wqe_rcvoxid, &wqe->generic, iocbq->iocb.ulpContext);
+                /* The entire sequence is transmitted for this IOCB */
+                xmit_len = total_len;
+                cmnd = CMD_XMIT_SEQUENCE64_CR;
         case CMD_XMIT_SEQUENCE64_CR:
                 /* word3 iocb=io_tag32 wqe=payload_offset */
                 /* payload offset used for multilpe outstanding
@@ -5933,7 +5960,8 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 /* word4 relative_offset memcpy */
                 /* word5 r_ctl/df_ctl memcpy */
                 bf_set(lpfc_wqe_gen_pu, &wqe->generic, 0);
-                wqe->xmit_sequence.xmit_len = payload_len;
+                wqe->xmit_sequence.xmit_len = xmit_len;
+                command_type = OTHER_COMMAND;
         break;
         case CMD_XMIT_BCAST64_CN:
                 /* word3 iocb=iotag32 wqe=payload_len */
@@ -5962,7 +5990,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
         case CMD_FCP_IREAD64_CR:
                 /* FCP_CMD is always the 1st sgl entry */
                 wqe->fcp_iread.payload_len =
-                        payload_len + sizeof(struct fcp_rsp);
+                        xmit_len + sizeof(struct fcp_rsp);
 
                 /* word 4 (xfer length) should have been set on the memcpy */
 
@@ -5999,7 +6027,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                  * sgl[1] = rsp.
                  *
                  */
-                wqe->gen_req.command_len = payload_len;
+                wqe->gen_req.command_len = xmit_len;
                 /* Word4 parameter  copied in the memcpy */
                 /* Word5 [rctl, type, df_ctl, la] copied in memcpy */
                 /* word6 context tag copied in memcpy */
@@ -6051,12 +6079,10 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 else
                         bf_set(abort_cmd_ia, &wqe->abort_cmd, 0);
                 bf_set(abort_cmd_criteria, &wqe->abort_cmd, T_XRI_TAG);
-                abort_tag = iocbq->iocb.un.acxri.abortIoTag;
                 wqe->words[5] = 0;
                 bf_set(lpfc_wqe_gen_ct, &wqe->generic,
                         ((iocbq->iocb.ulpCt_h << 1) | iocbq->iocb.ulpCt_l));
                 abort_tag = iocbq->iocb.un.acxri.abortIoTag;
-                wqe->generic.abort_tag = abort_tag;
                 /*
                  * The abort handler will send us CMD_ABORT_XRI_CN or
                  * CMD_CLOSE_XRI_CN and the fw only accepts CMD_ABORT_XRI_CX
@@ -6066,6 +6092,38 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 command_type = OTHER_COMMAND;
                 xritag = 0;
         break;
+        case CMD_XMIT_BLS_RSP64_CX:
+                /* As BLS ABTS-ACC WQE is very different from other WQEs,
+                 * we re-construct this WQE here based on information in
+                 * iocbq from scratch.
+                 */
+                memset(wqe, 0, sizeof(union lpfc_wqe));
+                /* OX_ID is invariable to who sent ABTS to CT exchange */
+                bf_set(xmit_bls_rsp64_oxid, &wqe->xmit_bls_rsp,
+                       bf_get(lpfc_abts_oxid, &iocbq->iocb.un.bls_acc));
+                if (bf_get(lpfc_abts_orig, &iocbq->iocb.un.bls_acc) ==
+                    LPFC_ABTS_UNSOL_INT) {
+                        /* ABTS sent by initiator to CT exchange, the
+                         * RX_ID field will be filled with the newly
+                         * allocated responder XRI.
+                         */
+                        bf_set(xmit_bls_rsp64_rxid, &wqe->xmit_bls_rsp,
+                               iocbq->sli4_xritag);
+                } else {
+                        /* ABTS sent by responder to CT exchange, the
+                         * RX_ID field will be filled with the responder
+                         * RX_ID from ABTS.
+                         */
+                        bf_set(xmit_bls_rsp64_rxid, &wqe->xmit_bls_rsp,
+                               bf_get(lpfc_abts_rxid, &iocbq->iocb.un.bls_acc));
+                }
+                bf_set(xmit_bls_rsp64_seqcnthi, &wqe->xmit_bls_rsp, 0xffff);
+                bf_set(wqe_xmit_bls_pt, &wqe->xmit_bls_rsp.wqe_dest, 0x1);
+                bf_set(wqe_ctxt_tag, &wqe->xmit_bls_rsp.wqe_com,
+                       iocbq->iocb.ulpContext);
+                /* Overwrite the pre-set comnd type with OTHER_COMMAND */
+                command_type = OTHER_COMMAND;
+        break;
         case CMD_XRI_ABORTED_CX:
         case CMD_CREATE_XRI_CR: /* Do we expect to use this? */
                 /* words0-2 are all 0's no bde */
@@ -6120,11 +6178,10 @@ __lpfc_sli_issue_iocb_s4(struct lpfc_hba *phba, uint32_t ring_number,
         uint16_t xritag;
         union lpfc_wqe wqe;
         struct lpfc_sli_ring *pring = &phba->sli.ring[ring_number];
-        uint32_t fcp_wqidx;
 
         if (piocb->sli4_xritag == NO_XRI) {
                 if (piocb->iocb.ulpCommand == CMD_ABORT_XRI_CN ||
-                        piocb->iocb.ulpCommand == CMD_CLOSE_XRI_CN)
+                    piocb->iocb.ulpCommand == CMD_CLOSE_XRI_CN)
                         sglq = NULL;
                 else {
                         sglq = __lpfc_sli_get_sglq(phba);
@@ -6154,9 +6211,18 @@ __lpfc_sli_issue_iocb_s4(struct lpfc_hba *phba, uint32_t ring_number,
         if (lpfc_sli4_iocb2wqe(phba, piocb, &wqe))
                 return IOCB_ERROR;
 
-        if (piocb->iocb_flag &  LPFC_IO_FCP) {
-                fcp_wqidx = lpfc_sli4_scmd_to_wqidx_distr(phba);
-                if (lpfc_sli4_wq_put(phba->sli4_hba.fcp_wq[fcp_wqidx], &wqe))
+        if ((piocb->iocb_flag & LPFC_IO_FCP) ||
+                (piocb->iocb_flag & LPFC_USE_FCPWQIDX)) {
+                /*
+                 * For FCP command IOCB, get a new WQ index to distribute
+                 * WQE across the WQsr. On the other hand, for abort IOCB,
+                 * it carries the same WQ index to the original command
+                 * IOCB.
+                 */
+                if (piocb->iocb_flag & LPFC_IO_FCP)
+                        piocb->fcp_wqidx = lpfc_sli4_scmd_to_wqidx_distr(phba);
+                if (lpfc_sli4_wq_put(phba->sli4_hba.fcp_wq[piocb->fcp_wqidx],
+                                     &wqe))
                         return IOCB_ERROR;
         } else {
                 if (lpfc_sli4_wq_put(phba->sli4_hba.els_wq, &wqe))
@@ -6449,31 +6515,37 @@ lpfc_sli_setup(struct lpfc_hba *phba)
                         pring->iotag_max = 4096;
                         pring->lpfc_sli_rcv_async_status =
                                 lpfc_sli_async_event_handler;
-                        pring->num_mask = 4;
+                        pring->num_mask = LPFC_MAX_RING_MASK;
                         pring->prt[0].profile = 0;      /* Mask 0 */
-                        pring->prt[0].rctl = FC_ELS_REQ;
-                        pring->prt[0].type = FC_ELS_DATA;
+                        pring->prt[0].rctl = FC_RCTL_ELS_REQ;
+                        pring->prt[0].type = FC_TYPE_ELS;
                         pring->prt[0].lpfc_sli_rcv_unsol_event =
                             lpfc_els_unsol_event;
                         pring->prt[1].profile = 0;      /* Mask 1 */
-                        pring->prt[1].rctl = FC_ELS_RSP;
-                        pring->prt[1].type = FC_ELS_DATA;
+                        pring->prt[1].rctl = FC_RCTL_ELS_REP;
+                        pring->prt[1].type = FC_TYPE_ELS;
                         pring->prt[1].lpfc_sli_rcv_unsol_event =
                             lpfc_els_unsol_event;
                         pring->prt[2].profile = 0;      /* Mask 2 */
                         /* NameServer Inquiry */
-                        pring->prt[2].rctl = FC_UNSOL_CTL;
+                        pring->prt[2].rctl = FC_RCTL_DD_UNSOL_CTL;
                         /* NameServer */
-                        pring->prt[2].type = FC_COMMON_TRANSPORT_ULP;
+                        pring->prt[2].type = FC_TYPE_CT;
                         pring->prt[2].lpfc_sli_rcv_unsol_event =
                             lpfc_ct_unsol_event;
                         pring->prt[3].profile = 0;      /* Mask 3 */
                         /* NameServer response */
-                        pring->prt[3].rctl = FC_SOL_CTL;
+                        pring->prt[3].rctl = FC_RCTL_DD_SOL_CTL;
                         /* NameServer */
-                        pring->prt[3].type = FC_COMMON_TRANSPORT_ULP;
+                        pring->prt[3].type = FC_TYPE_CT;
                         pring->prt[3].lpfc_sli_rcv_unsol_event =
                             lpfc_ct_unsol_event;
+                        /* abort unsolicited sequence */
+                        pring->prt[4].profile = 0;      /* Mask 4 */
+                        pring->prt[4].rctl = FC_RCTL_BA_ABTS;
+                        pring->prt[4].type = FC_TYPE_BLS;
+                        pring->prt[4].lpfc_sli_rcv_unsol_event =
+                            lpfc_sli4_ct_abort_unsol_event;
                         break;
                 }
                 totiocbsize += (pring->numCiocb * pring->sizeCiocb) +
@@ -6976,8 +7048,18 @@ lpfc_sli_abort_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                 abort_iotag = cmdiocb->iocb.un.acxri.abortIoTag;
 
                 spin_lock_irq(&phba->hbalock);
-                if (abort_iotag != 0 && abort_iotag <= phba->sli.last_iotag)
-                        abort_iocb = phba->sli.iocbq_lookup[abort_iotag];
+                if (phba->sli_rev < LPFC_SLI_REV4) {
+                        if (abort_iotag != 0 &&
+                                abort_iotag <= phba->sli.last_iotag)
+                                abort_iocb =
+                                        phba->sli.iocbq_lookup[abort_iotag];
+                } else
+                        /* For sli4 the abort_tag is the XRI,
+                         * so the abort routine puts the iotag  of the iocb
+                         * being aborted in the context field of the abort
+                         * IOCB.
+                         */
+                        abort_iocb = phba->sli.iocbq_lookup[abort_context];
 
                 lpfc_printf_log(phba, KERN_INFO, LOG_ELS | LOG_SLI,
                                 "0327 Cannot abort els iocb %p "
@@ -6991,9 +7073,18 @@ lpfc_sli_abort_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                  *  might have completed already. Do not free it again.
                  */
                 if (irsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
-                        spin_unlock_irq(&phba->hbalock);
-                        lpfc_sli_release_iocbq(phba, cmdiocb);
-                        return;
+                        if (irsp->un.ulpWord[4] != IOERR_NO_XRI) {
+                                spin_unlock_irq(&phba->hbalock);
+                                lpfc_sli_release_iocbq(phba, cmdiocb);
+                                return;
+                        }
+                        /* For SLI4 the ulpContext field for abort IOCB
+                         * holds the iotag of the IOCB being aborted so
+                         * the local abort_context needs to be reset to
+                         * match the aborted IOCBs ulpContext.
+                         */
+                        if (abort_iocb && phba->sli_rev == LPFC_SLI_REV4)
+                                abort_context = abort_iocb->iocb.ulpContext;
                 }
                 /*
                  * make sure we have the right iocbq before taking it
@@ -7003,7 +7094,14 @@ lpfc_sli_abort_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                     abort_iocb->iocb.ulpContext != abort_context ||
                     (abort_iocb->iocb_flag & LPFC_DRIVER_ABORTED) == 0)
                         spin_unlock_irq(&phba->hbalock);
-                else {
+                else if (phba->sli_rev < LPFC_SLI_REV4) {
+                        /*
+                         * leave the SLI4 aborted command on the txcmplq
+                         * list and the command complete WCQE's XB bit
+                         * will tell whether the SGL (XRI) can be released
+                         * immediately or to the aborted SGL list for the
+                         * following abort XRI from the HBA.
+                         */
                         list_del_init(&abort_iocb->list);
                         pring->txcmplq_cnt--;
                         spin_unlock_irq(&phba->hbalock);
@@ -7012,11 +7110,13 @@ lpfc_sli_abort_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                          * payload, so don't free data buffer till after
                          * a hbeat.
                          */
+                        spin_lock_irq(&phba->hbalock);
                         abort_iocb->iocb_flag |= LPFC_DELAY_MEM_FREE;
-
                         abort_iocb->iocb_flag &= ~LPFC_DRIVER_ABORTED;
+                        spin_unlock_irq(&phba->hbalock);
+
                         abort_iocb->iocb.ulpStatus = IOSTAT_LOCAL_REJECT;
-                        abort_iocb->iocb.un.ulpWord[4] = IOERR_SLI_ABORTED;
+                        abort_iocb->iocb.un.ulpWord[4] = IOERR_ABORT_REQUESTED;
                         (abort_iocb->iocb_cmpl)(phba, abort_iocb, abort_iocb);
                 }
         }
@@ -7105,20 +7205,27 @@ lpfc_sli_issue_abort_iotag(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                 return 0;
 
         /* This signals the response to set the correct status
-         * before calling the completion handler.
+         * before calling the completion handler
          */
         cmdiocb->iocb_flag |= LPFC_DRIVER_ABORTED;
 
         iabt = &abtsiocbp->iocb;
         iabt->un.acxri.abortType = ABORT_TYPE_ABTS;
         iabt->un.acxri.abortContextTag = icmd->ulpContext;
-        if (phba->sli_rev == LPFC_SLI_REV4)
+        if (phba->sli_rev == LPFC_SLI_REV4) {
                 iabt->un.acxri.abortIoTag = cmdiocb->sli4_xritag;
+                iabt->un.acxri.abortContextTag = cmdiocb->iotag;
+        }
         else
                 iabt->un.acxri.abortIoTag = icmd->ulpIoTag;
         iabt->ulpLe = 1;
         iabt->ulpClass = icmd->ulpClass;
 
+        /* ABTS WQE must go to the same WQ as the WQE to be aborted */
+        abtsiocbp->fcp_wqidx = cmdiocb->fcp_wqidx;
+        if (cmdiocb->iocb_flag & LPFC_IO_FCP)
+                abtsiocbp->iocb_flag |= LPFC_USE_FCPWQIDX;
+
         if (phba->link_state >= LPFC_LINK_UP)
                 iabt->ulpCommand = CMD_ABORT_XRI_CN;
         else
@@ -7322,6 +7429,11 @@ lpfc_sli_abort_iocb(struct lpfc_vport *vport, struct lpfc_sli_ring *pring,
                 abtsiocb->iocb.ulpClass = cmd->ulpClass;
                 abtsiocb->vport = phba->pport;
 
+                /* ABTS WQE must go to the same WQ as the WQE to be aborted */
+                abtsiocb->fcp_wqidx = iocbq->fcp_wqidx;
+                if (iocbq->iocb_flag & LPFC_IO_FCP)
+                        abtsiocb->iocb_flag |= LPFC_USE_FCPWQIDX;
+
                 if (lpfc_is_link_up(phba))
                         abtsiocb->iocb.ulpCommand = CMD_ABORT_XRI_CN;
                 else
@@ -7365,6 +7477,7 @@ lpfc_sli_wake_iocb_wait(struct lpfc_hba *phba,
 {
         wait_queue_head_t *pdone_q;
         unsigned long iflags;
+        struct lpfc_scsi_buf *lpfc_cmd;
 
         spin_lock_irqsave(&phba->hbalock, iflags);
         cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
@@ -7372,6 +7485,14 @@ lpfc_sli_wake_iocb_wait(struct lpfc_hba *phba,
                 memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
                        &rspiocbq->iocb, sizeof(IOCB_t));
 
+        /* Set the exchange busy flag for task management commands */
+        if ((cmdiocbq->iocb_flag & LPFC_IO_FCP) &&
+                !(cmdiocbq->iocb_flag & LPFC_IO_LIBDFC)) {
+                lpfc_cmd = container_of(cmdiocbq, struct lpfc_scsi_buf,
+                        cur_iocbq);
+                lpfc_cmd->exch_busy = rspiocbq->iocb_flag & LPFC_EXCHANGE_BUSY;
+        }
+
         pdone_q = cmdiocbq->context_un.wait_queue;
         if (pdone_q)
                 wake_up(pdone_q);
@@ -7687,31 +7808,28 @@ static int
 lpfc_sli4_eratt_read(struct lpfc_hba *phba)
 {
         uint32_t uerr_sta_hi, uerr_sta_lo;
-        uint32_t onlnreg0, onlnreg1;
 
         /* For now, use the SLI4 device internal unrecoverable error
          * registers for error attention. This can be changed later.
          */
-        onlnreg0 = readl(phba->sli4_hba.ONLINE0regaddr);
-        onlnreg1 = readl(phba->sli4_hba.ONLINE1regaddr);
-        if ((onlnreg0 != LPFC_ONLINE_NERR) || (onlnreg1 != LPFC_ONLINE_NERR)) {
-                uerr_sta_lo = readl(phba->sli4_hba.UERRLOregaddr);
-                uerr_sta_hi = readl(phba->sli4_hba.UERRHIregaddr);
-                if (uerr_sta_lo || uerr_sta_hi) {
-                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                        "1423 HBA Unrecoverable error: "
-                                        "uerr_lo_reg=0x%x, uerr_hi_reg=0x%x, "
-                                        "online0_reg=0x%x, online1_reg=0x%x\n",
-                                        uerr_sta_lo, uerr_sta_hi,
-                                        onlnreg0, onlnreg1);
-                        phba->work_status[0] = uerr_sta_lo;
-                        phba->work_status[1] = uerr_sta_hi;
-                        /* Set the driver HA work bitmap */
-                        phba->work_ha |= HA_ERATT;
-                        /* Indicate polling handles this ERATT */
-                        phba->hba_flag |= HBA_ERATT_HANDLED;
-                        return 1;
-                }
+        uerr_sta_lo = readl(phba->sli4_hba.UERRLOregaddr);
+        uerr_sta_hi = readl(phba->sli4_hba.UERRHIregaddr);
+        if ((~phba->sli4_hba.ue_mask_lo & uerr_sta_lo) ||
+            (~phba->sli4_hba.ue_mask_hi & uerr_sta_hi)) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "1423 HBA Unrecoverable error: "
+                                "uerr_lo_reg=0x%x, uerr_hi_reg=0x%x, "
+                                "ue_mask_lo_reg=0x%x, ue_mask_hi_reg=0x%x\n",
+                                uerr_sta_lo, uerr_sta_hi,
+                                phba->sli4_hba.ue_mask_lo,
+                                phba->sli4_hba.ue_mask_hi);
+                phba->work_status[0] = uerr_sta_lo;
+                phba->work_status[1] = uerr_sta_hi;
+                /* Set the driver HA work bitmap */
+                phba->work_ha |= HA_ERATT;
+                /* Indicate polling handles this ERATT */
+                phba->hba_flag |= HBA_ERATT_HANDLED;
+                return 1;
         }
         return 0;
 }
@@ -7834,7 +7952,7 @@ irqreturn_t
 lpfc_sli_sp_intr_handler(int irq, void *dev_id)
 {
         struct lpfc_hba  *phba;
-        uint32_t ha_copy;
+        uint32_t ha_copy, hc_copy;
         uint32_t work_ha_copy;
         unsigned long status;
         unsigned long iflag;
@@ -7892,8 +8010,13 @@ lpfc_sli_sp_intr_handler(int irq, void *dev_id)
                 }
 
                 /* Clear up only attention source related to slow-path */
+                hc_copy = readl(phba->HCregaddr);
+                writel(hc_copy & ~(HC_MBINT_ENA | HC_R2INT_ENA |
+                        HC_LAINT_ENA | HC_ERINT_ENA),
+                        phba->HCregaddr);
                 writel((ha_copy & (HA_MBATT | HA_R2_CLR_MSK)),
                         phba->HAregaddr);
+                writel(hc_copy, phba->HCregaddr);
                 readl(phba->HAregaddr); /* flush */
                 spin_unlock_irqrestore(&phba->hbalock, iflag);
         } else
@@ -8049,7 +8172,7 @@ lpfc_sli_sp_intr_handler(int irq, void *dev_id)
                                                         KERN_ERR,
                                                         LOG_MBOX | LOG_SLI,
                                                         "0350 rc should have"
-                                                        "been MBX_BUSY");
+                                                        "been MBX_BUSY\n");
                                                 if (rc != MBX_NOT_FINISHED)
                                                         goto send_current_mbox;
                                         }
@@ -8078,7 +8201,7 @@ send_current_mbox:
                         if (rc != MBX_SUCCESS)
                                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX |
                                                 LOG_SLI, "0349 rc should be "
-                                                "MBX_SUCCESS");
+                                                "MBX_SUCCESS\n");
                 }
 
                 spin_lock_irqsave(&phba->hbalock, iflag);
@@ -8203,6 +8326,7 @@ lpfc_sli_intr_handler(int irq, void *dev_id)
         struct lpfc_hba  *phba;
         irqreturn_t sp_irq_rc, fp_irq_rc;
         unsigned long status1, status2;
+        uint32_t hc_copy;
 
         /*
          * Get the driver's phba structure from the dev_id and
@@ -8240,7 +8364,12 @@ lpfc_sli_intr_handler(int irq, void *dev_id)
         }
 
         /* Clear attention sources except link and error attentions */
+        hc_copy = readl(phba->HCregaddr);
+        writel(hc_copy & ~(HC_MBINT_ENA | HC_R0INT_ENA | HC_R1INT_ENA
+                | HC_R2INT_ENA | HC_LAINT_ENA | HC_ERINT_ENA),
+                phba->HCregaddr);
         writel((phba->ha_copy & ~(HA_LATT | HA_ERATT)), phba->HAregaddr);
+        writel(hc_copy, phba->HCregaddr);
         readl(phba->HAregaddr); /* flush */
         spin_unlock(&phba->hbalock);
 
@@ -8342,17 +8471,28 @@ void lpfc_sli4_els_xri_abort_event_proc(struct lpfc_hba *phba)
         }
 }
 
+/**
+ * lpfc_sli4_iocb_param_transfer - Transfer pIocbOut and cmpl status to pIocbIn
+ * @phba: pointer to lpfc hba data structure
+ * @pIocbIn: pointer to the rspiocbq
+ * @pIocbOut: pointer to the cmdiocbq
+ * @wcqe: pointer to the complete wcqe
+ *
+ * This routine transfers the fields of a command iocbq to a response iocbq
+ * by copying all the IOCB fields from command iocbq and transferring the
+ * completion status information from the complete wcqe.
+ **/
 static void
-lpfc_sli4_iocb_param_transfer(struct lpfc_iocbq *pIocbIn,
+lpfc_sli4_iocb_param_transfer(struct lpfc_hba *phba,
+                              struct lpfc_iocbq *pIocbIn,
                               struct lpfc_iocbq *pIocbOut,
                               struct lpfc_wcqe_complete *wcqe)
 {
+        unsigned long iflags;
         size_t offset = offsetof(struct lpfc_iocbq, iocb);
 
         memcpy((char *)pIocbIn + offset, (char *)pIocbOut + offset,
                sizeof(struct lpfc_iocbq) - offset);
-        memset(&pIocbIn->sli4_info, 0,
-               sizeof(struct lpfc_sli4_rspiocb_info));
         /* Map WCQE parameters into irspiocb parameters */
         pIocbIn->iocb.ulpStatus = bf_get(lpfc_wcqe_c_status, wcqe);
         if (pIocbOut->iocb_flag & LPFC_IO_FCP)
@@ -8362,18 +8502,60 @@ lpfc_sli4_iocb_param_transfer(struct lpfc_iocbq *pIocbIn,
                                         wcqe->total_data_placed;
                 else
                         pIocbIn->iocb.un.ulpWord[4] = wcqe->parameter;
-        else
+        else {
                 pIocbIn->iocb.un.ulpWord[4] = wcqe->parameter;
-        /* Load in additional WCQE parameters */
-        pIocbIn->sli4_info.hw_status = bf_get(lpfc_wcqe_c_hw_status, wcqe);
-        pIocbIn->sli4_info.bfield = 0;
-        if (bf_get(lpfc_wcqe_c_xb, wcqe))
-                pIocbIn->sli4_info.bfield |= LPFC_XB;
-        if (bf_get(lpfc_wcqe_c_pv, wcqe)) {
-                pIocbIn->sli4_info.bfield |= LPFC_PV;
-                pIocbIn->sli4_info.priority =
-                                        bf_get(lpfc_wcqe_c_priority, wcqe);
+                pIocbIn->iocb.un.genreq64.bdl.bdeSize = wcqe->total_data_placed;
+        }
+
+        /* Pick up HBA exchange busy condition */
+        if (bf_get(lpfc_wcqe_c_xb, wcqe)) {
+                spin_lock_irqsave(&phba->hbalock, iflags);
+                pIocbIn->iocb_flag |= LPFC_EXCHANGE_BUSY;
+                spin_unlock_irqrestore(&phba->hbalock, iflags);
+        }
+}
+
+/**
+ * lpfc_sli4_els_wcqe_to_rspiocbq - Get response iocbq from els wcqe
+ * @phba: Pointer to HBA context object.
+ * @wcqe: Pointer to work-queue completion queue entry.
+ *
+ * This routine handles an ELS work-queue completion event and construct
+ * a pseudo response ELS IODBQ from the SLI4 ELS WCQE for the common
+ * discovery engine to handle.
+ *
+ * Return: Pointer to the receive IOCBQ, NULL otherwise.
+ **/
+static struct lpfc_iocbq *
+lpfc_sli4_els_wcqe_to_rspiocbq(struct lpfc_hba *phba,
+                               struct lpfc_iocbq *irspiocbq)
+{
+        struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
+        struct lpfc_iocbq *cmdiocbq;
+        struct lpfc_wcqe_complete *wcqe;
+        unsigned long iflags;
+
+        wcqe = &irspiocbq->cq_event.cqe.wcqe_cmpl;
+        spin_lock_irqsave(&phba->hbalock, iflags);
+        pring->stats.iocb_event++;
+        /* Look up the ELS command IOCB and create pseudo response IOCB */
+        cmdiocbq = lpfc_sli_iocbq_lookup_by_tag(phba, pring,
+                                bf_get(lpfc_wcqe_c_request_tag, wcqe));
+        spin_unlock_irqrestore(&phba->hbalock, iflags);
+
+        if (unlikely(!cmdiocbq)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
+                                "0386 ELS complete with no corresponding "
+                                "cmdiocb: iotag (%d)\n",
+                                bf_get(lpfc_wcqe_c_request_tag, wcqe));
+                lpfc_sli_release_iocbq(phba, irspiocbq);
+                return NULL;
         }
+
+        /* Fake the irspiocbq and copy necessary response information */
+        lpfc_sli4_iocb_param_transfer(phba, irspiocbq, cmdiocbq, wcqe);
+
+        return irspiocbq;
 }
 
 /**
@@ -8566,45 +8748,26 @@ static bool
 lpfc_sli4_sp_handle_els_wcqe(struct lpfc_hba *phba,
                              struct lpfc_wcqe_complete *wcqe)
 {
-        struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
-        struct lpfc_iocbq *cmdiocbq;
         struct lpfc_iocbq *irspiocbq;
         unsigned long iflags;
-        bool workposted = false;
 
-        spin_lock_irqsave(&phba->hbalock, iflags);
-        pring->stats.iocb_event++;
-        /* Look up the ELS command IOCB and create pseudo response IOCB */
-        cmdiocbq = lpfc_sli_iocbq_lookup_by_tag(phba, pring,
-                                bf_get(lpfc_wcqe_c_request_tag, wcqe));
-        spin_unlock_irqrestore(&phba->hbalock, iflags);
-
-        if (unlikely(!cmdiocbq)) {
-                lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
-                                "0386 ELS complete with no corresponding "
-                                "cmdiocb: iotag (%d)\n",
-                                bf_get(lpfc_wcqe_c_request_tag, wcqe));
-                return workposted;
-        }
-
-        /* Fake the irspiocbq and copy necessary response information */
+        /* Get an irspiocbq for later ELS response processing use */
         irspiocbq = lpfc_sli_get_iocbq(phba);
         if (!irspiocbq) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "0387 Failed to allocate an iocbq\n");
-                return workposted;
+                return false;
         }
-        lpfc_sli4_iocb_param_transfer(irspiocbq, cmdiocbq, wcqe);
 
-        /* Add the irspiocb to the response IOCB work list */
+        /* Save off the slow-path queue event for work thread to process */
+        memcpy(&irspiocbq->cq_event.cqe.wcqe_cmpl, wcqe, sizeof(*wcqe));
         spin_lock_irqsave(&phba->hbalock, iflags);
-        list_add_tail(&irspiocbq->list, &phba->sli4_hba.sp_rspiocb_work_queue);
-        /* Indicate ELS ring attention */
-        phba->work_ha |= (HA_R0ATT << (4*LPFC_ELS_RING));
+        list_add_tail(&irspiocbq->cq_event.list,
+                      &phba->sli4_hba.sp_queue_event);
+        phba->hba_flag |= HBA_SP_QUEUE_EVT;
         spin_unlock_irqrestore(&phba->hbalock, iflags);
-        workposted = true;
 
-        return workposted;
+        return true;
 }
 
 /**
@@ -8690,52 +8853,6 @@ lpfc_sli4_sp_handle_abort_xri_wcqe(struct lpfc_hba *phba,
 }
 
 /**
- * lpfc_sli4_sp_handle_wcqe - Process a work-queue completion queue entry
- * @phba: Pointer to HBA context object.
- * @cq: Pointer to the completion queue.
- * @wcqe: Pointer to a completion queue entry.
- *
- * This routine process a slow-path work-queue completion queue entry.
- *
- * Return: true if work posted to worker thread, otherwise false.
- **/
-static bool
-lpfc_sli4_sp_handle_wcqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
-                         struct lpfc_cqe *cqe)
-{
-        struct lpfc_wcqe_complete wcqe;
-        bool workposted = false;
-
-        /* Copy the work queue CQE and convert endian order if needed */
-        lpfc_sli_pcimem_bcopy(cqe, &wcqe, sizeof(struct lpfc_cqe));
-
-        /* Check and process for different type of WCQE and dispatch */
-        switch (bf_get(lpfc_wcqe_c_code, &wcqe)) {
-        case CQE_CODE_COMPL_WQE:
-                /* Process the WQ complete event */
-                workposted = lpfc_sli4_sp_handle_els_wcqe(phba,
-                                        (struct lpfc_wcqe_complete *)&wcqe);
-                break;
-        case CQE_CODE_RELEASE_WQE:
-                /* Process the WQ release event */
-                lpfc_sli4_sp_handle_rel_wcqe(phba,
-                                        (struct lpfc_wcqe_release *)&wcqe);
-                break;
-        case CQE_CODE_XRI_ABORTED:
-                /* Process the WQ XRI abort event */
-                workposted = lpfc_sli4_sp_handle_abort_xri_wcqe(phba, cq,
-                                        (struct sli4_wcqe_xri_aborted *)&wcqe);
-                break;
-        default:
-                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
-                                "0388 Not a valid WCQE code: x%x\n",
-                                bf_get(lpfc_wcqe_c_code, &wcqe));
-                break;
-        }
-        return workposted;
-}
-
-/**
  * lpfc_sli4_sp_handle_rcqe - Process a receive-queue completion queue entry
  * @phba: Pointer to HBA context object.
  * @rcqe: Pointer to receive-queue completion queue entry.
@@ -8745,9 +8862,8 @@ lpfc_sli4_sp_handle_wcqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
  * Return: true if work posted to worker thread, otherwise false.
  **/
 static bool
-lpfc_sli4_sp_handle_rcqe(struct lpfc_hba *phba, struct lpfc_cqe *cqe)
+lpfc_sli4_sp_handle_rcqe(struct lpfc_hba *phba, struct lpfc_rcqe *rcqe)
 {
-        struct lpfc_rcqe rcqe;
         bool workposted = false;
         struct lpfc_queue *hrq = phba->sli4_hba.hdr_rq;
         struct lpfc_queue *drq = phba->sli4_hba.dat_rq;
@@ -8755,31 +8871,28 @@ lpfc_sli4_sp_handle_rcqe(struct lpfc_hba *phba, struct lpfc_cqe *cqe)
         uint32_t status;
         unsigned long iflags;
 
-        /* Copy the receive queue CQE and convert endian order if needed */
-        lpfc_sli_pcimem_bcopy(cqe, &rcqe, sizeof(struct lpfc_rcqe));
-        lpfc_sli4_rq_release(hrq, drq);
-        if (bf_get(lpfc_rcqe_code, &rcqe) != CQE_CODE_RECEIVE)
-                goto out;
-        if (bf_get(lpfc_rcqe_rq_id, &rcqe) != hrq->queue_id)
+        if (bf_get(lpfc_rcqe_rq_id, rcqe) != hrq->queue_id)
                 goto out;
 
-        status = bf_get(lpfc_rcqe_status, &rcqe);
+        status = bf_get(lpfc_rcqe_status, rcqe);
         switch (status) {
         case FC_STATUS_RQ_BUF_LEN_EXCEEDED:
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "2537 Receive Frame Truncated!!\n");
         case FC_STATUS_RQ_SUCCESS:
+                lpfc_sli4_rq_release(hrq, drq);
                 spin_lock_irqsave(&phba->hbalock, iflags);
                 dma_buf = lpfc_sli_hbqbuf_get(&phba->hbqs[0].hbq_buffer_list);
                 if (!dma_buf) {
                         spin_unlock_irqrestore(&phba->hbalock, iflags);
                         goto out;
                 }
-                memcpy(&dma_buf->rcqe, &rcqe, sizeof(rcqe));
+                memcpy(&dma_buf->cq_event.cqe.rcqe_cmpl, rcqe, sizeof(*rcqe));
                 /* save off the frame for the word thread to process */
-                list_add_tail(&dma_buf->dbuf.list, &phba->rb_pend_list);
+                list_add_tail(&dma_buf->cq_event.list,
+                              &phba->sli4_hba.sp_queue_event);
                 /* Frame received */
-                phba->hba_flag |= HBA_RECEIVE_BUFFER;
+                phba->hba_flag |= HBA_SP_QUEUE_EVT;
                 spin_unlock_irqrestore(&phba->hbalock, iflags);
                 workposted = true;
                 break;
@@ -8794,7 +8907,58 @@ lpfc_sli4_sp_handle_rcqe(struct lpfc_hba *phba, struct lpfc_cqe *cqe)
         }
 out:
         return workposted;
+}
+
+/**
+ * lpfc_sli4_sp_handle_cqe - Process a slow path completion queue entry
+ * @phba: Pointer to HBA context object.
+ * @cq: Pointer to the completion queue.
+ * @wcqe: Pointer to a completion queue entry.
+ *
+ * This routine process a slow-path work-queue or recieve queue completion queue
+ * entry.
+ *
+ * Return: true if work posted to worker thread, otherwise false.
+ **/
+static bool
+lpfc_sli4_sp_handle_cqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
+                         struct lpfc_cqe *cqe)
+{
+        struct lpfc_cqe cqevt;
+        bool workposted = false;
+
+        /* Copy the work queue CQE and convert endian order if needed */
+        lpfc_sli_pcimem_bcopy(cqe, &cqevt, sizeof(struct lpfc_cqe));
 
+        /* Check and process for different type of WCQE and dispatch */
+        switch (bf_get(lpfc_cqe_code, &cqevt)) {
+        case CQE_CODE_COMPL_WQE:
+                /* Process the WQ/RQ complete event */
+                workposted = lpfc_sli4_sp_handle_els_wcqe(phba,
+                                (struct lpfc_wcqe_complete *)&cqevt);
+                break;
+        case CQE_CODE_RELEASE_WQE:
+                /* Process the WQ release event */
+                lpfc_sli4_sp_handle_rel_wcqe(phba,
+                                (struct lpfc_wcqe_release *)&cqevt);
+                break;
+        case CQE_CODE_XRI_ABORTED:
+                /* Process the WQ XRI abort event */
+                workposted = lpfc_sli4_sp_handle_abort_xri_wcqe(phba, cq,
+                                (struct sli4_wcqe_xri_aborted *)&cqevt);
+                break;
+        case CQE_CODE_RECEIVE:
+                /* Process the RQ event */
+                workposted = lpfc_sli4_sp_handle_rcqe(phba,
+                                (struct lpfc_rcqe *)&cqevt);
+                break;
+        default:
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "0388 Not a valid WCQE code: x%x\n",
+                                bf_get(lpfc_cqe_code, &cqevt));
+                break;
+        }
+        return workposted;
 }
 
 /**
@@ -8819,8 +8983,7 @@ lpfc_sli4_sp_handle_eqe(struct lpfc_hba *phba, struct lpfc_eqe *eqe)
         int ecount = 0;
         uint16_t cqid;
 
-        if (bf_get(lpfc_eqe_major_code, eqe) != 0 ||
-            bf_get(lpfc_eqe_minor_code, eqe) != 0) {
+        if (bf_get(lpfc_eqe_major_code, eqe) != 0) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "0359 Not a valid slow-path completion "
                                 "event: majorcode=x%x, minorcode=x%x\n",
@@ -8858,14 +9021,7 @@ lpfc_sli4_sp_handle_eqe(struct lpfc_hba *phba, struct lpfc_eqe *eqe)
                 break;
         case LPFC_WCQ:
                 while ((cqe = lpfc_sli4_cq_get(cq))) {
-                        workposted |= lpfc_sli4_sp_handle_wcqe(phba, cq, cqe);
-                        if (!(++ecount % LPFC_GET_QE_REL_INT))
-                                lpfc_sli4_cq_release(cq, LPFC_QUEUE_NOARM);
-                }
-                break;
-        case LPFC_RCQ:
-                while ((cqe = lpfc_sli4_cq_get(cq))) {
-                        workposted |= lpfc_sli4_sp_handle_rcqe(phba, cqe);
+                        workposted |= lpfc_sli4_sp_handle_cqe(phba, cq, cqe);
                         if (!(++ecount % LPFC_GET_QE_REL_INT))
                                 lpfc_sli4_cq_release(cq, LPFC_QUEUE_NOARM);
                 }
@@ -8953,7 +9109,13 @@ lpfc_sli4_fp_handle_fcp_wcqe(struct lpfc_hba *phba,
         }
 
         /* Fake the irspiocb and copy necessary response information */
-        lpfc_sli4_iocb_param_transfer(&irspiocbq, cmdiocbq, wcqe);
+        lpfc_sli4_iocb_param_transfer(phba, &irspiocbq, cmdiocbq, wcqe);
+
+        if (cmdiocbq->iocb_flag & LPFC_DRIVER_ABORTED) {
+                spin_lock_irqsave(&phba->hbalock, iflags);
+                cmdiocbq->iocb_flag &= ~LPFC_DRIVER_ABORTED;
+                spin_unlock_irqrestore(&phba->hbalock, iflags);
+        }
 
         /* Pass the cmd_iocb and the rsp state to the upper layer */
         (cmdiocbq->iocb_cmpl)(phba, cmdiocbq, &irspiocbq);
@@ -9059,8 +9221,7 @@ lpfc_sli4_fp_handle_eqe(struct lpfc_hba *phba, struct lpfc_eqe *eqe,
         uint16_t cqid;
         int ecount = 0;
 
-        if (unlikely(bf_get(lpfc_eqe_major_code, eqe) != 0) ||
-            unlikely(bf_get(lpfc_eqe_minor_code, eqe) != 0)) {
+        if (unlikely(bf_get(lpfc_eqe_major_code, eqe) != 0)) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "0366 Not a valid fast-path completion "
                                 "event: majorcode=x%x, minorcode=x%x\n",
@@ -10427,8 +10588,7 @@ lpfc_sli4_next_xritag(struct lpfc_hba *phba)
                 return xritag;
         }
         spin_unlock_irq(&phba->hbalock);
-
-        lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+        lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
                         "2004 Failed to allocate XRI.last XRITAG is %d"
                         " Max XRI is %d, Used XRI is %d\n",
                         phba->sli4_hba.next_xri,
@@ -10492,15 +10652,7 @@ lpfc_sli4_post_sgl_list(struct lpfc_hba *phba)
                 lpfc_sli4_mbox_cmd_free(phba, mbox);
                 return -ENOMEM;
         }
-
         /* Get the first SGE entry from the non-embedded DMA memory */
-        if (unlikely(!mbox->sge_array)) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
-                                "2525 Failed to get the non-embedded SGE "
-                                "virtual address\n");
-                lpfc_sli4_mbox_cmd_free(phba, mbox);
-                return -ENOMEM;
-        }
         viraddr = mbox->sge_array->addr[0];
 
         /* Set up the SGL pages in the non-embedded DMA pages */
@@ -10524,8 +10676,7 @@ lpfc_sli4_post_sgl_list(struct lpfc_hba *phba)
                 sgl_pg_pairs++;
         }
         bf_set(lpfc_post_sgl_pages_xri, sgl, xritag_start);
-        pg_pairs = (pg_pairs > 0) ? (pg_pairs - 1) : pg_pairs;
-        bf_set(lpfc_post_sgl_pages_xricnt, sgl, pg_pairs);
+        bf_set(lpfc_post_sgl_pages_xricnt, sgl, els_xri_cnt);
         /* Perform endian conversion if necessary */
         sgl->word0 = cpu_to_le32(sgl->word0);
 
@@ -10607,15 +10758,7 @@ lpfc_sli4_post_scsi_sgl_block(struct lpfc_hba *phba, struct list_head *sblist,
                 lpfc_sli4_mbox_cmd_free(phba, mbox);
                 return -ENOMEM;
         }
-
         /* Get the first SGE entry from the non-embedded DMA memory */
-        if (unlikely(!mbox->sge_array)) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
-                                "2565 Failed to get the non-embedded SGE "
-                                "virtual address\n");
-                lpfc_sli4_mbox_cmd_free(phba, mbox);
-                return -ENOMEM;
-        }
         viraddr = mbox->sge_array->addr[0];
 
         /* Set up the SGL pages in the non-embedded DMA pages */
@@ -10802,6 +10945,105 @@ lpfc_fc_frame_to_vport(struct lpfc_hba *phba, struct fc_frame_header *fc_hdr,
 }
 
 /**
+ * lpfc_update_rcv_time_stamp - Update vport's rcv seq time stamp
+ * @vport: The vport to work on.
+ *
+ * This function updates the receive sequence time stamp for this vport. The
+ * receive sequence time stamp indicates the time that the last frame of the
+ * the sequence that has been idle for the longest amount of time was received.
+ * the driver uses this time stamp to indicate if any received sequences have
+ * timed out.
+ **/
+void
+lpfc_update_rcv_time_stamp(struct lpfc_vport *vport)
+{
+        struct lpfc_dmabuf *h_buf;
+        struct hbq_dmabuf *dmabuf = NULL;
+
+        /* get the oldest sequence on the rcv list */
+        h_buf = list_get_first(&vport->rcv_buffer_list,
+                               struct lpfc_dmabuf, list);
+        if (!h_buf)
+                return;
+        dmabuf = container_of(h_buf, struct hbq_dmabuf, hbuf);
+        vport->rcv_buffer_time_stamp = dmabuf->time_stamp;
+}
+
+/**
+ * lpfc_cleanup_rcv_buffers - Cleans up all outstanding receive sequences.
+ * @vport: The vport that the received sequences were sent to.
+ *
+ * This function cleans up all outstanding received sequences. This is called
+ * by the driver when a link event or user action invalidates all the received
+ * sequences.
+ **/
+void
+lpfc_cleanup_rcv_buffers(struct lpfc_vport *vport)
+{
+        struct lpfc_dmabuf *h_buf, *hnext;
+        struct lpfc_dmabuf *d_buf, *dnext;
+        struct hbq_dmabuf *dmabuf = NULL;
+
+        /* start with the oldest sequence on the rcv list */
+        list_for_each_entry_safe(h_buf, hnext, &vport->rcv_buffer_list, list) {
+                dmabuf = container_of(h_buf, struct hbq_dmabuf, hbuf);
+                list_del_init(&dmabuf->hbuf.list);
+                list_for_each_entry_safe(d_buf, dnext,
+                                         &dmabuf->dbuf.list, list) {
+                        list_del_init(&d_buf->list);
+                        lpfc_in_buf_free(vport->phba, d_buf);
+                }
+                lpfc_in_buf_free(vport->phba, &dmabuf->dbuf);
+        }
+}
+
+/**
+ * lpfc_rcv_seq_check_edtov - Cleans up timed out receive sequences.
+ * @vport: The vport that the received sequences were sent to.
+ *
+ * This function determines whether any received sequences have timed out by
+ * first checking the vport's rcv_buffer_time_stamp. If this time_stamp
+ * indicates that there is at least one timed out sequence this routine will
+ * go through the received sequences one at a time from most inactive to most
+ * active to determine which ones need to be cleaned up. Once it has determined
+ * that a sequence needs to be cleaned up it will simply free up the resources
+ * without sending an abort.
+ **/
+void
+lpfc_rcv_seq_check_edtov(struct lpfc_vport *vport)
+{
+        struct lpfc_dmabuf *h_buf, *hnext;
+        struct lpfc_dmabuf *d_buf, *dnext;
+        struct hbq_dmabuf *dmabuf = NULL;
+        unsigned long timeout;
+        int abort_count = 0;
+
+        timeout = (msecs_to_jiffies(vport->phba->fc_edtov) +
+                   vport->rcv_buffer_time_stamp);
+        if (list_empty(&vport->rcv_buffer_list) ||
+            time_before(jiffies, timeout))
+                return;
+        /* start with the oldest sequence on the rcv list */
+        list_for_each_entry_safe(h_buf, hnext, &vport->rcv_buffer_list, list) {
+                dmabuf = container_of(h_buf, struct hbq_dmabuf, hbuf);
+                timeout = (msecs_to_jiffies(vport->phba->fc_edtov) +
+                           dmabuf->time_stamp);
+                if (time_before(jiffies, timeout))
+                        break;
+                abort_count++;
+                list_del_init(&dmabuf->hbuf.list);
+                list_for_each_entry_safe(d_buf, dnext,
+                                         &dmabuf->dbuf.list, list) {
+                        list_del_init(&d_buf->list);
+                        lpfc_in_buf_free(vport->phba, d_buf);
+                }
+                lpfc_in_buf_free(vport->phba, &dmabuf->dbuf);
+        }
+        if (abort_count)
+                lpfc_update_rcv_time_stamp(vport);
+}
+
+/**
  * lpfc_fc_frame_add - Adds a frame to the vport's list of received sequences
  * @dmabuf: pointer to a dmabuf that describes the hdr and data of the FC frame
  *
@@ -10823,6 +11065,8 @@ lpfc_fc_frame_add(struct lpfc_vport *vport, struct hbq_dmabuf *dmabuf)
         struct hbq_dmabuf *seq_dmabuf = NULL;
         struct hbq_dmabuf *temp_dmabuf = NULL;
 
+        INIT_LIST_HEAD(&dmabuf->dbuf.list);
+        dmabuf->time_stamp = jiffies;
         new_hdr = (struct fc_frame_header *)dmabuf->hbuf.virt;
         /* Use the hdr_buf to find the sequence that this frame belongs to */
         list_for_each_entry(h_buf, &vport->rcv_buffer_list, list) {
@@ -10841,13 +11085,27 @@ lpfc_fc_frame_add(struct lpfc_vport *vport, struct hbq_dmabuf *dmabuf)
                  * Queue the buffer on the vport's rcv_buffer_list.
                  */
                 list_add_tail(&dmabuf->hbuf.list, &vport->rcv_buffer_list);
+                lpfc_update_rcv_time_stamp(vport);
                 return dmabuf;
         }
         temp_hdr = seq_dmabuf->hbuf.virt;
-        if (new_hdr->fh_seq_cnt < temp_hdr->fh_seq_cnt) {
-                list_add(&seq_dmabuf->dbuf.list, &dmabuf->dbuf.list);
+        if (be16_to_cpu(new_hdr->fh_seq_cnt) <
+                be16_to_cpu(temp_hdr->fh_seq_cnt)) {
+                list_del_init(&seq_dmabuf->hbuf.list);
+                list_add_tail(&dmabuf->hbuf.list, &vport->rcv_buffer_list);
+                list_add_tail(&dmabuf->dbuf.list, &seq_dmabuf->dbuf.list);
+                lpfc_update_rcv_time_stamp(vport);
                 return dmabuf;
         }
+        /* move this sequence to the tail to indicate a young sequence */
+        list_move_tail(&seq_dmabuf->hbuf.list, &vport->rcv_buffer_list);
+        seq_dmabuf->time_stamp = jiffies;
+        lpfc_update_rcv_time_stamp(vport);
+        if (list_empty(&seq_dmabuf->dbuf.list)) {
+                temp_hdr = dmabuf->hbuf.virt;
+                list_add_tail(&dmabuf->dbuf.list, &seq_dmabuf->dbuf.list);
+                return seq_dmabuf;
+        }
         /* find the correct place in the sequence to insert this frame */
         list_for_each_entry_reverse(d_buf, &seq_dmabuf->dbuf.list, list) {
                 temp_dmabuf = container_of(d_buf, struct hbq_dmabuf, dbuf);
@@ -10856,7 +11114,8 @@ lpfc_fc_frame_add(struct lpfc_vport *vport, struct hbq_dmabuf *dmabuf)
                  * If the frame's sequence count is greater than the frame on
                  * the list then insert the frame right after this frame
                  */
-                if (new_hdr->fh_seq_cnt > temp_hdr->fh_seq_cnt) {
+                if (be16_to_cpu(new_hdr->fh_seq_cnt) >
+                        be16_to_cpu(temp_hdr->fh_seq_cnt)) {
                         list_add(&dmabuf->dbuf.list, &temp_dmabuf->dbuf.list);
                         return seq_dmabuf;
                 }
@@ -10865,6 +11124,210 @@ lpfc_fc_frame_add(struct lpfc_vport *vport, struct hbq_dmabuf *dmabuf)
 }
 
 /**
+ * lpfc_sli4_abort_partial_seq - Abort partially assembled unsol sequence
+ * @vport: pointer to a vitural port
+ * @dmabuf: pointer to a dmabuf that describes the FC sequence
+ *
+ * This function tries to abort from the partially assembed sequence, described
+ * by the information from basic abbort @dmabuf. It checks to see whether such
+ * partially assembled sequence held by the driver. If so, it shall free up all
+ * the frames from the partially assembled sequence.
+ *
+ * Return
+ * true  -- if there is matching partially assembled sequence present and all
+ *          the frames freed with the sequence;
+ * false -- if there is no matching partially assembled sequence present so
+ *          nothing got aborted in the lower layer driver
+ **/
+static bool
+lpfc_sli4_abort_partial_seq(struct lpfc_vport *vport,
+                            struct hbq_dmabuf *dmabuf)
+{
+        struct fc_frame_header *new_hdr;
+        struct fc_frame_header *temp_hdr;
+        struct lpfc_dmabuf *d_buf, *n_buf, *h_buf;
+        struct hbq_dmabuf *seq_dmabuf = NULL;
+
+        /* Use the hdr_buf to find the sequence that matches this frame */
+        INIT_LIST_HEAD(&dmabuf->dbuf.list);
+        INIT_LIST_HEAD(&dmabuf->hbuf.list);
+        new_hdr = (struct fc_frame_header *)dmabuf->hbuf.virt;
+        list_for_each_entry(h_buf, &vport->rcv_buffer_list, list) {
+                temp_hdr = (struct fc_frame_header *)h_buf->virt;
+                if ((temp_hdr->fh_seq_id != new_hdr->fh_seq_id) ||
+                    (temp_hdr->fh_ox_id != new_hdr->fh_ox_id) ||
+                    (memcmp(&temp_hdr->fh_s_id, &new_hdr->fh_s_id, 3)))
+                        continue;
+                /* found a pending sequence that matches this frame */
+                seq_dmabuf = container_of(h_buf, struct hbq_dmabuf, hbuf);
+                break;
+        }
+
+        /* Free up all the frames from the partially assembled sequence */
+        if (seq_dmabuf) {
+                list_for_each_entry_safe(d_buf, n_buf,
+                                         &seq_dmabuf->dbuf.list, list) {
+                        list_del_init(&d_buf->list);
+                        lpfc_in_buf_free(vport->phba, d_buf);
+                }
+                return true;
+        }
+        return false;
+}
+
+/**
+ * lpfc_sli4_seq_abort_acc_cmpl - Accept seq abort iocb complete handler
+ * @phba: Pointer to HBA context object.
+ * @cmd_iocbq: pointer to the command iocbq structure.
+ * @rsp_iocbq: pointer to the response iocbq structure.
+ *
+ * This function handles the sequence abort accept iocb command complete
+ * event. It properly releases the memory allocated to the sequence abort
+ * accept iocb.
+ **/
+static void
+lpfc_sli4_seq_abort_acc_cmpl(struct lpfc_hba *phba,
+                             struct lpfc_iocbq *cmd_iocbq,
+                             struct lpfc_iocbq *rsp_iocbq)
+{
+        if (cmd_iocbq)
+                lpfc_sli_release_iocbq(phba, cmd_iocbq);
+}
+
+/**
+ * lpfc_sli4_seq_abort_acc - Accept sequence abort
+ * @phba: Pointer to HBA context object.
+ * @fc_hdr: pointer to a FC frame header.
+ *
+ * This function sends a basic accept to a previous unsol sequence abort
+ * event after aborting the sequence handling.
+ **/
+static void
+lpfc_sli4_seq_abort_acc(struct lpfc_hba *phba,
+                        struct fc_frame_header *fc_hdr)
+{
+        struct lpfc_iocbq *ctiocb = NULL;
+        struct lpfc_nodelist *ndlp;
+        uint16_t oxid, rxid;
+        uint32_t sid, fctl;
+        IOCB_t *icmd;
+
+        if (!lpfc_is_link_up(phba))
+                return;
+
+        sid = sli4_sid_from_fc_hdr(fc_hdr);
+        oxid = be16_to_cpu(fc_hdr->fh_ox_id);
+        rxid = be16_to_cpu(fc_hdr->fh_rx_id);
+
+        ndlp = lpfc_findnode_did(phba->pport, sid);
+        if (!ndlp) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_ELS,
+                                "1268 Find ndlp returned NULL for oxid:x%x "
+                                "SID:x%x\n", oxid, sid);
+                return;
+        }
+
+        /* Allocate buffer for acc iocb */
+        ctiocb = lpfc_sli_get_iocbq(phba);
+        if (!ctiocb)
+                return;
+
+        /* Extract the F_CTL field from FC_HDR */
+        fctl = sli4_fctl_from_fc_hdr(fc_hdr);
+
+        icmd = &ctiocb->iocb;
+        icmd->un.xseq64.bdl.bdeSize = 0;
+        icmd->un.xseq64.bdl.ulpIoTag32 = 0;
+        icmd->un.xseq64.w5.hcsw.Dfctl = 0;
+        icmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_BA_ACC;
+        icmd->un.xseq64.w5.hcsw.Type = FC_TYPE_BLS;
+
+        /* Fill in the rest of iocb fields */
+        icmd->ulpCommand = CMD_XMIT_BLS_RSP64_CX;
+        icmd->ulpBdeCount = 0;
+        icmd->ulpLe = 1;
+        icmd->ulpClass = CLASS3;
+        icmd->ulpContext = ndlp->nlp_rpi;
+
+        ctiocb->iocb_cmpl = NULL;
+        ctiocb->vport = phba->pport;
+        ctiocb->iocb_cmpl = lpfc_sli4_seq_abort_acc_cmpl;
+
+        if (fctl & FC_FC_EX_CTX) {
+                /* ABTS sent by responder to CT exchange, construction
+                 * of BA_ACC will use OX_ID from ABTS for the XRI_TAG
+                 * field and RX_ID from ABTS for RX_ID field.
+                 */
+                bf_set(lpfc_abts_orig, &icmd->un.bls_acc, LPFC_ABTS_UNSOL_RSP);
+                bf_set(lpfc_abts_rxid, &icmd->un.bls_acc, rxid);
+                ctiocb->sli4_xritag = oxid;
+        } else {
+                /* ABTS sent by initiator to CT exchange, construction
+                 * of BA_ACC will need to allocate a new XRI as for the
+                 * XRI_TAG and RX_ID fields.
+                 */
+                bf_set(lpfc_abts_orig, &icmd->un.bls_acc, LPFC_ABTS_UNSOL_INT);
+                bf_set(lpfc_abts_rxid, &icmd->un.bls_acc, NO_XRI);
+                ctiocb->sli4_xritag = NO_XRI;
+        }
+        bf_set(lpfc_abts_oxid, &icmd->un.bls_acc, oxid);
+
+        /* Xmit CT abts accept on exchange <xid> */
+        lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
+                        "1200 Xmit CT ABTS ACC on exchange x%x Data: x%x\n",
+                        CMD_XMIT_BLS_RSP64_CX, phba->link_state);
+        lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, ctiocb, 0);
+}
+
+/**
+ * lpfc_sli4_handle_unsol_abort - Handle sli-4 unsolicited abort event
+ * @vport: Pointer to the vport on which this sequence was received
+ * @dmabuf: pointer to a dmabuf that describes the FC sequence
+ *
+ * This function handles an SLI-4 unsolicited abort event. If the unsolicited
+ * receive sequence is only partially assembed by the driver, it shall abort
+ * the partially assembled frames for the sequence. Otherwise, if the
+ * unsolicited receive sequence has been completely assembled and passed to
+ * the Upper Layer Protocol (UPL), it then mark the per oxid status for the
+ * unsolicited sequence has been aborted. After that, it will issue a basic
+ * accept to accept the abort.
+ **/
+void
+lpfc_sli4_handle_unsol_abort(struct lpfc_vport *vport,
+                             struct hbq_dmabuf *dmabuf)
+{
+        struct lpfc_hba *phba = vport->phba;
+        struct fc_frame_header fc_hdr;
+        uint32_t fctl;
+        bool abts_par;
+
+        /* Make a copy of fc_hdr before the dmabuf being released */
+        memcpy(&fc_hdr, dmabuf->hbuf.virt, sizeof(struct fc_frame_header));
+        fctl = sli4_fctl_from_fc_hdr(&fc_hdr);
+
+        if (fctl & FC_FC_EX_CTX) {
+                /*
+                 * ABTS sent by responder to exchange, just free the buffer
+                 */
+                lpfc_in_buf_free(phba, &dmabuf->dbuf);
+        } else {
+                /*
+                 * ABTS sent by initiator to exchange, need to do cleanup
+                 */
+                /* Try to abort partially assembled seq */
+                abts_par = lpfc_sli4_abort_partial_seq(vport, dmabuf);
+
+                /* Send abort to ULP if partially seq abort failed */
+                if (abts_par == false)
+                        lpfc_sli4_send_seq_to_ulp(vport, dmabuf);
+                else
+                        lpfc_in_buf_free(phba, &dmabuf->dbuf);
+        }
+        /* Send basic accept (BA_ACC) to the abort requester */
+        lpfc_sli4_seq_abort_acc(phba, &fc_hdr);
+}
+
+/**
  * lpfc_seq_complete - Indicates if a sequence is complete
  * @dmabuf: pointer to a dmabuf that describes the FC sequence
  *
@@ -10899,7 +11362,7 @@ lpfc_seq_complete(struct hbq_dmabuf *dmabuf)
                 seq_dmabuf = container_of(d_buf, struct hbq_dmabuf, dbuf);
                 hdr = (struct fc_frame_header *)seq_dmabuf->hbuf.virt;
                 /* If there is a hole in the sequence count then fail. */
-                if (++seq_count != hdr->fh_seq_cnt)
+                if (++seq_count != be16_to_cpu(hdr->fh_seq_cnt))
                         return 0;
                 fctl = (hdr->fh_f_ctl[0] << 16 |
                         hdr->fh_f_ctl[1] << 8 |
@@ -10931,14 +11394,14 @@ lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
         struct lpfc_iocbq *first_iocbq, *iocbq;
         struct fc_frame_header *fc_hdr;
         uint32_t sid;
+        struct ulp_bde64 *pbde;
 
         fc_hdr = (struct fc_frame_header *)seq_dmabuf->hbuf.virt;
         /* remove from receive buffer list */
         list_del_init(&seq_dmabuf->hbuf.list);
+        lpfc_update_rcv_time_stamp(vport);
         /* get the Remote Port's SID */
-        sid = (fc_hdr->fh_s_id[0] << 16 |
-               fc_hdr->fh_s_id[1] << 8 |
-               fc_hdr->fh_s_id[2]);
+        sid = sli4_sid_from_fc_hdr(fc_hdr);
         /* Get an iocbq struct to fill in. */
         first_iocbq = lpfc_sli_get_iocbq(vport->phba);
         if (first_iocbq) {
@@ -10957,7 +11420,8 @@ lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
                                                         LPFC_DATA_BUF_SIZE;
                 first_iocbq->iocb.un.rcvels.remoteID = sid;
                 first_iocbq->iocb.unsli3.rcvsli3.acc_len +=
-                                bf_get(lpfc_rcqe_length, &seq_dmabuf->rcqe);
+                                bf_get(lpfc_rcqe_length,
+                                       &seq_dmabuf->cq_event.cqe.rcqe_cmpl);
         }
         iocbq = first_iocbq;
         /*
@@ -10972,10 +11436,12 @@ lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
                 if (!iocbq->context3) {
                         iocbq->context3 = d_buf;
                         iocbq->iocb.ulpBdeCount++;
-                        iocbq->iocb.unsli3.rcvsli3.bde2.tus.f.bdeSize =
-                                                        LPFC_DATA_BUF_SIZE;
+                        pbde = (struct ulp_bde64 *)
+                                        &iocbq->iocb.unsli3.sli3Words[4];
+                        pbde->tus.f.bdeSize = LPFC_DATA_BUF_SIZE;
                         first_iocbq->iocb.unsli3.rcvsli3.acc_len +=
-                                bf_get(lpfc_rcqe_length, &seq_dmabuf->rcqe);
+                                bf_get(lpfc_rcqe_length,
+                                       &seq_dmabuf->cq_event.cqe.rcqe_cmpl);
                 } else {
                         iocbq = lpfc_sli_get_iocbq(vport->phba);
                         if (!iocbq) {
@@ -10994,7 +11460,8 @@ lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
                         iocbq->iocb.un.cont64[0].tus.f.bdeSize =
                                                         LPFC_DATA_BUF_SIZE;
                         first_iocbq->iocb.unsli3.rcvsli3.acc_len +=
-                                bf_get(lpfc_rcqe_length, &seq_dmabuf->rcqe);
+                                bf_get(lpfc_rcqe_length,
+                                       &seq_dmabuf->cq_event.cqe.rcqe_cmpl);
                         iocbq->iocb.un.rcvels.remoteID = sid;
                         list_add_tail(&iocbq->list, &first_iocbq->list);
                 }
@@ -11002,6 +11469,43 @@ lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
         return first_iocbq;
 }
 
+static void
+lpfc_sli4_send_seq_to_ulp(struct lpfc_vport *vport,
+                          struct hbq_dmabuf *seq_dmabuf)
+{
+        struct fc_frame_header *fc_hdr;
+        struct lpfc_iocbq *iocbq, *curr_iocb, *next_iocb;
+        struct lpfc_hba *phba = vport->phba;
+
+        fc_hdr = (struct fc_frame_header *)seq_dmabuf->hbuf.virt;
+        iocbq = lpfc_prep_seq(vport, seq_dmabuf);
+        if (!iocbq) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "2707 Ring %d handler: Failed to allocate "
+                                "iocb Rctl x%x Type x%x received\n",
+                                LPFC_ELS_RING,
+                                fc_hdr->fh_r_ctl, fc_hdr->fh_type);
+                return;
+        }
+        if (!lpfc_complete_unsol_iocb(phba,
+                                      &phba->sli.ring[LPFC_ELS_RING],
+                                      iocbq, fc_hdr->fh_r_ctl,
+                                      fc_hdr->fh_type))
+                lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
+                                "2540 Ring %d handler: unexpected Rctl "
+                                "x%x Type x%x received\n",
+                                LPFC_ELS_RING,
+                                fc_hdr->fh_r_ctl, fc_hdr->fh_type);
+
+        /* Free iocb created in lpfc_prep_seq */
+        list_for_each_entry_safe(curr_iocb, next_iocb,
+                &iocbq->list, list) {
+                list_del_init(&curr_iocb->list);
+                lpfc_sli_release_iocbq(phba, curr_iocb);
+        }
+        lpfc_sli_release_iocbq(phba, iocbq);
+}
+
 /**
  * lpfc_sli4_handle_received_buffer - Handle received buffers from firmware
  * @phba: Pointer to HBA context object.
@@ -11014,67 +11518,48 @@ lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
  * Worker thread calls lpfc_sli4_handle_received_buffer, which will call the
  * appropriate receive function when the final frame in a sequence is received.
  **/
-int
-lpfc_sli4_handle_received_buffer(struct lpfc_hba *phba)
+void
+lpfc_sli4_handle_received_buffer(struct lpfc_hba *phba,
+                                 struct hbq_dmabuf *dmabuf)
 {
-        LIST_HEAD(cmplq);
-        struct hbq_dmabuf *dmabuf, *seq_dmabuf;
+        struct hbq_dmabuf *seq_dmabuf;
         struct fc_frame_header *fc_hdr;
         struct lpfc_vport *vport;
         uint32_t fcfi;
-        struct lpfc_iocbq *iocbq;
-
-        /* Clear hba flag and get all received buffers into the cmplq */
-        spin_lock_irq(&phba->hbalock);
-        phba->hba_flag &= ~HBA_RECEIVE_BUFFER;
-        list_splice_init(&phba->rb_pend_list, &cmplq);
-        spin_unlock_irq(&phba->hbalock);
 
         /* Process each received buffer */
-        while ((dmabuf = lpfc_sli_hbqbuf_get(&cmplq)) != NULL) {
-                fc_hdr = (struct fc_frame_header *)dmabuf->hbuf.virt;
-                /* check to see if this a valid type of frame */
-                if (lpfc_fc_frame_check(phba, fc_hdr)) {
-                        lpfc_in_buf_free(phba, &dmabuf->dbuf);
-                        continue;
-                }
-                fcfi = bf_get(lpfc_rcqe_fcf_id, &dmabuf->rcqe);
-                vport = lpfc_fc_frame_to_vport(phba, fc_hdr, fcfi);
-                if (!vport) {
-                        /* throw out the frame */
-                        lpfc_in_buf_free(phba, &dmabuf->dbuf);
-                        continue;
-                }
-                /* Link this frame */
-                seq_dmabuf = lpfc_fc_frame_add(vport, dmabuf);
-                if (!seq_dmabuf) {
-                        /* unable to add frame to vport - throw it out */
-                        lpfc_in_buf_free(phba, &dmabuf->dbuf);
-                        continue;
-                }
-                /* If not last frame in sequence continue processing frames. */
-                if (!lpfc_seq_complete(seq_dmabuf)) {
-                        /*
-                         * When saving off frames post a new one and mark this
-                         * frame to be freed when it is finished.
-                         **/
-                        lpfc_sli_hbqbuf_fill_hbqs(phba, LPFC_ELS_HBQ, 1);
-                        dmabuf->tag = -1;
-                        continue;
-                }
-                fc_hdr = (struct fc_frame_header *)seq_dmabuf->hbuf.virt;
-                iocbq = lpfc_prep_seq(vport, seq_dmabuf);
-                if (!lpfc_complete_unsol_iocb(phba,
-                                              &phba->sli.ring[LPFC_ELS_RING],
-                                              iocbq, fc_hdr->fh_r_ctl,
-                                              fc_hdr->fh_type))
-                        lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
-                                        "2540 Ring %d handler: unexpected Rctl "
-                                        "x%x Type x%x received\n",
-                                        LPFC_ELS_RING,
-                                        fc_hdr->fh_r_ctl, fc_hdr->fh_type);
-        };
-        return 0;
+        fc_hdr = (struct fc_frame_header *)dmabuf->hbuf.virt;
+        /* check to see if this a valid type of frame */
+        if (lpfc_fc_frame_check(phba, fc_hdr)) {
+                lpfc_in_buf_free(phba, &dmabuf->dbuf);
+                return;
+        }
+        fcfi = bf_get(lpfc_rcqe_fcf_id, &dmabuf->cq_event.cqe.rcqe_cmpl);
+        vport = lpfc_fc_frame_to_vport(phba, fc_hdr, fcfi);
+        if (!vport || !(vport->vpi_state & LPFC_VPI_REGISTERED)) {
+                /* throw out the frame */
+                lpfc_in_buf_free(phba, &dmabuf->dbuf);
+                return;
+        }
+        /* Handle the basic abort sequence (BA_ABTS) event */
+        if (fc_hdr->fh_r_ctl == FC_RCTL_BA_ABTS) {
+                lpfc_sli4_handle_unsol_abort(vport, dmabuf);
+                return;
+        }
+
+        /* Link this frame */
+        seq_dmabuf = lpfc_fc_frame_add(vport, dmabuf);
+        if (!seq_dmabuf) {
+                /* unable to add frame to vport - throw it out */
+                lpfc_in_buf_free(phba, &dmabuf->dbuf);
+                return;
+        }
+        /* If not last frame in sequence continue processing frames. */
+        if (!lpfc_seq_complete(seq_dmabuf))
+                return;
+
+        /* Send the complete sequence to the upper layer protocol */
+        lpfc_sli4_send_seq_to_ulp(vport, seq_dmabuf);
 }
 
 /**
@@ -11091,7 +11576,7 @@ lpfc_sli4_handle_received_buffer(struct lpfc_hba *phba)
  * sequential.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      EIO - The mailbox failed to complete successfully.
  *      When this error occurs, the driver is not guaranteed
  *      to have any rpi regions posted to the device and
@@ -11129,7 +11614,7 @@ lpfc_sli4_post_all_rpi_hdrs(struct lpfc_hba *phba)
  * maps up to 64 rpi context regions.
  *
  * Return codes
- *      0 - sucessful
+ *      0 - successful
  *      ENOMEM - No available memory
  *      EIO - The mailbox failed to complete successfully.
  **/
@@ -11191,7 +11676,7 @@ lpfc_sli4_post_rpi_hdr(struct lpfc_hba *phba, struct lpfc_rpi_hdr *rpi_page)
  * PAGE_SIZE modulo 64 rpi context headers.
  *
  * Returns
- *      A nonzero rpi defined as rpi_base <= rpi < max_rpi if sucessful
+ *      A nonzero rpi defined as rpi_base <= rpi < max_rpi if successful
  *      LPFC_RPI_ALLOC_ERROR if no rpis are available.
  **/
 int
@@ -11334,6 +11819,7 @@ lpfc_sli4_init_vpi(struct lpfc_hba *phba, uint16_t vpi)
 {
         LPFC_MBOXQ_t *mboxq;
         int rc = 0;
+        int retval = MBX_SUCCESS;
         uint32_t mbox_tmo;
 
         if (vpi == 0)
@@ -11344,16 +11830,17 @@ lpfc_sli4_init_vpi(struct lpfc_hba *phba, uint16_t vpi)
         lpfc_init_vpi(phba, mboxq, vpi);
         mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_INIT_VPI);
         rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
-        if (rc != MBX_TIMEOUT)
-                mempool_free(mboxq, phba->mbox_mem_pool);
         if (rc != MBX_SUCCESS) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "2022 INIT VPI Mailbox failed "
                                 "status %d, mbxStatus x%x\n", rc,
                                 bf_get(lpfc_mqe_status, &mboxq->u.mqe));
-                rc = -EIO;
+                retval = -EIO;
         }
-        return rc;
+        if (rc != MBX_TIMEOUT)
+                mempool_free(mboxq, phba->mbox_mem_pool);
+
+        return retval;
 }
 
 /**
@@ -11438,13 +11925,6 @@ lpfc_sli4_add_fcf_record(struct lpfc_hba *phba, struct fcf_record *fcf_record)
          */
         lpfc_sli4_mbx_sge_get(mboxq, 0, &sge);
         phys_addr = getPaddr(sge.pa_hi, sge.pa_lo);
-        if (unlikely(!mboxq->sge_array)) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
-                                "2526 Failed to get the non-embedded SGE "
-                                "virtual address\n");
-                lpfc_sli4_mbox_cmd_free(phba, mboxq);
-                return -ENOMEM;
-        }
         virt_addr = mboxq->sge_array->addr[0];
         /*
          * Configure the FCF record for FCFI 0.  This is the driver's
@@ -11517,24 +11997,22 @@ lpfc_sli4_build_dflt_fcf_record(struct lpfc_hba *phba,
 }
 
 /**
- * lpfc_sli4_read_fcf_record - Read the driver's default FCF Record.
+ * lpfc_sli4_fcf_scan_read_fcf_rec - Read hba fcf record for fcf scan.
  * @phba: pointer to lpfc hba data structure.
  * @fcf_index: FCF table entry offset.
  *
- * This routine is invoked to read up to @fcf_num of FCF record from the
- * device starting with the given @fcf_index.
+ * This routine is invoked to scan the entire FCF table by reading FCF
+ * record and processing it one at a time starting from the @fcf_index
+ * for initial FCF discovery or fast FCF failover rediscovery.
+ *
+ * Return 0 if the mailbox command is submitted sucessfully, none 0
+ * otherwise.
  **/
 int
-lpfc_sli4_read_fcf_record(struct lpfc_hba *phba, uint16_t fcf_index)
+lpfc_sli4_fcf_scan_read_fcf_rec(struct lpfc_hba *phba, uint16_t fcf_index)
 {
         int rc = 0, error;
         LPFC_MBOXQ_t *mboxq;
-        void *virt_addr;
-        dma_addr_t phys_addr;
-        uint8_t *bytep;
-        struct lpfc_mbx_sge sge;
-        uint32_t alloc_len, req_len;
-        struct lpfc_mbx_read_fcf_tbl *read_fcf;
 
         phba->fcoe_eventtag_at_fcf_scan = phba->fcoe_eventtag;
         mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
@@ -11542,59 +12020,347 @@ lpfc_sli4_read_fcf_record(struct lpfc_hba *phba, uint16_t fcf_index)
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                 "2000 Failed to allocate mbox for "
                                 "READ_FCF cmd\n");
-                return -ENOMEM;
+                error = -ENOMEM;
+                goto fail_fcf_scan;
         }
+        /* Construct the read FCF record mailbox command */
+        rc = lpfc_sli4_mbx_read_fcf_rec(phba, mboxq, fcf_index);
+        if (rc) {
+                error = -EINVAL;
+                goto fail_fcf_scan;
+        }
+        /* Issue the mailbox command asynchronously */
+        mboxq->vport = phba->pport;
+        mboxq->mbox_cmpl = lpfc_mbx_cmpl_fcf_scan_read_fcf_rec;
+        rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
+        if (rc == MBX_NOT_FINISHED)
+                error = -EIO;
+        else {
+                spin_lock_irq(&phba->hbalock);
+                phba->hba_flag |= FCF_DISC_INPROGRESS;
+                spin_unlock_irq(&phba->hbalock);
+                /* Reset FCF round robin index bmask for new scan */
+                if (fcf_index == LPFC_FCOE_FCF_GET_FIRST)
+                        memset(phba->fcf.fcf_rr_bmask, 0,
+                               sizeof(*phba->fcf.fcf_rr_bmask));
+                error = 0;
+        }
+fail_fcf_scan:
+        if (error) {
+                if (mboxq)
+                        lpfc_sli4_mbox_cmd_free(phba, mboxq);
+                /* FCF scan failed, clear FCF_DISC_INPROGRESS flag */
+                spin_lock_irq(&phba->hbalock);
+                phba->hba_flag &= ~FCF_DISC_INPROGRESS;
+                spin_unlock_irq(&phba->hbalock);
+        }
+        return error;
+}
 
-        req_len = sizeof(struct fcf_record) +
-                  sizeof(union lpfc_sli4_cfg_shdr) + 2 * sizeof(uint32_t);
+/**
+ * lpfc_sli4_fcf_rr_read_fcf_rec - Read hba fcf record for round robin fcf.
+ * @phba: pointer to lpfc hba data structure.
+ * @fcf_index: FCF table entry offset.
+ *
+ * This routine is invoked to read an FCF record indicated by @fcf_index
+ * and to use it for FLOGI round robin FCF failover.
+ *
+ * Return 0 if the mailbox command is submitted sucessfully, none 0
+ * otherwise.
+ **/
+int
+lpfc_sli4_fcf_rr_read_fcf_rec(struct lpfc_hba *phba, uint16_t fcf_index)
+{
+        int rc = 0, error;
+        LPFC_MBOXQ_t *mboxq;
 
-        /* Set up READ_FCF SLI4_CONFIG mailbox-ioctl command */
-        alloc_len = lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
-                         LPFC_MBOX_OPCODE_FCOE_READ_FCF_TABLE, req_len,
-                         LPFC_SLI4_MBX_NEMBED);
+        mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mboxq) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_INIT,
+                                "2763 Failed to allocate mbox for "
+                                "READ_FCF cmd\n");
+                error = -ENOMEM;
+                goto fail_fcf_read;
+        }
+        /* Construct the read FCF record mailbox command */
+        rc = lpfc_sli4_mbx_read_fcf_rec(phba, mboxq, fcf_index);
+        if (rc) {
+                error = -EINVAL;
+                goto fail_fcf_read;
+        }
+        /* Issue the mailbox command asynchronously */
+        mboxq->vport = phba->pport;
+        mboxq->mbox_cmpl = lpfc_mbx_cmpl_fcf_rr_read_fcf_rec;
+        rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
+        if (rc == MBX_NOT_FINISHED)
+                error = -EIO;
+        else
+                error = 0;
 
-        if (alloc_len < req_len) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "0291 Allocated DMA memory size (x%x) is "
-                                "less than the requested DMA memory "
-                                "size (x%x)\n", alloc_len, req_len);
+fail_fcf_read:
+        if (error && mboxq)
                 lpfc_sli4_mbox_cmd_free(phba, mboxq);
-                return -ENOMEM;
+        return error;
+}
+
+/**
+ * lpfc_sli4_read_fcf_rec - Read hba fcf record for update eligible fcf bmask.
+ * @phba: pointer to lpfc hba data structure.
+ * @fcf_index: FCF table entry offset.
+ *
+ * This routine is invoked to read an FCF record indicated by @fcf_index to
+ * determine whether it's eligible for FLOGI round robin failover list.
+ *
+ * Return 0 if the mailbox command is submitted sucessfully, none 0
+ * otherwise.
+ **/
+int
+lpfc_sli4_read_fcf_rec(struct lpfc_hba *phba, uint16_t fcf_index)
+{
+        int rc = 0, error;
+        LPFC_MBOXQ_t *mboxq;
+
+        mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mboxq) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_INIT,
+                                "2758 Failed to allocate mbox for "
+                                "READ_FCF cmd\n");
+                                error = -ENOMEM;
+                                goto fail_fcf_read;
+        }
+        /* Construct the read FCF record mailbox command */
+        rc = lpfc_sli4_mbx_read_fcf_rec(phba, mboxq, fcf_index);
+        if (rc) {
+                error = -EINVAL;
+                goto fail_fcf_read;
         }
+        /* Issue the mailbox command asynchronously */
+        mboxq->vport = phba->pport;
+        mboxq->mbox_cmpl = lpfc_mbx_cmpl_read_fcf_rec;
+        rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
+        if (rc == MBX_NOT_FINISHED)
+                error = -EIO;
+        else
+                error = 0;
 
-        /* Get the first SGE entry from the non-embedded DMA memory. This
-         * routine only uses a single SGE.
-         */
-        lpfc_sli4_mbx_sge_get(mboxq, 0, &sge);
-        phys_addr = getPaddr(sge.pa_hi, sge.pa_lo);
-        if (unlikely(!mboxq->sge_array)) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
-                                "2527 Failed to get the non-embedded SGE "
-                                "virtual address\n");
+fail_fcf_read:
+        if (error && mboxq)
                 lpfc_sli4_mbox_cmd_free(phba, mboxq);
+        return error;
+}
+
+/**
+ * lpfc_sli4_fcf_rr_next_index_get - Get next eligible fcf record index
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is to get the next eligible FCF record index in a round
+ * robin fashion. If the next eligible FCF record index equals to the
+ * initial round robin FCF record index, LPFC_FCOE_FCF_NEXT_NONE (0xFFFF)
+ * shall be returned, otherwise, the next eligible FCF record's index
+ * shall be returned.
+ **/
+uint16_t
+lpfc_sli4_fcf_rr_next_index_get(struct lpfc_hba *phba)
+{
+        uint16_t next_fcf_index;
+
+        /* Search from the currently registered FCF index */
+        next_fcf_index = find_next_bit(phba->fcf.fcf_rr_bmask,
+                                       LPFC_SLI4_FCF_TBL_INDX_MAX,
+                                       phba->fcf.current_rec.fcf_indx);
+        /* Wrap around condition on phba->fcf.fcf_rr_bmask */
+        if (next_fcf_index >= LPFC_SLI4_FCF_TBL_INDX_MAX)
+                next_fcf_index = find_next_bit(phba->fcf.fcf_rr_bmask,
+                                               LPFC_SLI4_FCF_TBL_INDX_MAX, 0);
+        /* Round robin failover stop condition */
+        if (next_fcf_index == phba->fcf.fcf_rr_init_indx)
+                return LPFC_FCOE_FCF_NEXT_NONE;
+
+        return next_fcf_index;
+}
+
+/**
+ * lpfc_sli4_fcf_rr_index_set - Set bmask with eligible fcf record index
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine sets the FCF record index in to the eligible bmask for
+ * round robin failover search. It checks to make sure that the index
+ * does not go beyond the range of the driver allocated bmask dimension
+ * before setting the bit.
+ *
+ * Returns 0 if the index bit successfully set, otherwise, it returns
+ * -EINVAL.
+ **/
+int
+lpfc_sli4_fcf_rr_index_set(struct lpfc_hba *phba, uint16_t fcf_index)
+{
+        if (fcf_index >= LPFC_SLI4_FCF_TBL_INDX_MAX) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
+                                "2610 HBA FCF index reached driver's "
+                                "book keeping dimension: fcf_index:%d, "
+                                "driver_bmask_max:%d\n",
+                                fcf_index, LPFC_SLI4_FCF_TBL_INDX_MAX);
+                return -EINVAL;
+        }
+        /* Set the eligible FCF record index bmask */
+        set_bit(fcf_index, phba->fcf.fcf_rr_bmask);
+
+        return 0;
+}
+
+/**
+ * lpfc_sli4_fcf_rr_index_set - Clear bmask from eligible fcf record index
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine clears the FCF record index from the eligible bmask for
+ * round robin failover search. It checks to make sure that the index
+ * does not go beyond the range of the driver allocated bmask dimension
+ * before clearing the bit.
+ **/
+void
+lpfc_sli4_fcf_rr_index_clear(struct lpfc_hba *phba, uint16_t fcf_index)
+{
+        if (fcf_index >= LPFC_SLI4_FCF_TBL_INDX_MAX) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
+                                "2762 HBA FCF index goes beyond driver's "
+                                "book keeping dimension: fcf_index:%d, "
+                                "driver_bmask_max:%d\n",
+                                fcf_index, LPFC_SLI4_FCF_TBL_INDX_MAX);
+                return;
+        }
+        /* Clear the eligible FCF record index bmask */
+        clear_bit(fcf_index, phba->fcf.fcf_rr_bmask);
+}
+
+/**
+ * lpfc_mbx_cmpl_redisc_fcf_table - completion routine for rediscover FCF table
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is the completion routine for the rediscover FCF table mailbox
+ * command. If the mailbox command returned failure, it will try to stop the
+ * FCF rediscover wait timer.
+ **/
+void
+lpfc_mbx_cmpl_redisc_fcf_table(struct lpfc_hba *phba, LPFC_MBOXQ_t *mbox)
+{
+        struct lpfc_mbx_redisc_fcf_tbl *redisc_fcf;
+        uint32_t shdr_status, shdr_add_status;
+
+        redisc_fcf = &mbox->u.mqe.un.redisc_fcf_tbl;
+
+        shdr_status = bf_get(lpfc_mbox_hdr_status,
+                             &redisc_fcf->header.cfg_shdr.response);
+        shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
+                             &redisc_fcf->header.cfg_shdr.response);
+        if (shdr_status || shdr_add_status) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
+                                "2746 Requesting for FCF rediscovery failed "
+                                "status x%x add_status x%x\n",
+                                shdr_status, shdr_add_status);
+                if (phba->fcf.fcf_flag & FCF_ACVL_DISC) {
+                        spin_lock_irq(&phba->hbalock);
+                        phba->fcf.fcf_flag &= ~FCF_ACVL_DISC;
+                        spin_unlock_irq(&phba->hbalock);
+                        /*
+                         * CVL event triggered FCF rediscover request failed,
+                         * last resort to re-try current registered FCF entry.
+                         */
+                        lpfc_retry_pport_discovery(phba);
+                } else {
+                        spin_lock_irq(&phba->hbalock);
+                        phba->fcf.fcf_flag &= ~FCF_DEAD_DISC;
+                        spin_unlock_irq(&phba->hbalock);
+                        /*
+                         * DEAD FCF event triggered FCF rediscover request
+                         * failed, last resort to fail over as a link down
+                         * to FCF registration.
+                         */
+                        lpfc_sli4_fcf_dead_failthrough(phba);
+                }
+        } else {
+                lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
+                                "2775 Start FCF rediscovery quiescent period "
+                                "wait timer before scaning FCF table\n");
+                /*
+                 * Start FCF rediscovery wait timer for pending FCF
+                 * before rescan FCF record table.
+                 */
+                lpfc_fcf_redisc_wait_start_timer(phba);
+        }
+
+        mempool_free(mbox, phba->mbox_mem_pool);
+}
+
+/**
+ * lpfc_sli4_redisc_all_fcf - Request to rediscover entire FCF table by port.
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is invoked to request for rediscovery of the entire FCF table
+ * by the port.
+ **/
+int
+lpfc_sli4_redisc_fcf_table(struct lpfc_hba *phba)
+{
+        LPFC_MBOXQ_t *mbox;
+        struct lpfc_mbx_redisc_fcf_tbl *redisc_fcf;
+        int rc, length;
+
+        /* Cancel retry delay timers to all vports before FCF rediscover */
+        lpfc_cancel_all_vport_retry_delay_timer(phba);
+
+        mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mbox) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "2745 Failed to allocate mbox for "
+                                "requesting FCF rediscover.\n");
                 return -ENOMEM;
         }
-        virt_addr = mboxq->sge_array->addr[0];
-        read_fcf = (struct lpfc_mbx_read_fcf_tbl *)virt_addr;
 
-        /* Set up command fields */
-        bf_set(lpfc_mbx_read_fcf_tbl_indx, &read_fcf->u.request, fcf_index);
-        /* Perform necessary endian conversion */
-        bytep = virt_addr + sizeof(union lpfc_sli4_cfg_shdr);
-        lpfc_sli_pcimem_bcopy(bytep, bytep, sizeof(uint32_t));
-        mboxq->vport = phba->pport;
-        mboxq->mbox_cmpl = lpfc_mbx_cmpl_read_fcf_record;
-        rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
+        length = (sizeof(struct lpfc_mbx_redisc_fcf_tbl) -
+                  sizeof(struct lpfc_sli4_cfg_mhdr));
+        lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
+                         LPFC_MBOX_OPCODE_FCOE_REDISCOVER_FCF,
+                         length, LPFC_SLI4_MBX_EMBED);
+
+        redisc_fcf = &mbox->u.mqe.un.redisc_fcf_tbl;
+        /* Set count to 0 for invalidating the entire FCF database */
+        bf_set(lpfc_mbx_redisc_fcf_count, redisc_fcf, 0);
+
+        /* Issue the mailbox command asynchronously */
+        mbox->vport = phba->pport;
+        mbox->mbox_cmpl = lpfc_mbx_cmpl_redisc_fcf_table;
+        rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
+
         if (rc == MBX_NOT_FINISHED) {
-                lpfc_sli4_mbox_cmd_free(phba, mboxq);
-                error = -EIO;
-        } else {
-                spin_lock_irq(&phba->hbalock);
-                phba->hba_flag |= FCF_DISC_INPROGRESS;
-                spin_unlock_irq(&phba->hbalock);
-                error = 0;
+                mempool_free(mbox, phba->mbox_mem_pool);
+                return -EIO;
         }
-        return error;
+        return 0;
+}
+
+/**
+ * lpfc_sli4_fcf_dead_failthrough - Failthrough routine to fcf dead event
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This function is the failover routine as a last resort to the FCF DEAD
+ * event when driver failed to perform fast FCF failover.
+ **/
+void
+lpfc_sli4_fcf_dead_failthrough(struct lpfc_hba *phba)
+{
+        uint32_t link_state;
+
+        /*
+         * Last resort as FCF DEAD event failover will treat this as
+         * a link down, but save the link state because we don't want
+         * it to be changed to Link Down unless it is already down.
+         */
+        link_state = phba->link_state;
+        lpfc_linkdown(phba);
+        phba->link_state = link_state;
+
+        /* Unregister FCF if no devices connected to it */
+        lpfc_unregister_unused_fcf(phba);
 }
 
 /**
@@ -11725,3 +12491,48 @@ out:
         kfree(rgn23_data);
         return;
 }
+
+/**
+ * lpfc_cleanup_pending_mbox - Free up vport discovery mailbox commands.
+ * @vport: pointer to vport data structure.
+ *
+ * This function iterate through the mailboxq and clean up all REG_LOGIN
+ * and REG_VPI mailbox commands associated with the vport. This function
+ * is called when driver want to restart discovery of the vport due to
+ * a Clear Virtual Link event.
+ **/
+void
+lpfc_cleanup_pending_mbox(struct lpfc_vport *vport)
+{
+        struct lpfc_hba *phba = vport->phba;
+        LPFC_MBOXQ_t *mb, *nextmb;
+        struct lpfc_dmabuf *mp;
+
+        spin_lock_irq(&phba->hbalock);
+        list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) {
+                if (mb->vport != vport)
+                        continue;
+
+                if ((mb->u.mb.mbxCommand != MBX_REG_LOGIN64) &&
+                        (mb->u.mb.mbxCommand != MBX_REG_VPI))
+                        continue;
+
+                if (mb->u.mb.mbxCommand == MBX_REG_LOGIN64) {
+                        mp = (struct lpfc_dmabuf *) (mb->context1);
+                        if (mp) {
+                                __lpfc_mbuf_free(phba, mp->virt, mp->phys);
+                                kfree(mp);
+                        }
+                }
+                list_del(&mb->list);
+                mempool_free(mb, phba->mbox_mem_pool);
+        }
+        mb = phba->sli.mbox_active;
+        if (mb && (mb->vport == vport)) {
+                if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) ||
+                        (mb->u.mb.mbxCommand == MBX_REG_VPI))
+                        mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
+        }
+        spin_unlock_irq(&phba->hbalock);
+}
+
diff --git a/drivers/scsi/lpfc/lpfc_sli.h b/drivers/scsi/lpfc/lpfc_sli.h
index 3c53316cf6d0..b4a639c47616 100644
--- a/drivers/scsi/lpfc/lpfc_sli.h
+++ b/drivers/scsi/lpfc/lpfc_sli.h
@@ -29,14 +29,17 @@ typedef enum _lpfc_ctx_cmd {
         LPFC_CTX_HOST
 } lpfc_ctx_cmd;
 
-/* This structure is used to carry the needed response IOCB states */
-struct lpfc_sli4_rspiocb_info {
-        uint8_t hw_status;
-        uint8_t bfield;
-#define LPFC_XB 0x1
-#define LPFC_PV 0x2
-        uint8_t priority;
-        uint8_t reserved;
+struct lpfc_cq_event {
+        struct list_head list;
+        union {
+                struct lpfc_mcqe                mcqe_cmpl;
+                struct lpfc_acqe_link           acqe_link;
+                struct lpfc_acqe_fcoe           acqe_fcoe;
+                struct lpfc_acqe_dcbx           acqe_dcbx;
+                struct lpfc_rcqe                rcqe_cmpl;
+                struct sli4_wcqe_xri_aborted    wcqe_axri;
+                struct lpfc_wcqe_complete       wcqe_cmpl;
+        } cqe;
 };
 
 /* This structure is used to handle IOCB requests / responses */
@@ -46,21 +49,27 @@ struct lpfc_iocbq {
         struct list_head clist;
         uint16_t iotag;         /* pre-assigned IO tag */
         uint16_t sli4_xritag;   /* pre-assigned XRI, (OXID) tag. */
+        struct lpfc_cq_event cq_event;
 
         IOCB_t iocb;            /* IOCB cmd */
         uint8_t retry;          /* retry counter for IOCB cmd - if needed */
-        uint8_t iocb_flag;
+        uint16_t iocb_flag;
 #define LPFC_IO_LIBDFC          1       /* libdfc iocb */
 #define LPFC_IO_WAKE            2       /* High Priority Queue signal flag */
 #define LPFC_IO_FCP             4       /* FCP command -- iocbq in scsi_buf */
 #define LPFC_DRIVER_ABORTED     8       /* driver aborted this request */
 #define LPFC_IO_FABRIC          0x10    /* Iocb send using fabric scheduler */
 #define LPFC_DELAY_MEM_FREE     0x20    /* Defer free'ing of FC data */
-#define LPFC_FIP_ELS            0x40
+#define LPFC_EXCHANGE_BUSY      0x40    /* SLI4 hba reported XB in response */
+#define LPFC_USE_FCPWQIDX       0x80    /* Submit to specified FCPWQ index */
+#define DSS_SECURITY_OP         0x100   /* security IO */
+
+#define LPFC_FIP_ELS_ID_MASK    0xc000  /* ELS_ID range 0-3, non-shifted mask */
+#define LPFC_FIP_ELS_ID_SHIFT   14
 
-        uint8_t abort_count;
         uint8_t rsvd2;
         uint32_t drvrTimeout;   /* driver timeout in seconds */
+        uint32_t fcp_wqidx;     /* index to FCP work queue */
         struct lpfc_vport *vport;/* virtual port pointer */
         void *context1;         /* caller context information */
         void *context2;         /* caller context information */
@@ -76,7 +85,6 @@ struct lpfc_iocbq {
                            struct lpfc_iocbq *);
         void (*iocb_cmpl) (struct lpfc_hba *, struct lpfc_iocbq *,
                            struct lpfc_iocbq *);
-        struct lpfc_sli4_rspiocb_info sli4_info;
 };
 
 #define SLI_IOCB_RET_IOCB      1        /* Return IOCB if cmd ring full */
@@ -110,7 +118,7 @@ typedef struct lpfcMboxq {
                                    return */
 #define MBX_NOWAIT      2       /* issue command then return immediately */
 
-#define LPFC_MAX_RING_MASK  4   /* max num of rctl/type masks allowed per
+#define LPFC_MAX_RING_MASK  5   /* max num of rctl/type masks allowed per
                                    ring */
 #define LPFC_MAX_RING       4   /* max num of SLI rings used by driver */
 
diff --git a/drivers/scsi/lpfc/lpfc_sli4.h b/drivers/scsi/lpfc/lpfc_sli4.h
index b5f4ba1a5c27..4a35e7b9bc5b 100644
--- a/drivers/scsi/lpfc/lpfc_sli4.h
+++ b/drivers/scsi/lpfc/lpfc_sli4.h
@@ -22,13 +22,17 @@
 #define LPFC_RELEASE_NOTIFICATION_INTERVAL      32
 #define LPFC_GET_QE_REL_INT                     32
 #define LPFC_RPI_LOW_WATER_MARK                 10
+
+/* Amount of time in seconds for waiting FCF rediscovery to complete */
+#define LPFC_FCF_REDISCOVER_WAIT_TMO            2000 /* msec */
+
 /* Number of SGL entries can be posted in a 4KB nonembedded mbox command */
 #define LPFC_NEMBED_MBOX_SGL_CNT                254
 
 /* Multi-queue arrangement for fast-path FCP work queues */
 #define LPFC_FN_EQN_MAX       8
 #define LPFC_SP_EQN_DEF       1
-#define LPFC_FP_EQN_DEF       1
+#define LPFC_FP_EQN_DEF       4
 #define LPFC_FP_EQN_MIN       1
 #define LPFC_FP_EQN_MAX       (LPFC_FN_EQN_MAX - LPFC_SP_EQN_DEF)
 
@@ -58,6 +62,16 @@
 #define LPFC_FCOE_FKA_ADV_PER   0
 #define LPFC_FCOE_FIP_PRIORITY  0x80
 
+#define sli4_sid_from_fc_hdr(fc_hdr)  \
+        ((fc_hdr)->fh_s_id[0] << 16 | \
+         (fc_hdr)->fh_s_id[1] <<  8 | \
+         (fc_hdr)->fh_s_id[2])
+
+#define sli4_fctl_from_fc_hdr(fc_hdr)  \
+        ((fc_hdr)->fh_f_ctl[0] << 16 | \
+         (fc_hdr)->fh_f_ctl[1] <<  8 | \
+         (fc_hdr)->fh_f_ctl[2])
+
 enum lpfc_sli4_queue_type {
         LPFC_EQ,
         LPFC_GCQ,
@@ -110,44 +124,56 @@ struct lpfc_queue {
         union sli4_qe qe[1];    /* array to index entries (must be last) */
 };
 
-struct lpfc_cq_event {
-        struct list_head list;
-        union {
-                struct lpfc_mcqe                mcqe_cmpl;
-                struct lpfc_acqe_link           acqe_link;
-                struct lpfc_acqe_fcoe           acqe_fcoe;
-                struct lpfc_acqe_dcbx           acqe_dcbx;
-                struct lpfc_rcqe                rcqe_cmpl;
-                struct sli4_wcqe_xri_aborted    wcqe_axri;
-        } cqe;
-};
-
 struct lpfc_sli4_link {
         uint8_t speed;
         uint8_t duplex;
         uint8_t status;
         uint8_t physical;
         uint8_t fault;
+        uint16_t logical_speed;
 };
 
-struct lpfc_fcf {
-        uint8_t  fabric_name[8];
-        uint8_t  switch_name[8];
+struct lpfc_fcf_rec {
+        uint8_t  fabric_name[8];
+        uint8_t  switch_name[8];
         uint8_t  mac_addr[6];
         uint16_t fcf_indx;
+        uint32_t priority;
+        uint16_t vlan_id;
+        uint32_t addr_mode;
+        uint32_t flag;
+#define BOOT_ENABLE     0x01
+#define RECORD_VALID    0x02
+};
+
+struct lpfc_fcf {
         uint16_t fcfi;
         uint32_t fcf_flag;
 #define FCF_AVAILABLE   0x01 /* FCF available for discovery */
 #define FCF_REGISTERED  0x02 /* FCF registered with FW */
-#define FCF_DISCOVERED  0x04 /* FCF discovery started  */
-#define FCF_BOOT_ENABLE 0x08 /* Boot bios use this FCF */
-#define FCF_IN_USE      0x10 /* Atleast one discovery completed */
-#define FCF_VALID_VLAN  0x20 /* Use the vlan id specified */
-        uint32_t priority;
+#define FCF_SCAN_DONE   0x04 /* FCF table scan done */
+#define FCF_IN_USE      0x08 /* Atleast one discovery completed */
+#define FCF_INIT_DISC   0x10 /* Initial FCF discovery */
+#define FCF_DEAD_DISC   0x20 /* FCF DEAD fast FCF failover discovery */
+#define FCF_ACVL_DISC   0x40 /* All CVL fast FCF failover discovery */
+#define FCF_DISCOVERY   (FCF_INIT_DISC | FCF_DEAD_DISC | FCF_ACVL_DISC)
+#define FCF_REDISC_PEND 0x80 /* FCF rediscovery pending */
+#define FCF_REDISC_EVT  0x100 /* FCF rediscovery event to worker thread */
+#define FCF_REDISC_FOV  0x200 /* Post FCF rediscovery fast failover */
         uint32_t addr_mode;
-        uint16_t vlan_id;
+        uint16_t fcf_rr_init_indx;
+        struct lpfc_fcf_rec current_rec;
+        struct lpfc_fcf_rec failover_rec;
+        struct timer_list redisc_wait;
+        unsigned long *fcf_rr_bmask; /* Eligible FCF indexes for RR failover */
 };
 
+/*
+ * Maximum FCF table index, it is for driver internal book keeping, it
+ * just needs to be no less than the supported HBA's FCF table size.
+ */
+#define LPFC_SLI4_FCF_TBL_INDX_MAX      32
+
 #define LPFC_REGION23_SIGNATURE "RG23"
 #define LPFC_REGION23_VERSION   1
 #define LPFC_REGION23_LAST_REC  0xff
@@ -166,7 +192,7 @@ struct lpfc_fip_param_hdr {
 #define lpfc_fip_param_hdr_fipp_mode_SHIFT      6
 #define lpfc_fip_param_hdr_fipp_mode_MASK       0x3
 #define lpfc_fip_param_hdr_fipp_mode_WORD       parm_flags
-#define FIPP_MODE_ON                            0x2
+#define FIPP_MODE_ON                            0x1
 #define FIPP_MODE_OFF                           0x0
 #define FIPP_VLAN_VALID                         0x1
 };
@@ -250,7 +276,10 @@ struct lpfc_bmbx {
 #define SLI4_CT_VFI 2
 #define SLI4_CT_FCFI 3
 
-#define LPFC_SLI4_MAX_SEGMENT_SIZE 0x10000
+#define LPFC_SLI4_FL1_MAX_SEGMENT_SIZE  0x10000
+#define LPFC_SLI4_FL1_MAX_BUF_SIZE      0X2000
+#define LPFC_SLI4_MIN_BUF_SIZE          0x400
+#define LPFC_SLI4_MAX_BUF_SIZE          0x20000
 
 /*
  * SLI4 specific data structures
@@ -284,6 +313,42 @@ struct lpfc_fcp_eq_hdl {
         struct lpfc_hba *phba;
 };
 
+/* Port Capabilities for SLI4 Parameters */
+struct lpfc_pc_sli4_params {
+        uint32_t supported;
+        uint32_t if_type;
+        uint32_t sli_rev;
+        uint32_t sli_family;
+        uint32_t featurelevel_1;
+        uint32_t featurelevel_2;
+        uint32_t proto_types;
+#define LPFC_SLI4_PROTO_FCOE    0x0000001
+#define LPFC_SLI4_PROTO_FC      0x0000002
+#define LPFC_SLI4_PROTO_NIC     0x0000004
+#define LPFC_SLI4_PROTO_ISCSI   0x0000008
+#define LPFC_SLI4_PROTO_RDMA    0x0000010
+        uint32_t sge_supp_len;
+        uint32_t if_page_sz;
+        uint32_t rq_db_window;
+        uint32_t loopbk_scope;
+        uint32_t eq_pages_max;
+        uint32_t eqe_size;
+        uint32_t cq_pages_max;
+        uint32_t cqe_size;
+        uint32_t mq_pages_max;
+        uint32_t mqe_size;
+        uint32_t mq_elem_cnt;
+        uint32_t wq_pages_max;
+        uint32_t wqe_size;
+        uint32_t rq_pages_max;
+        uint32_t rqe_size;
+        uint32_t hdr_pages_max;
+        uint32_t hdr_size;
+        uint32_t hdr_pp_align;
+        uint32_t sgl_pages_max;
+        uint32_t sgl_pp_align;
+};
+
 /* SLI4 HBA data structure entries */
 struct lpfc_sli4_hba {
         void __iomem *conf_regs_memmap_p; /* Kernel memory mapped address for
@@ -295,10 +360,9 @@ struct lpfc_sli4_hba {
         /* BAR0 PCI config space register memory map */
         void __iomem *UERRLOregaddr; /* Address to UERR_STATUS_LO register */
         void __iomem *UERRHIregaddr; /* Address to UERR_STATUS_HI register */
-        void __iomem *ONLINE0regaddr; /* Address to components of internal UE */
-        void __iomem *ONLINE1regaddr; /* Address to components of internal UE */
-#define LPFC_ONLINE_NERR        0xFFFFFFFF
-        void __iomem *SCRATCHPADregaddr; /* Address to scratchpad register */
+        void __iomem *UEMASKLOregaddr; /* Address to UE_MASK_LO register */
+        void __iomem *UEMASKHIregaddr; /* Address to UE_MASK_HI register */
+        void __iomem *SLIINTFregaddr; /* Address to SLI_INTF register */
         /* BAR1 FCoE function CSR register memory map */
         void __iomem *STAregaddr;    /* Address to HST_STATE register */
         void __iomem *ISRregaddr;    /* Address to HST_ISR register */
@@ -311,6 +375,10 @@ struct lpfc_sli4_hba {
         void __iomem *MQDBregaddr;   /* Address to MQ_DOORBELL register */
         void __iomem *BMBXregaddr;   /* Address to BootStrap MBX register */
 
+        uint32_t ue_mask_lo;
+        uint32_t ue_mask_hi;
+        struct lpfc_register sli_intf;
+        struct lpfc_pc_sli4_params pc_sli4_params;
         struct msix_entry *msix_entries;
         uint32_t cfg_eqn;
         struct lpfc_fcp_eq_hdl *fcp_eq_hdl; /* FCP per-WQ handle */
@@ -325,7 +393,6 @@ struct lpfc_sli4_hba {
         struct lpfc_queue **fcp_cq;/* Fast-path FCP compl queue */
         struct lpfc_queue *mbx_cq; /* Slow-path mailbox complete queue */
         struct lpfc_queue *els_cq; /* Slow-path ELS response complete queue */
-        struct lpfc_queue *rxq_cq; /* Slow-path unsolicited complete queue */
 
         /* Setup information for various queue parameters */
         int eq_esize;
@@ -360,7 +427,7 @@ struct lpfc_sli4_hba {
         unsigned long *rpi_bmask;
         uint16_t rpi_count;
         struct lpfc_sli4_flags sli4_flags;
-        struct list_head sp_rspiocb_work_queue;
+        struct list_head sp_queue_event;
         struct list_head sp_cqe_event_pool;
         struct list_head sp_asynce_work_queue;
         struct list_head sp_fcp_xri_aborted_work_queue;
@@ -376,11 +443,18 @@ enum lpfc_sge_type {
         SCSI_BUFF_TYPE
 };
 
+enum lpfc_sgl_state {
+        SGL_FREED,
+        SGL_ALLOCATED,
+        SGL_XRI_ABORTED
+};
+
 struct lpfc_sglq {
         /* lpfc_sglqs are used in double linked lists */
         struct list_head list;
         struct list_head clist;
         enum lpfc_sge_type buff_type; /* is this a scsi sgl */
+        enum lpfc_sgl_state state;
         uint16_t iotag;         /* pre-assigned IO tag */
         uint16_t sli4_xritag;   /* pre-assigned XRI, (OXID) tag. */
         struct sli4_sge *sgl;   /* pre-assigned SGL */
@@ -408,6 +482,8 @@ void lpfc_sli4_mbox_cmd_free(struct lpfc_hba *, struct lpfcMboxq *);
 void lpfc_sli4_mbx_sge_set(struct lpfcMboxq *, uint32_t, dma_addr_t, uint32_t);
 void lpfc_sli4_mbx_sge_get(struct lpfcMboxq *, uint32_t,
                            struct lpfc_mbx_sge *);
+int lpfc_sli4_mbx_read_fcf_rec(struct lpfc_hba *, struct lpfcMboxq *,
+                               uint16_t);
 
 void lpfc_sli4_hba_reset(struct lpfc_hba *);
 struct lpfc_queue *lpfc_sli4_queue_alloc(struct lpfc_hba *, uint32_t,
@@ -450,6 +526,7 @@ int lpfc_sli4_alloc_rpi(struct lpfc_hba *);
 void lpfc_sli4_free_rpi(struct lpfc_hba *, int);
 void lpfc_sli4_remove_rpis(struct lpfc_hba *);
 void lpfc_sli4_async_event_proc(struct lpfc_hba *);
+void lpfc_sli4_fcf_redisc_event_proc(struct lpfc_hba *);
 int lpfc_sli4_resume_rpi(struct lpfc_nodelist *);
 void lpfc_sli4_fcp_xri_abort_event_proc(struct lpfc_hba *);
 void lpfc_sli4_els_xri_abort_event_proc(struct lpfc_hba *);
@@ -465,8 +542,13 @@ int lpfc_sli4_init_vpi(struct lpfc_hba *, uint16_t);
 uint32_t lpfc_sli4_cq_release(struct lpfc_queue *, bool);
 uint32_t lpfc_sli4_eq_release(struct lpfc_queue *, bool);
 void lpfc_sli4_fcfi_unreg(struct lpfc_hba *, uint16_t);
-int lpfc_sli4_read_fcf_record(struct lpfc_hba *, uint16_t);
-void lpfc_mbx_cmpl_read_fcf_record(struct lpfc_hba *, LPFC_MBOXQ_t *);
+int lpfc_sli4_fcf_scan_read_fcf_rec(struct lpfc_hba *, uint16_t);
+int lpfc_sli4_fcf_rr_read_fcf_rec(struct lpfc_hba *, uint16_t);
+int lpfc_sli4_read_fcf_rec(struct lpfc_hba *, uint16_t);
+void lpfc_mbx_cmpl_fcf_scan_read_fcf_rec(struct lpfc_hba *, LPFC_MBOXQ_t *);
+void lpfc_mbx_cmpl_fcf_rr_read_fcf_rec(struct lpfc_hba *, LPFC_MBOXQ_t *);
+void lpfc_mbx_cmpl_read_fcf_rec(struct lpfc_hba *, LPFC_MBOXQ_t *);
+int lpfc_sli4_unregister_fcf(struct lpfc_hba *);
 int lpfc_sli4_post_status_check(struct lpfc_hba *);
 uint8_t lpfc_sli4_mbox_opcode_get(struct lpfc_hba *, struct lpfcMboxq *);
 
diff --git a/drivers/scsi/lpfc/lpfc_version.h b/drivers/scsi/lpfc/lpfc_version.h
index 9ae20af4bdb7..013deec5dae8 100644
--- a/drivers/scsi/lpfc/lpfc_version.h
+++ b/drivers/scsi/lpfc/lpfc_version.h
@@ -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-2010 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -18,8 +18,7 @@
  * included with this package.                                     *
  *******************************************************************/
 
-#define LPFC_DRIVER_VERSION "8.3.4"
-
+#define LPFC_DRIVER_VERSION "8.3.10"
 #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/lpfc/lpfc_vport.c b/drivers/scsi/lpfc/lpfc_vport.c
index 606efa767548..ffd575c379f3 100644
--- a/drivers/scsi/lpfc/lpfc_vport.c
+++ b/drivers/scsi/lpfc/lpfc_vport.c
@@ -26,6 +26,7 @@
 #include <linux/interrupt.h>
 #include <linux/kthread.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 #include <linux/spinlock.h>
 
 #include <scsi/scsi.h>
@@ -123,7 +124,12 @@ lpfc_vport_sparm(struct lpfc_hba *phba, struct lpfc_vport *vport)
         }
         mb = &pmb->u.mb;
 
-        lpfc_read_sparam(phba, pmb, vport->vpi);
+        rc = lpfc_read_sparam(phba, pmb, vport->vpi);
+        if (rc) {
+                mempool_free(pmb, phba->mbox_mem_pool);
+                return -ENOMEM;
+        }
+
         /*
          * Grab buffer pointer and clear context1 so we can use
          * lpfc_sli_issue_box_wait
@@ -389,7 +395,7 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable)
          * by the port.
          */
         if ((phba->sli_rev == LPFC_SLI_REV4) &&
-                (pport->vfi_state & LPFC_VFI_REGISTERED)) {
+                (pport->fc_flag & FC_VFI_REGISTERED)) {
                 rc = lpfc_sli4_init_vpi(phba, vpi);
                 if (rc) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
@@ -505,6 +511,7 @@ enable_vport(struct fc_vport *fc_vport)
         struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
         struct lpfc_hba   *phba = vport->phba;
         struct lpfc_nodelist *ndlp = NULL;
+        struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 
         if ((phba->link_state < LPFC_LINK_UP) ||
             (phba->fc_topology == TOPOLOGY_LOOP)) {
@@ -512,8 +519,10 @@ enable_vport(struct fc_vport *fc_vport)
                 return VPORT_OK;
         }
 
+        spin_lock_irq(shost->host_lock);
         vport->load_flag |= FC_LOADING;
         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
+        spin_unlock_irq(shost->host_lock);
 
         /* Use the Physical nodes Fabric NDLP to determine if the link is
          * up and ready to FDISC.
@@ -700,6 +709,8 @@ lpfc_vport_delete(struct fc_vport *fc_vport)
                         }
                         spin_unlock_irq(&phba->ndlp_lock);
                 }
+                if (!(vport->vpi_state & LPFC_VPI_REGISTERED))
+                        goto skip_logo;
                 vport->unreg_vpi_cmpl = VPORT_INVAL;
                 timeout = msecs_to_jiffies(phba->fc_ratov * 2000);
                 if (!lpfc_issue_els_npiv_logo(vport, ndlp))
diff --git a/drivers/scsi/mac_esp.c b/drivers/scsi/mac_esp.c
index c24e86f07804..3893337e3dd3 100644
--- a/drivers/scsi/mac_esp.c
+++ b/drivers/scsi/mac_esp.c
@@ -19,10 +19,10 @@
 #include <linux/delay.h>
 #include <linux/io.h>
 #include <linux/nubus.h>
+#include <linux/slab.h>
 
 #include <asm/irq.h>
 #include <asm/dma.h>
-
 #include <asm/macints.h>
 #include <asm/macintosh.h>
 
@@ -53,7 +53,6 @@ struct mac_esp_priv {
         void __iomem *pdma_io;
         int error;
 };
-static struct platform_device *internal_pdev, *external_pdev;
 static struct esp *esp_chips[2];
 
 #define MAC_ESP_GET_PRIV(esp) ((struct mac_esp_priv *) \
@@ -279,24 +278,27 @@ static void mac_esp_send_pdma_cmd(struct esp *esp, u32 addr, u32 esp_count,
  * Programmed IO routines follow.
  */
 
-static inline int mac_esp_wait_for_fifo(struct esp *esp)
+static inline unsigned int mac_esp_wait_for_fifo(struct esp *esp)
 {
         int i = 500000;
 
         do {
-                if (esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES)
-                        return 0;
+                unsigned int fbytes = esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES;
+
+                if (fbytes)
+                        return fbytes;
 
                 udelay(2);
         } while (--i);
 
         printk(KERN_ERR PFX "FIFO is empty (sreg %02x)\n",
                esp_read8(ESP_STATUS));
-        return 1;
+        return 0;
 }
 
 static inline int mac_esp_wait_for_intr(struct esp *esp)
 {
+        struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
         int i = 500000;
 
         do {
@@ -308,6 +310,7 @@ static inline int mac_esp_wait_for_intr(struct esp *esp)
         } while (--i);
 
         printk(KERN_ERR PFX "IRQ timeout (sreg %02x)\n", esp->sreg);
+        mep->error = 1;
         return 1;
 }
 
@@ -347,11 +350,10 @@ static inline int mac_esp_wait_for_intr(struct esp *esp)
 static void mac_esp_send_pio_cmd(struct esp *esp, u32 addr, u32 esp_count,
                                  u32 dma_count, int write, u8 cmd)
 {
-        unsigned long flags;
         struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
         u8 *fifo = esp->regs + ESP_FDATA * 16;
 
-        local_irq_save(flags);
+        disable_irq(esp->host->irq);
 
         cmd &= ~ESP_CMD_DMA;
         mep->error = 0;
@@ -359,11 +361,35 @@ static void mac_esp_send_pio_cmd(struct esp *esp, u32 addr, u32 esp_count,
         if (write) {
                 scsi_esp_cmd(esp, cmd);
 
-                if (!mac_esp_wait_for_intr(esp)) {
-                        if (mac_esp_wait_for_fifo(esp))
-                                esp_count = 0;
-                } else {
-                        esp_count = 0;
+                while (1) {
+                        unsigned int n;
+
+                        n = mac_esp_wait_for_fifo(esp);
+                        if (!n)
+                                break;
+
+                        if (n > esp_count)
+                                n = esp_count;
+                        esp_count -= n;
+
+                        MAC_ESP_PIO_LOOP("%2@,%0@+", n);
+
+                        if (!esp_count)
+                                break;
+
+                        if (mac_esp_wait_for_intr(esp))
+                                break;
+
+                        if (((esp->sreg & ESP_STAT_PMASK) != ESP_DIP) &&
+                            ((esp->sreg & ESP_STAT_PMASK) != ESP_MIP))
+                                break;
+
+                        esp->ireg = esp_read8(ESP_INTRPT);
+                        if ((esp->ireg & (ESP_INTR_DC | ESP_INTR_BSERV)) !=
+                            ESP_INTR_BSERV)
+                                break;
+
+                        scsi_esp_cmd(esp, ESP_CMD_TI);
                 }
         } else {
                 scsi_esp_cmd(esp, ESP_CMD_FLUSH);
@@ -374,47 +400,24 @@ static void mac_esp_send_pio_cmd(struct esp *esp, u32 addr, u32 esp_count,
                         MAC_ESP_PIO_LOOP("%0@+,%2@", esp_count);
 
                 scsi_esp_cmd(esp, cmd);
-        }
-
-        while (esp_count) {
-                unsigned int n;
 
-                if (mac_esp_wait_for_intr(esp)) {
-                        mep->error = 1;
-                        break;
-                }
-
-                if (esp->sreg & ESP_STAT_SPAM) {
-                        printk(KERN_ERR PFX "gross error\n");
-                        mep->error = 1;
-                        break;
-                }
-
-                n = esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES;
-
-                if (write) {
-                        if (n > esp_count)
-                                n = esp_count;
-                        esp_count -= n;
-
-                        MAC_ESP_PIO_LOOP("%2@,%0@+", n);
+                while (esp_count) {
+                        unsigned int n;
 
-                        if ((esp->sreg & ESP_STAT_PMASK) == ESP_STATP)
+                        if (mac_esp_wait_for_intr(esp))
                                 break;
 
-                        if (esp_count) {
-                                esp->ireg = esp_read8(ESP_INTRPT);
-                                if (esp->ireg & ESP_INTR_DC)
-                                        break;
+                        if (((esp->sreg & ESP_STAT_PMASK) != ESP_DOP) &&
+                            ((esp->sreg & ESP_STAT_PMASK) != ESP_MOP))
+                                break;
 
-                                scsi_esp_cmd(esp, ESP_CMD_TI);
-                        }
-                } else {
                         esp->ireg = esp_read8(ESP_INTRPT);
-                        if (esp->ireg & ESP_INTR_DC)
+                        if ((esp->ireg & (ESP_INTR_DC | ESP_INTR_BSERV)) !=
+                            ESP_INTR_BSERV)
                                 break;
 
-                        n = MAC_ESP_FIFO_SIZE - n;
+                        n = MAC_ESP_FIFO_SIZE -
+                            (esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES);
                         if (n > esp_count)
                                 n = esp_count;
 
@@ -429,7 +432,7 @@ static void mac_esp_send_pio_cmd(struct esp *esp, u32 addr, u32 esp_count,
                 }
         }
 
-        local_irq_restore(flags);
+        enable_irq(esp->host->irq);
 }
 
 static int mac_esp_irq_pending(struct esp *esp)
@@ -492,29 +495,12 @@ static int __devinit esp_mac_probe(struct platform_device *dev)
         struct Scsi_Host *host;
         struct esp *esp;
         int err;
-        int chips_present;
         struct mac_esp_priv *mep;
 
         if (!MACH_IS_MAC)
                 return -ENODEV;
 
-        switch (macintosh_config->scsi_type) {
-        case MAC_SCSI_QUADRA:
-        case MAC_SCSI_QUADRA3:
-                chips_present = 1;
-                break;
-        case MAC_SCSI_QUADRA2:
-                if ((macintosh_config->ident == MAC_MODEL_Q900) ||
-                    (macintosh_config->ident == MAC_MODEL_Q950))
-                        chips_present = 2;
-                else
-                        chips_present = 1;
-                break;
-        default:
-                chips_present = 0;
-        }
-
-        if (dev->id + 1 > chips_present)
+        if (dev->id > 1)
                 return -ENODEV;
 
         host = scsi_host_alloc(tpnt, sizeof(struct esp));
@@ -639,55 +625,26 @@ static struct platform_driver esp_mac_driver = {
         .probe    = esp_mac_probe,
         .remove   = __devexit_p(esp_mac_remove),
         .driver   = {
-                .name     = DRV_MODULE_NAME,
+                .name   = DRV_MODULE_NAME,
+                .owner  = THIS_MODULE,
         },
 };
 
 static int __init mac_esp_init(void)
 {
-        int err;
-
-        err = platform_driver_register(&esp_mac_driver);
-        if (err)
-                return err;
-
-        internal_pdev = platform_device_alloc(DRV_MODULE_NAME, 0);
-        if (internal_pdev && platform_device_add(internal_pdev)) {
-                platform_device_put(internal_pdev);
-                internal_pdev = NULL;
-        }
-        external_pdev = platform_device_alloc(DRV_MODULE_NAME, 1);
-        if (external_pdev && platform_device_add(external_pdev)) {
-                platform_device_put(external_pdev);
-                external_pdev = NULL;
-        }
-
-        if (internal_pdev || external_pdev) {
-                return 0;
-        } else {
-                platform_driver_unregister(&esp_mac_driver);
-                return -ENOMEM;
-        }
+        return platform_driver_register(&esp_mac_driver);
 }
 
 static void __exit mac_esp_exit(void)
 {
         platform_driver_unregister(&esp_mac_driver);
-
-        if (internal_pdev) {
-                platform_device_unregister(internal_pdev);
-                internal_pdev = NULL;
-        }
-        if (external_pdev) {
-                platform_device_unregister(external_pdev);
-                external_pdev = NULL;
-        }
 }
 
 MODULE_DESCRIPTION("Mac ESP SCSI driver");
 MODULE_AUTHOR("Finn Thain <fthain@telegraphics.com.au>");
 MODULE_LICENSE("GPL v2");
 MODULE_VERSION(DRV_VERSION);
+MODULE_ALIAS("platform:" DRV_MODULE_NAME);
 
 module_init(mac_esp_init);
 module_exit(mac_esp_exit);
diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index 49eb0612d5af..4bf7edca9e69 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -47,6 +47,7 @@
 #include <linux/init.h>
 #include <linux/dma-mapping.h>
 #include <linux/smp_lock.h>
+#include <linux/slab.h>
 #include <scsi/scsicam.h>
 
 #include "scsi.h"
diff --git a/drivers/scsi/megaraid.h b/drivers/scsi/megaraid.h
index 512c2cc1a33f..d310f49d077e 100644
--- a/drivers/scsi/megaraid.h
+++ b/drivers/scsi/megaraid.h
@@ -381,7 +381,7 @@ typedef struct {
         u8      battery_status; /*
                                  * BIT 0: battery module missing
                                  * BIT 1: VBAD
-                                 * BIT 2: temprature high
+                                 * BIT 2: temperature high
                                  * BIT 3: battery pack missing
                                  * BIT 4,5:
                                  *   00 - charge complete
diff --git a/drivers/scsi/megaraid/mbox_defs.h b/drivers/scsi/megaraid/mbox_defs.h
index b25b74764ec3..ce2487a888ed 100644
--- a/drivers/scsi/megaraid/mbox_defs.h
+++ b/drivers/scsi/megaraid/mbox_defs.h
@@ -497,7 +497,7 @@ typedef struct {
  * @inserted_drive              : channel:Id of inserted drive
  * @battery_status              : bit 0: battery module missing
  *                              bit 1: VBAD
- *                              bit 2: temprature high
+ *                              bit 2: temperature high
  *                              bit 3: battery pack missing
  *                              bit 4,5:
  *                                      00 - charge complete
diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index 234f0b7eb21c..a7810a106b37 100644
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -70,6 +70,7 @@
  * For history of changes, see Documentation/ChangeLog.megaraid
  */
 
+#include <linux/slab.h>
 #include "megaraid_mbox.h"
 
 static int megaraid_init(void);
@@ -335,12 +336,17 @@ static struct device_attribute *megaraid_sdev_attrs[] = {
  * megaraid_change_queue_depth - Change the device's queue depth
  * @sdev:       scsi device struct
  * @qdepth:     depth to set
+ * @reason:     calling context
  *
  * Return value:
  *      actual depth set
  */
-static int megaraid_change_queue_depth(struct scsi_device *sdev, int qdepth)
+static int megaraid_change_queue_depth(struct scsi_device *sdev, int qdepth,
+                                       int reason)
 {
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
         if (qdepth > MBOX_MAX_SCSI_CMDS)
                 qdepth = MBOX_MAX_SCSI_CMDS;
         scsi_adjust_queue_depth(sdev, 0, qdepth);
@@ -2704,7 +2710,7 @@ megaraid_reset_handler(struct scsi_cmnd *scp)
         }
         else {
                 con_log(CL_ANN, (KERN_NOTICE
-                "megaraid mbox: reset sequence completed sucessfully\n"));
+                "megaraid mbox: reset sequence completed successfully\n"));
         }
 
 
diff --git a/drivers/scsi/megaraid/megaraid_mm.c b/drivers/scsi/megaraid/megaraid_mm.c
index f680561d2c6f..36e0b7d05c1d 100644
--- a/drivers/scsi/megaraid/megaraid_mm.c
+++ b/drivers/scsi/megaraid/megaraid_mm.c
@@ -15,6 +15,7 @@
  * Common management module
  */
 #include <linux/sched.h>
+#include <linux/slab.h>
 #include <linux/smp_lock.h>
 #include "megaraid_mm.h"
 
diff --git a/drivers/scsi/megaraid/megaraid_sas.c b/drivers/scsi/megaraid/megaraid_sas.c
index a39addc3a596..99e4478c3f3e 100644
--- a/drivers/scsi/megaraid/megaraid_sas.c
+++ b/drivers/scsi/megaraid/megaraid_sas.c
@@ -10,7 +10,7 @@
  *         2 of the License, or (at your option) any later version.
  *
  * FILE         : megaraid_sas.c
- * Version     : v00.00.04.01-rc1
+ * Version     : v00.00.04.17.1-rc1
  *
  * Authors:
  *      (email-id : megaraidlinux@lsi.com)
@@ -35,11 +35,13 @@
 #include <linux/delay.h>
 #include <linux/smp_lock.h>
 #include <linux/uio.h>
+#include <linux/slab.h>
 #include <asm/uaccess.h>
 #include <linux/fs.h>
 #include <linux/compat.h>
 #include <linux/blkdev.h>
 #include <linux/mutex.h>
+#include <linux/poll.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -75,6 +77,10 @@ static struct pci_device_id megasas_pci_table[] = {
         /* gen2*/
         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0079GEN2)},
         /* gen2*/
+        {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0073SKINNY)},
+        /* skinny*/
+        {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0071SKINNY)},
+        /* skinny*/
         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VERDE_ZCR)},
         /* xscale IOP, vega */
         {PCI_DEVICE(PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_PERC5)},
@@ -89,8 +95,14 @@ static struct megasas_mgmt_info megasas_mgmt_info;
 static struct fasync_struct *megasas_async_queue;
 static DEFINE_MUTEX(megasas_async_queue_mutex);
 
+static int megasas_poll_wait_aen;
+static DECLARE_WAIT_QUEUE_HEAD(megasas_poll_wait);
+static u32 support_poll_for_event;
 static u32 megasas_dbg_lvl;
 
+/* define lock for aen poll */
+spinlock_t poll_aen_lock;
+
 static void
 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
                      u8 alt_status);
@@ -215,7 +227,10 @@ megasas_clear_intr_xscale(struct megasas_register_set __iomem * regs)
  * @regs :                      MFI register set
  */
 static inline void 
-megasas_fire_cmd_xscale(dma_addr_t frame_phys_addr,u32 frame_count, struct megasas_register_set __iomem *regs)
+megasas_fire_cmd_xscale(struct megasas_instance *instance,
+                dma_addr_t frame_phys_addr,
+                u32 frame_count,
+                struct megasas_register_set __iomem *regs)
 {
         writel((frame_phys_addr >> 3)|(frame_count),
                &(regs)->inbound_queue_port);
@@ -312,7 +327,10 @@ megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs)
  * @regs :                      MFI register set
  */
 static inline void 
-megasas_fire_cmd_ppc(dma_addr_t frame_phys_addr, u32 frame_count, struct megasas_register_set __iomem *regs)
+megasas_fire_cmd_ppc(struct megasas_instance *instance,
+                dma_addr_t frame_phys_addr,
+                u32 frame_count,
+                struct megasas_register_set __iomem *regs)
 {
         writel((frame_phys_addr | (frame_count<<1))|1, 
                         &(regs)->inbound_queue_port);
@@ -328,6 +346,104 @@ static struct megasas_instance_template megasas_instance_template_ppc = {
 };
 
 /**
+ * megasas_enable_intr_skinny - Enables interrupts
+ * @regs:                       MFI register set
+ */
+static inline void
+megasas_enable_intr_skinny(struct megasas_register_set __iomem *regs)
+{
+        writel(0xFFFFFFFF, &(regs)->outbound_intr_mask);
+
+        writel(~MFI_SKINNY_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
+
+        /* Dummy readl to force pci flush */
+        readl(&regs->outbound_intr_mask);
+}
+
+/**
+ * megasas_disable_intr_skinny -        Disables interrupt
+ * @regs:                       MFI register set
+ */
+static inline void
+megasas_disable_intr_skinny(struct megasas_register_set __iomem *regs)
+{
+        u32 mask = 0xFFFFFFFF;
+        writel(mask, &regs->outbound_intr_mask);
+        /* Dummy readl to force pci flush */
+        readl(&regs->outbound_intr_mask);
+}
+
+/**
+ * megasas_read_fw_status_reg_skinny - returns the current FW status value
+ * @regs:                       MFI register set
+ */
+static u32
+megasas_read_fw_status_reg_skinny(struct megasas_register_set __iomem *regs)
+{
+        return readl(&(regs)->outbound_scratch_pad);
+}
+
+/**
+ * megasas_clear_interrupt_skinny -     Check & clear interrupt
+ * @regs:                               MFI register set
+ */
+static int
+megasas_clear_intr_skinny(struct megasas_register_set __iomem *regs)
+{
+        u32 status;
+        /*
+         * Check if it is our interrupt
+         */
+        status = readl(&regs->outbound_intr_status);
+
+        if (!(status & MFI_SKINNY_ENABLE_INTERRUPT_MASK)) {
+                return 1;
+        }
+
+        /*
+         * Clear the interrupt by writing back the same value
+         */
+        writel(status, &regs->outbound_intr_status);
+
+        /*
+        * dummy read to flush PCI
+        */
+        readl(&regs->outbound_intr_status);
+
+        return 0;
+}
+
+/**
+ * megasas_fire_cmd_skinny -    Sends command to the FW
+ * @frame_phys_addr :           Physical address of cmd
+ * @frame_count :               Number of frames for the command
+ * @regs :                      MFI register set
+ */
+static inline void
+megasas_fire_cmd_skinny(struct megasas_instance *instance,
+                        dma_addr_t frame_phys_addr,
+                        u32 frame_count,
+                        struct megasas_register_set __iomem *regs)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&instance->fire_lock, flags);
+        writel(0, &(regs)->inbound_high_queue_port);
+        writel((frame_phys_addr | (frame_count<<1))|1,
+                &(regs)->inbound_low_queue_port);
+        spin_unlock_irqrestore(&instance->fire_lock, flags);
+}
+
+static struct megasas_instance_template megasas_instance_template_skinny = {
+
+        .fire_cmd = megasas_fire_cmd_skinny,
+        .enable_intr = megasas_enable_intr_skinny,
+        .disable_intr = megasas_disable_intr_skinny,
+        .clear_intr = megasas_clear_intr_skinny,
+        .read_fw_status_reg = megasas_read_fw_status_reg_skinny,
+};
+
+
+/**
 *       The following functions are defined for gen2 (deviceid : 0x78 0x79)
 *       controllers
 */
@@ -404,7 +520,9 @@ megasas_clear_intr_gen2(struct megasas_register_set __iomem *regs)
  * @regs :                     MFI register set
  */
 static inline void
-megasas_fire_cmd_gen2(dma_addr_t frame_phys_addr, u32 frame_count,
+megasas_fire_cmd_gen2(struct megasas_instance *instance,
+                        dma_addr_t frame_phys_addr,
+                        u32 frame_count,
                         struct megasas_register_set __iomem *regs)
 {
         writel((frame_phys_addr | (frame_count<<1))|1,
@@ -446,7 +564,8 @@ megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
         /*
          * Issue the frame using inbound queue port
          */
-        instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
+        instance->instancet->fire_cmd(instance,
+                        cmd->frame_phys_addr, 0, instance->reg_set);
 
         /*
          * Wait for cmd_status to change
@@ -477,7 +596,8 @@ megasas_issue_blocked_cmd(struct megasas_instance *instance,
 {
         cmd->cmd_status = ENODATA;
 
-        instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
+        instance->instancet->fire_cmd(instance,
+                        cmd->frame_phys_addr, 0, instance->reg_set);
 
         wait_event_timeout(instance->int_cmd_wait_q, (cmd->cmd_status != ENODATA),
                 MEGASAS_INTERNAL_CMD_WAIT_TIME*HZ);
@@ -522,7 +642,8 @@ megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
         cmd->sync_cmd = 1;
         cmd->cmd_status = 0xFF;
 
-        instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
+        instance->instancet->fire_cmd(instance,
+                        cmd->frame_phys_addr, 0, instance->reg_set);
 
         /*
          * Wait for this cmd to complete
@@ -592,6 +713,35 @@ megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
         return sge_count;
 }
 
+/**
+ * megasas_make_sgl_skinny - Prepares IEEE SGL
+ * @instance:           Adapter soft state
+ * @scp:                SCSI command from the mid-layer
+ * @mfi_sgl:            SGL to be filled in
+ *
+ * If successful, this function returns the number of SG elements. Otherwise,
+ * it returnes -1.
+ */
+static int
+megasas_make_sgl_skinny(struct megasas_instance *instance,
+                struct scsi_cmnd *scp, union megasas_sgl *mfi_sgl)
+{
+        int i;
+        int sge_count;
+        struct scatterlist *os_sgl;
+
+        sge_count = scsi_dma_map(scp);
+
+        if (sge_count) {
+                scsi_for_each_sg(scp, os_sgl, sge_count, i) {
+                        mfi_sgl->sge_skinny[i].length = sg_dma_len(os_sgl);
+                        mfi_sgl->sge_skinny[i].phys_addr =
+                                                sg_dma_address(os_sgl);
+                }
+        }
+        return sge_count;
+}
+
  /**
  * megasas_get_frame_count - Computes the number of frames
  * @frame_type          : type of frame- io or pthru frame
@@ -600,7 +750,8 @@ megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
  * Returns the number of frames required for numnber of sge's (sge_count)
  */
 
-static u32 megasas_get_frame_count(u8 sge_count, u8 frame_type)
+static u32 megasas_get_frame_count(struct megasas_instance *instance,
+                        u8 sge_count, u8 frame_type)
 {
         int num_cnt;
         int sge_bytes;
@@ -610,6 +761,10 @@ static u32 megasas_get_frame_count(u8 sge_count, u8 frame_type)
         sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
             sizeof(struct megasas_sge32);
 
+        if (instance->flag_ieee) {
+                sge_sz = sizeof(struct megasas_sge_skinny);
+        }
+
         /*
          * Main frame can contain 2 SGEs for 64-bit SGLs and
          * 3 SGEs for 32-bit SGLs for ldio &
@@ -617,12 +772,16 @@ static u32 megasas_get_frame_count(u8 sge_count, u8 frame_type)
          * 2 SGEs for 32-bit SGLs for pthru frame
          */
         if (unlikely(frame_type == PTHRU_FRAME)) {
-                if (IS_DMA64)
+                if (instance->flag_ieee == 1) {
+                        num_cnt = sge_count - 1;
+                } else if (IS_DMA64)
                         num_cnt = sge_count - 1;
                 else
                         num_cnt = sge_count - 2;
         } else {
-                if (IS_DMA64)
+                if (instance->flag_ieee == 1) {
+                        num_cnt = sge_count - 1;
+                } else if (IS_DMA64)
                         num_cnt = sge_count - 2;
                 else
                         num_cnt = sge_count - 3;
@@ -671,6 +830,10 @@ megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
         else if (scp->sc_data_direction == PCI_DMA_NONE)
                 flags = MFI_FRAME_DIR_NONE;
 
+        if (instance->flag_ieee == 1) {
+                flags |= MFI_FRAME_IEEE;
+        }
+
         /*
          * Prepare the DCDB frame
          */
@@ -681,15 +844,31 @@ megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
         pthru->lun = scp->device->lun;
         pthru->cdb_len = scp->cmd_len;
         pthru->timeout = 0;
+        pthru->pad_0 = 0;
         pthru->flags = flags;
         pthru->data_xfer_len = scsi_bufflen(scp);
 
         memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);
 
         /*
+        * If the command is for the tape device, set the
+        * pthru timeout to the os layer timeout value.
+        */
+        if (scp->device->type == TYPE_TAPE) {
+                if ((scp->request->timeout / HZ) > 0xFFFF)
+                        pthru->timeout = 0xFFFF;
+                else
+                        pthru->timeout = scp->request->timeout / HZ;
+        }
+
+        /*
          * Construct SGL
          */
-        if (IS_DMA64) {
+        if (instance->flag_ieee == 1) {
+                pthru->flags |= MFI_FRAME_SGL64;
+                pthru->sge_count = megasas_make_sgl_skinny(instance, scp,
+                                                      &pthru->sgl);
+        } else if (IS_DMA64) {
                 pthru->flags |= MFI_FRAME_SGL64;
                 pthru->sge_count = megasas_make_sgl64(instance, scp,
                                                       &pthru->sgl);
@@ -697,6 +876,12 @@ megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
                 pthru->sge_count = megasas_make_sgl32(instance, scp,
                                                       &pthru->sgl);
 
+        if (pthru->sge_count > instance->max_num_sge) {
+                printk(KERN_ERR "megasas: DCDB two many SGE NUM=%x\n",
+                        pthru->sge_count);
+                return 0;
+        }
+
         /*
          * Sense info specific
          */
@@ -708,7 +893,7 @@ megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
          * Compute the total number of frames this command consumes. FW uses
          * this number to pull sufficient number of frames from host memory.
          */
-        cmd->frame_count = megasas_get_frame_count(pthru->sge_count,
+        cmd->frame_count = megasas_get_frame_count(instance, pthru->sge_count,
                                                         PTHRU_FRAME);
 
         return cmd->frame_count;
@@ -739,6 +924,10 @@ megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
         else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
                 flags = MFI_FRAME_DIR_READ;
 
+        if (instance->flag_ieee == 1) {
+                flags |= MFI_FRAME_IEEE;
+        }
+
         /*
          * Prepare the Logical IO frame: 2nd bit is zero for all read cmds
          */
@@ -809,12 +998,22 @@ megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
         /*
          * Construct SGL
          */
-        if (IS_DMA64) {
+        if (instance->flag_ieee) {
+                ldio->flags |= MFI_FRAME_SGL64;
+                ldio->sge_count = megasas_make_sgl_skinny(instance, scp,
+                                              &ldio->sgl);
+        } else if (IS_DMA64) {
                 ldio->flags |= MFI_FRAME_SGL64;
                 ldio->sge_count = megasas_make_sgl64(instance, scp, &ldio->sgl);
         } else
                 ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl);
 
+        if (ldio->sge_count > instance->max_num_sge) {
+                printk(KERN_ERR "megasas: build_ld_io: sge_count = %x\n",
+                        ldio->sge_count);
+                return 0;
+        }
+
         /*
          * Sense info specific
          */
@@ -826,7 +1025,8 @@ megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
          * Compute the total number of frames this command consumes. FW uses
          * this number to pull sufficient number of frames from host memory.
          */
-        cmd->frame_count = megasas_get_frame_count(ldio->sge_count, IO_FRAME);
+        cmd->frame_count = megasas_get_frame_count(instance,
+                        ldio->sge_count, IO_FRAME);
 
         return cmd->frame_count;
 }
@@ -983,7 +1183,8 @@ megasas_queue_command(struct scsi_cmnd *scmd, void (*done) (struct scsi_cmnd *))
          */
         atomic_inc(&instance->fw_outstanding);
 
-        instance->instancet->fire_cmd(cmd->frame_phys_addr ,cmd->frame_count-1,instance->reg_set);
+        instance->instancet->fire_cmd(instance, cmd->frame_phys_addr,
+                                cmd->frame_count-1, instance->reg_set);
         /*
          * Check if we have pend cmds to be completed
          */
@@ -1000,24 +1201,76 @@ megasas_queue_command(struct scsi_cmnd *scmd, void (*done) (struct scsi_cmnd *))
         return 0;
 }
 
+static struct megasas_instance *megasas_lookup_instance(u16 host_no)
+{
+        int i;
+
+        for (i = 0; i < megasas_mgmt_info.max_index; i++) {
+
+                if ((megasas_mgmt_info.instance[i]) &&
+                    (megasas_mgmt_info.instance[i]->host->host_no == host_no))
+                        return megasas_mgmt_info.instance[i];
+        }
+
+        return NULL;
+}
+
 static int megasas_slave_configure(struct scsi_device *sdev)
 {
+        u16             pd_index = 0;
+        struct  megasas_instance *instance ;
+
+        instance = megasas_lookup_instance(sdev->host->host_no);
+
         /*
-         * Don't export physical disk devices to the disk driver.
-         *
-         * FIXME: Currently we don't export them to the midlayer at all.
-         *        That will be fixed once LSI engineers have audited the
-         *        firmware for possible issues.
-         */
-        if (sdev->channel < MEGASAS_MAX_PD_CHANNELS && sdev->type == TYPE_DISK)
+        * Don't export physical disk devices to the disk driver.
+        *
+        * FIXME: Currently we don't export them to the midlayer at all.
+        *        That will be fixed once LSI engineers have audited the
+        *        firmware for possible issues.
+        */
+        if (sdev->channel < MEGASAS_MAX_PD_CHANNELS &&
+                                sdev->type == TYPE_DISK) {
+                pd_index = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
+                                                                sdev->id;
+                if (instance->pd_list[pd_index].driveState ==
+                                                MR_PD_STATE_SYSTEM) {
+                        blk_queue_rq_timeout(sdev->request_queue,
+                                MEGASAS_DEFAULT_CMD_TIMEOUT * HZ);
+                        return 0;
+                }
                 return -ENXIO;
+        }
 
         /*
-         * The RAID firmware may require extended timeouts.
-         */
-        if (sdev->channel >= MEGASAS_MAX_PD_CHANNELS)
-                blk_queue_rq_timeout(sdev->request_queue,
-                                     MEGASAS_DEFAULT_CMD_TIMEOUT * HZ);
+        * The RAID firmware may require extended timeouts.
+        */
+        blk_queue_rq_timeout(sdev->request_queue,
+                MEGASAS_DEFAULT_CMD_TIMEOUT * HZ);
+        return 0;
+}
+
+static int megasas_slave_alloc(struct scsi_device *sdev)
+{
+        u16             pd_index = 0;
+        struct megasas_instance *instance ;
+        instance = megasas_lookup_instance(sdev->host->host_no);
+        if ((sdev->channel < MEGASAS_MAX_PD_CHANNELS) &&
+                                (sdev->type == TYPE_DISK)) {
+                /*
+                 * Open the OS scan to the SYSTEM PD
+                 */
+                pd_index =
+                        (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
+                        sdev->id;
+                if ((instance->pd_list[pd_index].driveState ==
+                                        MR_PD_STATE_SYSTEM) &&
+                        (instance->pd_list[pd_index].driveType ==
+                                                TYPE_DISK)) {
+                        return 0;
+                }
+                return -ENXIO;
+        }
         return 0;
 }
 
@@ -1072,7 +1325,14 @@ static void megasas_complete_cmd_dpc(unsigned long instance_addr)
 
                 spin_lock_irqsave(instance->host->host_lock, flags);
                 instance->flag &= ~MEGASAS_FW_BUSY;
-                instance->host->can_queue =
+                if ((instance->pdev->device ==
+                        PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
+                        (instance->pdev->device ==
+                        PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
+                        instance->host->can_queue =
+                                instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;
+                } else
+                        instance->host->can_queue =
                                 instance->max_fw_cmds - MEGASAS_INT_CMDS;
 
                 spin_unlock_irqrestore(instance->host->host_lock, flags);
@@ -1117,8 +1377,16 @@ static int megasas_wait_for_outstanding(struct megasas_instance *instance)
                 * Send signal to FW to stop processing any pending cmds.
                 * The controller will be taken offline by the OS now.
                 */
-                writel(MFI_STOP_ADP,
+                if ((instance->pdev->device ==
+                        PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
+                        (instance->pdev->device ==
+                        PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
+                        writel(MFI_STOP_ADP,
+                                &instance->reg_set->reserved_0[0]);
+                } else {
+                        writel(MFI_STOP_ADP,
                                 &instance->reg_set->inbound_doorbell);
+                }
                 megasas_dump_pending_frames(instance);
                 instance->hw_crit_error = 1;
                 return FAILED;
@@ -1266,6 +1534,8 @@ megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev,
         return 0;
 }
 
+static void megasas_aen_polling(struct work_struct *work);
+
 /**
  * megasas_service_aen -        Processes an event notification
  * @instance:                   Adapter soft state
@@ -1281,16 +1551,36 @@ megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev,
 static void
 megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
 {
+        unsigned long flags;
         /*
          * Don't signal app if it is just an aborted previously registered aen
          */
-        if (!cmd->abort_aen)
+        if ((!cmd->abort_aen) && (instance->unload == 0)) {
+                spin_lock_irqsave(&poll_aen_lock, flags);
+                megasas_poll_wait_aen = 1;
+                spin_unlock_irqrestore(&poll_aen_lock, flags);
+                wake_up(&megasas_poll_wait);
                 kill_fasync(&megasas_async_queue, SIGIO, POLL_IN);
+        }
         else
                 cmd->abort_aen = 0;
 
         instance->aen_cmd = NULL;
         megasas_return_cmd(instance, cmd);
+
+        if (instance->unload == 0) {
+                struct megasas_aen_event *ev;
+                ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
+                if (!ev) {
+                        printk(KERN_ERR "megasas_service_aen: out of memory\n");
+                } else {
+                        ev->instance = instance;
+                        instance->ev = ev;
+                        INIT_WORK(&ev->hotplug_work, megasas_aen_polling);
+                        schedule_delayed_work(
+                                (struct delayed_work *)&ev->hotplug_work, 0);
+                }
+        }
 }
 
 /*
@@ -1302,6 +1592,7 @@ static struct scsi_host_template megasas_template = {
         .name = "LSI SAS based MegaRAID driver",
         .proc_name = "megaraid_sas",
         .slave_configure = megasas_slave_configure,
+        .slave_alloc = megasas_slave_alloc,
         .queuecommand = megasas_queue_command,
         .eh_device_reset_handler = megasas_reset_device,
         .eh_bus_reset_handler = megasas_reset_bus_host,
@@ -1370,6 +1661,7 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
 {
         int exception = 0;
         struct megasas_header *hdr = &cmd->frame->hdr;
+        unsigned long flags;
 
         if (cmd->scmd)
                 cmd->scmd->SCp.ptr = NULL;
@@ -1459,6 +1751,12 @@ megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
         case MFI_CMD_SMP:
         case MFI_CMD_STP:
         case MFI_CMD_DCMD:
+                if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET_INFO ||
+                        cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET) {
+                        spin_lock_irqsave(&poll_aen_lock, flags);
+                        megasas_poll_wait_aen = 0;
+                        spin_unlock_irqrestore(&poll_aen_lock, flags);
+                }
 
                 /*
                  * See if got an event notification
@@ -1536,6 +1834,7 @@ megasas_transition_to_ready(struct megasas_instance* instance)
         u8 max_wait;
         u32 fw_state;
         u32 cur_state;
+        u32 abs_state, curr_abs_state;
 
         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) & MFI_STATE_MASK;
 
@@ -1545,6 +1844,9 @@ megasas_transition_to_ready(struct megasas_instance* instance)
 
         while (fw_state != MFI_STATE_READY) {
 
+                abs_state =
+                instance->instancet->read_fw_status_reg(instance->reg_set);
+
                 switch (fw_state) {
 
                 case MFI_STATE_FAULT:
@@ -1556,18 +1858,36 @@ megasas_transition_to_ready(struct megasas_instance* instance)
                         /*
                          * Set the CLR bit in inbound doorbell
                          */
-                        writel(MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
-                                &instance->reg_set->inbound_doorbell);
+                        if ((instance->pdev->device ==
+                                PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
+                                (instance->pdev->device ==
+                                PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
+
+                                writel(
+                                  MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
+                                  &instance->reg_set->reserved_0[0]);
+                        } else {
+                                writel(
+                                    MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
+                                        &instance->reg_set->inbound_doorbell);
+                        }
 
-                        max_wait = 2;
+                        max_wait = MEGASAS_RESET_WAIT_TIME;
                         cur_state = MFI_STATE_WAIT_HANDSHAKE;
                         break;
 
                 case MFI_STATE_BOOT_MESSAGE_PENDING:
-                        writel(MFI_INIT_HOTPLUG,
-                                &instance->reg_set->inbound_doorbell);
+                        if ((instance->pdev->device ==
+                                PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
+                        (instance->pdev->device ==
+                                PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
+                                writel(MFI_INIT_HOTPLUG,
+                                &instance->reg_set->reserved_0[0]);
+                        } else
+                                writel(MFI_INIT_HOTPLUG,
+                                        &instance->reg_set->inbound_doorbell);
 
-                        max_wait = 10;
+                        max_wait = MEGASAS_RESET_WAIT_TIME;
                         cur_state = MFI_STATE_BOOT_MESSAGE_PENDING;
                         break;
 
@@ -1576,9 +1896,17 @@ megasas_transition_to_ready(struct megasas_instance* instance)
                          * Bring it to READY state; assuming max wait 10 secs
                          */
                         instance->instancet->disable_intr(instance->reg_set);
-                        writel(MFI_RESET_FLAGS, &instance->reg_set->inbound_doorbell);
+                        if ((instance->pdev->device ==
+                                PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
+                                (instance->pdev->device ==
+                                PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
+                                writel(MFI_RESET_FLAGS,
+                                        &instance->reg_set->reserved_0[0]);
+                        } else
+                                writel(MFI_RESET_FLAGS,
+                                        &instance->reg_set->inbound_doorbell);
 
-                        max_wait = 60;
+                        max_wait = MEGASAS_RESET_WAIT_TIME;
                         cur_state = MFI_STATE_OPERATIONAL;
                         break;
 
@@ -1586,32 +1914,32 @@ megasas_transition_to_ready(struct megasas_instance* instance)
                         /*
                          * This state should not last for more than 2 seconds
                          */
-                        max_wait = 2;
+                        max_wait = MEGASAS_RESET_WAIT_TIME;
                         cur_state = MFI_STATE_UNDEFINED;
                         break;
 
                 case MFI_STATE_BB_INIT:
-                        max_wait = 2;
+                        max_wait = MEGASAS_RESET_WAIT_TIME;
                         cur_state = MFI_STATE_BB_INIT;
                         break;
 
                 case MFI_STATE_FW_INIT:
-                        max_wait = 20;
+                        max_wait = MEGASAS_RESET_WAIT_TIME;
                         cur_state = MFI_STATE_FW_INIT;
                         break;
 
                 case MFI_STATE_FW_INIT_2:
-                        max_wait = 20;
+                        max_wait = MEGASAS_RESET_WAIT_TIME;
                         cur_state = MFI_STATE_FW_INIT_2;
                         break;
 
                 case MFI_STATE_DEVICE_SCAN:
-                        max_wait = 20;
+                        max_wait = MEGASAS_RESET_WAIT_TIME;
                         cur_state = MFI_STATE_DEVICE_SCAN;
                         break;
 
                 case MFI_STATE_FLUSH_CACHE:
-                        max_wait = 20;
+                        max_wait = MEGASAS_RESET_WAIT_TIME;
                         cur_state = MFI_STATE_FLUSH_CACHE;
                         break;
 
@@ -1627,8 +1955,10 @@ megasas_transition_to_ready(struct megasas_instance* instance)
                 for (i = 0; i < (max_wait * 1000); i++) {
                         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) &  
                                         MFI_STATE_MASK ;
+                curr_abs_state =
+                instance->instancet->read_fw_status_reg(instance->reg_set);
 
-                        if (fw_state == cur_state) {
+                        if (abs_state == curr_abs_state) {
                                 msleep(1);
                         } else
                                 break;
@@ -1637,7 +1967,7 @@ megasas_transition_to_ready(struct megasas_instance* instance)
                 /*
                  * Return error if fw_state hasn't changed after max_wait
                  */
-                if (fw_state == cur_state) {
+                if (curr_abs_state == abs_state) {
                         printk(KERN_DEBUG "FW state [%d] hasn't changed "
                                "in %d secs\n", fw_state, max_wait);
                         return -ENODEV;
@@ -1715,6 +2045,10 @@ static int megasas_create_frame_pool(struct megasas_instance *instance)
         sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
             sizeof(struct megasas_sge32);
 
+        if (instance->flag_ieee) {
+                sge_sz = sizeof(struct megasas_sge_skinny);
+        }
+
         /*
          * Calculated the number of 64byte frames required for SGL
          */
@@ -1777,6 +2111,7 @@ static int megasas_create_frame_pool(struct megasas_instance *instance)
                 }
 
                 cmd->frame->io.context = cmd->index;
+                cmd->frame->io.pad_0 = 0;
         }
 
         return 0;
@@ -1882,6 +2217,178 @@ static int megasas_alloc_cmds(struct megasas_instance *instance)
         return 0;
 }
 
+/*
+ * megasas_get_pd_list_info -   Returns FW's pd_list structure
+ * @instance:                           Adapter soft state
+ * @pd_list:                            pd_list structure
+ *
+ * Issues an internal command (DCMD) to get the FW's controller PD
+ * list structure.  This information is mainly used to find out SYSTEM
+ * supported by the FW.
+ */
+static int
+megasas_get_pd_list(struct megasas_instance *instance)
+{
+        int ret = 0, pd_index = 0;
+        struct megasas_cmd *cmd;
+        struct megasas_dcmd_frame *dcmd;
+        struct MR_PD_LIST *ci;
+        struct MR_PD_ADDRESS *pd_addr;
+        dma_addr_t ci_h = 0;
+
+        cmd = megasas_get_cmd(instance);
+
+        if (!cmd) {
+                printk(KERN_DEBUG "megasas (get_pd_list): Failed to get cmd\n");
+                return -ENOMEM;
+        }
+
+        dcmd = &cmd->frame->dcmd;
+
+        ci = pci_alloc_consistent(instance->pdev,
+                  MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST), &ci_h);
+
+        if (!ci) {
+                printk(KERN_DEBUG "Failed to alloc mem for pd_list\n");
+                megasas_return_cmd(instance, cmd);
+                return -ENOMEM;
+        }
+
+        memset(ci, 0, sizeof(*ci));
+        memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
+
+        dcmd->mbox.b[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST;
+        dcmd->mbox.b[1] = 0;
+        dcmd->cmd = MFI_CMD_DCMD;
+        dcmd->cmd_status = 0xFF;
+        dcmd->sge_count = 1;
+        dcmd->flags = MFI_FRAME_DIR_READ;
+        dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
+        dcmd->data_xfer_len = MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST);
+        dcmd->opcode = MR_DCMD_PD_LIST_QUERY;
+        dcmd->sgl.sge32[0].phys_addr = ci_h;
+        dcmd->sgl.sge32[0].length = MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST);
+
+        if (!megasas_issue_polled(instance, cmd)) {
+                ret = 0;
+        } else {
+                ret = -1;
+        }
+
+        /*
+        * the following function will get the instance PD LIST.
+        */
+
+        pd_addr = ci->addr;
+
+        if ( ret == 0 &&
+                (ci->count <
+                  (MEGASAS_MAX_PD_CHANNELS * MEGASAS_MAX_DEV_PER_CHANNEL))) {
+
+                memset(instance->pd_list, 0,
+                        MEGASAS_MAX_PD * sizeof(struct megasas_pd_list));
+
+                for (pd_index = 0; pd_index < ci->count; pd_index++) {
+
+                        instance->pd_list[pd_addr->deviceId].tid        =
+                                                        pd_addr->deviceId;
+                        instance->pd_list[pd_addr->deviceId].driveType  =
+                                                        pd_addr->scsiDevType;
+                        instance->pd_list[pd_addr->deviceId].driveState =
+                                                        MR_PD_STATE_SYSTEM;
+                        pd_addr++;
+                }
+        }
+
+        pci_free_consistent(instance->pdev,
+                                MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
+                                ci, ci_h);
+        megasas_return_cmd(instance, cmd);
+
+        return ret;
+}
+
+/*
+ * megasas_get_ld_list_info -   Returns FW's ld_list structure
+ * @instance:                           Adapter soft state
+ * @ld_list:                            ld_list structure
+ *
+ * Issues an internal command (DCMD) to get the FW's controller PD
+ * list structure.  This information is mainly used to find out SYSTEM
+ * supported by the FW.
+ */
+static int
+megasas_get_ld_list(struct megasas_instance *instance)
+{
+        int ret = 0, ld_index = 0, ids = 0;
+        struct megasas_cmd *cmd;
+        struct megasas_dcmd_frame *dcmd;
+        struct MR_LD_LIST *ci;
+        dma_addr_t ci_h = 0;
+
+        cmd = megasas_get_cmd(instance);
+
+        if (!cmd) {
+                printk(KERN_DEBUG "megasas_get_ld_list: Failed to get cmd\n");
+                return -ENOMEM;
+        }
+
+        dcmd = &cmd->frame->dcmd;
+
+        ci = pci_alloc_consistent(instance->pdev,
+                                sizeof(struct MR_LD_LIST),
+                                &ci_h);
+
+        if (!ci) {
+                printk(KERN_DEBUG "Failed to alloc mem in get_ld_list\n");
+                megasas_return_cmd(instance, cmd);
+                return -ENOMEM;
+        }
+
+        memset(ci, 0, sizeof(*ci));
+        memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
+
+        dcmd->cmd = MFI_CMD_DCMD;
+        dcmd->cmd_status = 0xFF;
+        dcmd->sge_count = 1;
+        dcmd->flags = MFI_FRAME_DIR_READ;
+        dcmd->timeout = 0;
+        dcmd->data_xfer_len = sizeof(struct MR_LD_LIST);
+        dcmd->opcode = MR_DCMD_LD_GET_LIST;
+        dcmd->sgl.sge32[0].phys_addr = ci_h;
+        dcmd->sgl.sge32[0].length = sizeof(struct MR_LD_LIST);
+        dcmd->pad_0  = 0;
+
+        if (!megasas_issue_polled(instance, cmd)) {
+                ret = 0;
+        } else {
+                ret = -1;
+        }
+
+        /* the following function will get the instance PD LIST */
+
+        if ((ret == 0) && (ci->ldCount < MAX_LOGICAL_DRIVES)) {
+                memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
+
+                for (ld_index = 0; ld_index < ci->ldCount; ld_index++) {
+                        if (ci->ldList[ld_index].state != 0) {
+                                ids = ci->ldList[ld_index].ref.targetId;
+                                instance->ld_ids[ids] =
+                                        ci->ldList[ld_index].ref.targetId;
+                        }
+                }
+        }
+
+        pci_free_consistent(instance->pdev,
+                                sizeof(struct MR_LD_LIST),
+                                ci,
+                                ci_h);
+
+        megasas_return_cmd(instance, cmd);
+        return ret;
+}
+
 /**
  * megasas_get_controller_info -        Returns FW's controller structure
  * @instance:                           Adapter soft state
@@ -1927,6 +2434,7 @@ megasas_get_ctrl_info(struct megasas_instance *instance,
         dcmd->sge_count = 1;
         dcmd->flags = MFI_FRAME_DIR_READ;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = sizeof(struct megasas_ctrl_info);
         dcmd->opcode = MR_DCMD_CTRL_GET_INFO;
         dcmd->sgl.sge32[0].phys_addr = ci_h;
@@ -2081,13 +2589,17 @@ static int megasas_init_mfi(struct megasas_instance *instance)
          * Map the message registers
          */
         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1078GEN2) ||
+                (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
+                (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
                 (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0079GEN2)) {
                 instance->base_addr = pci_resource_start(instance->pdev, 1);
         } else {
                 instance->base_addr = pci_resource_start(instance->pdev, 0);
         }
 
-        if (pci_request_regions(instance->pdev, "megasas: LSI")) {
+        if (pci_request_selected_regions(instance->pdev,
+                pci_select_bars(instance->pdev, IORESOURCE_MEM),
+                "megasas: LSI")) {
                 printk(KERN_DEBUG "megasas: IO memory region busy!\n");
                 return -EBUSY;
         }
@@ -2111,6 +2623,10 @@ static int megasas_init_mfi(struct megasas_instance *instance)
                 case PCI_DEVICE_ID_LSI_SAS0079GEN2:
                         instance->instancet = &megasas_instance_template_gen2;
                         break;
+                case PCI_DEVICE_ID_LSI_SAS0073SKINNY:
+                case PCI_DEVICE_ID_LSI_SAS0071SKINNY:
+                        instance->instancet = &megasas_instance_template_skinny;
+                        break;
                 case PCI_DEVICE_ID_LSI_SAS1064R:
                 case PCI_DEVICE_ID_DELL_PERC5:
                 default:
@@ -2166,6 +2682,13 @@ static int megasas_init_mfi(struct megasas_instance *instance)
         if (megasas_issue_init_mfi(instance))
                 goto fail_fw_init;
 
+        memset(instance->pd_list, 0 ,
+                (MEGASAS_MAX_PD * sizeof(struct megasas_pd_list)));
+        megasas_get_pd_list(instance);
+
+        memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
+        megasas_get_ld_list(instance);
+
         ctrl_info = kmalloc(sizeof(struct megasas_ctrl_info), GFP_KERNEL);
 
         /*
@@ -2220,7 +2743,8 @@ static int megasas_init_mfi(struct megasas_instance *instance)
         iounmap(instance->reg_set);
 
       fail_ioremap:
-        pci_release_regions(instance->pdev);
+        pci_release_selected_regions(instance->pdev,
+                pci_select_bars(instance->pdev, IORESOURCE_MEM));
 
         return -EINVAL;
 }
@@ -2240,7 +2764,8 @@ static void megasas_release_mfi(struct megasas_instance *instance)
 
         iounmap(instance->reg_set);
 
-        pci_release_regions(instance->pdev);
+        pci_release_selected_regions(instance->pdev,
+                pci_select_bars(instance->pdev, IORESOURCE_MEM));
 }
 
 /**
@@ -2288,6 +2813,7 @@ megasas_get_seq_num(struct megasas_instance *instance,
         dcmd->sge_count = 1;
         dcmd->flags = MFI_FRAME_DIR_READ;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = sizeof(struct megasas_evt_log_info);
         dcmd->opcode = MR_DCMD_CTRL_EVENT_GET_INFO;
         dcmd->sgl.sge32[0].phys_addr = el_info_h;
@@ -2402,6 +2928,7 @@ megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
         dcmd->sge_count = 1;
         dcmd->flags = MFI_FRAME_DIR_READ;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = sizeof(struct megasas_evt_detail);
         dcmd->opcode = MR_DCMD_CTRL_EVENT_WAIT;
         dcmd->mbox.w[0] = seq_num;
@@ -2409,6 +2936,11 @@ megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
         dcmd->sgl.sge32[0].phys_addr = (u32) instance->evt_detail_h;
         dcmd->sgl.sge32[0].length = sizeof(struct megasas_evt_detail);
 
+        if (instance->aen_cmd != NULL) {
+                megasas_return_cmd(instance, cmd);
+                return 0;
+        }
+
         /*
          * Store reference to the cmd used to register for AEN. When an
          * application wants us to register for AEN, we have to abort this
@@ -2419,7 +2951,8 @@ megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
         /*
          * Issue the aen registration frame
          */
-        instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
+        instance->instancet->fire_cmd(instance,
+                        cmd->frame_phys_addr, 0, instance->reg_set);
 
         return 0;
 }
@@ -2465,7 +2998,13 @@ static int megasas_io_attach(struct megasas_instance *instance)
          */
         host->irq = instance->pdev->irq;
         host->unique_id = instance->unique_id;
-        host->can_queue = instance->max_fw_cmds - MEGASAS_INT_CMDS;
+        if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
+                (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
+                host->can_queue =
+                        instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;
+        } else
+                host->can_queue =
+                        instance->max_fw_cmds - MEGASAS_INT_CMDS;
         host->this_id = instance->init_id;
         host->sg_tablesize = instance->max_num_sge;
         host->max_sectors = instance->max_sectors_per_req;
@@ -2537,7 +3076,7 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         /*
          * PCI prepping: enable device set bus mastering and dma mask
          */
-        rval = pci_enable_device(pdev);
+        rval = pci_enable_device_mem(pdev);
 
         if (rval) {
                 return rval;
@@ -2572,6 +3111,9 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
 
         *instance->producer = 0;
         *instance->consumer = 0;
+        megasas_poll_wait_aen = 0;
+        instance->flag_ieee = 0;
+        instance->ev = NULL;
 
         instance->evt_detail = pci_alloc_consistent(pdev,
                                                     sizeof(struct
@@ -2595,10 +3137,11 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         init_waitqueue_head(&instance->abort_cmd_wait_q);
 
         spin_lock_init(&instance->cmd_pool_lock);
+        spin_lock_init(&instance->fire_lock);
         spin_lock_init(&instance->completion_lock);
+        spin_lock_init(&poll_aen_lock);
 
         mutex_init(&instance->aen_mutex);
-        sema_init(&instance->ioctl_sem, MEGASAS_INT_CMDS);
 
         /*
          * Initialize PCI related and misc parameters
@@ -2608,8 +3151,16 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         instance->unique_id = pdev->bus->number << 8 | pdev->devfn;
         instance->init_id = MEGASAS_DEFAULT_INIT_ID;
 
+        if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
+                (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
+                instance->flag_ieee = 1;
+                sema_init(&instance->ioctl_sem, MEGASAS_SKINNY_INT_CMDS);
+        } else
+                sema_init(&instance->ioctl_sem, MEGASAS_INT_CMDS);
+
         megasas_dbg_lvl = 0;
         instance->flag = 0;
+        instance->unload = 1;
         instance->last_time = 0;
 
         /*
@@ -2655,6 +3206,7 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         if (megasas_io_attach(instance))
                 goto fail_io_attach;
 
+        instance->unload = 0;
         return 0;
 
       fail_start_aen:
@@ -2715,6 +3267,7 @@ static void megasas_flush_cache(struct megasas_instance *instance)
         dcmd->sge_count = 0;
         dcmd->flags = MFI_FRAME_DIR_NONE;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = 0;
         dcmd->opcode = MR_DCMD_CTRL_CACHE_FLUSH;
         dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
@@ -2754,6 +3307,7 @@ static void megasas_shutdown_controller(struct megasas_instance *instance,
         dcmd->sge_count = 0;
         dcmd->flags = MFI_FRAME_DIR_NONE;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = 0;
         dcmd->opcode = opcode;
 
@@ -2778,12 +3332,23 @@ megasas_suspend(struct pci_dev *pdev, pm_message_t state)
 
         instance = pci_get_drvdata(pdev);
         host = instance->host;
+        instance->unload = 1;
 
         if (poll_mode_io)
                 del_timer_sync(&instance->io_completion_timer);
 
         megasas_flush_cache(instance);
         megasas_shutdown_controller(instance, MR_DCMD_HIBERNATE_SHUTDOWN);
+
+        /* cancel the delayed work if this work still in queue */
+        if (instance->ev != NULL) {
+                struct megasas_aen_event *ev = instance->ev;
+                cancel_delayed_work(
+                        (struct delayed_work *)&ev->hotplug_work);
+                flush_scheduled_work();
+                instance->ev = NULL;
+        }
+
         tasklet_kill(&instance->isr_tasklet);
 
         pci_set_drvdata(instance->pdev, instance);
@@ -2818,7 +3383,7 @@ megasas_resume(struct pci_dev *pdev)
         /*
          * PCI prepping: enable device set bus mastering and dma mask
          */
-        rval = pci_enable_device(pdev);
+        rval = pci_enable_device_mem(pdev);
 
         if (rval) {
                 printk(KERN_ERR "megasas: Enable device failed\n");
@@ -2873,6 +3438,8 @@ megasas_resume(struct pci_dev *pdev)
                 megasas_start_timer(instance, &instance->io_completion_timer,
                                 megasas_io_completion_timer,
                                 MEGASAS_COMPLETION_TIMER_INTERVAL);
+        instance->unload = 0;
+
         return 0;
 
 fail_irq:
@@ -2913,6 +3480,7 @@ static void __devexit megasas_detach_one(struct pci_dev *pdev)
         struct megasas_instance *instance;
 
         instance = pci_get_drvdata(pdev);
+        instance->unload = 1;
         host = instance->host;
 
         if (poll_mode_io)
@@ -2921,6 +3489,16 @@ static void __devexit megasas_detach_one(struct pci_dev *pdev)
         scsi_remove_host(instance->host);
         megasas_flush_cache(instance);
         megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
+
+        /* cancel the delayed work if this work still in queue*/
+        if (instance->ev != NULL) {
+                struct megasas_aen_event *ev = instance->ev;
+                cancel_delayed_work(
+                        (struct delayed_work *)&ev->hotplug_work);
+                flush_scheduled_work();
+                instance->ev = NULL;
+        }
+
         tasklet_kill(&instance->isr_tasklet);
 
         /*
@@ -2969,6 +3547,7 @@ static void __devexit megasas_detach_one(struct pci_dev *pdev)
 static void megasas_shutdown(struct pci_dev *pdev)
 {
         struct megasas_instance *instance = pci_get_drvdata(pdev);
+        instance->unload = 1;
         megasas_flush_cache(instance);
         megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
 }
@@ -3016,6 +3595,23 @@ static int megasas_mgmt_fasync(int fd, struct file *filep, int mode)
 }
 
 /**
+ * megasas_mgmt_poll -  char node "poll" entry point
+ * */
+static unsigned int megasas_mgmt_poll(struct file *file, poll_table *wait)
+{
+        unsigned int mask;
+        unsigned long flags;
+        poll_wait(file, &megasas_poll_wait, wait);
+        spin_lock_irqsave(&poll_aen_lock, flags);
+        if (megasas_poll_wait_aen)
+                mask =   (POLLIN | POLLRDNORM);
+        else
+                mask = 0;
+        spin_unlock_irqrestore(&poll_aen_lock, flags);
+        return mask;
+}
+
+/**
  * megasas_mgmt_fw_ioctl -      Issues management ioctls to FW
  * @instance:                   Adapter soft state
  * @argp:                       User's ioctl packet
@@ -3032,7 +3628,7 @@ megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
         int error = 0, i;
         void *sense = NULL;
         dma_addr_t sense_handle;
-        u32 *sense_ptr;
+        unsigned long *sense_ptr;
 
         memset(kbuff_arr, 0, sizeof(kbuff_arr));
 
@@ -3056,6 +3652,7 @@ megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
          */
         memcpy(cmd->frame, ioc->frame.raw, 2 * MEGAMFI_FRAME_SIZE);
         cmd->frame->hdr.context = cmd->index;
+        cmd->frame->hdr.pad_0 = 0;
 
         /*
          * The management interface between applications and the fw uses
@@ -3109,7 +3706,7 @@ megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
                 }
 
                 sense_ptr =
-                    (u32 *) ((unsigned long)cmd->frame + ioc->sense_off);
+                (unsigned long *) ((unsigned long)cmd->frame + ioc->sense_off);
                 *sense_ptr = sense_handle;
         }
 
@@ -3140,8 +3737,8 @@ megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
                  * sense_ptr points to the location that has the user
                  * sense buffer address
                  */
-                sense_ptr = (u32 *) ((unsigned long)ioc->frame.raw +
-                                     ioc->sense_off);
+                sense_ptr = (unsigned long *) ((unsigned long)ioc->frame.raw +
+                                ioc->sense_off);
 
                 if (copy_to_user((void __user *)((unsigned long)(*sense_ptr)),
                                  sense, ioc->sense_len)) {
@@ -3177,20 +3774,6 @@ megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
         return error;
 }
 
-static struct megasas_instance *megasas_lookup_instance(u16 host_no)
-{
-        int i;
-
-        for (i = 0; i < megasas_mgmt_info.max_index; i++) {
-
-                if ((megasas_mgmt_info.instance[i]) &&
-                    (megasas_mgmt_info.instance[i]->host->host_no == host_no))
-                        return megasas_mgmt_info.instance[i];
-        }
-
-        return NULL;
-}
-
 static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
 {
         struct megasas_iocpacket __user *user_ioc =
@@ -3214,6 +3797,17 @@ static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
                 goto out_kfree_ioc;
         }
 
+        if (instance->hw_crit_error == 1) {
+                printk(KERN_DEBUG "Controller in Crit ERROR\n");
+                error = -ENODEV;
+                goto out_kfree_ioc;
+        }
+
+        if (instance->unload == 1) {
+                error = -ENODEV;
+                goto out_kfree_ioc;
+        }
+
         /*
          * We will allow only MEGASAS_INT_CMDS number of parallel ioctl cmds
          */
@@ -3249,6 +3843,14 @@ static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg)
         if (!instance)
                 return -ENODEV;
 
+        if (instance->hw_crit_error == 1) {
+                error = -ENODEV;
+        }
+
+        if (instance->unload == 1) {
+                return -ENODEV;
+        }
+
         mutex_lock(&instance->aen_mutex);
         error = megasas_register_aen(instance, aen.seq_num,
                                      aen.class_locale_word);
@@ -3282,6 +3884,7 @@ static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
             compat_alloc_user_space(sizeof(struct megasas_iocpacket));
         int i;
         int error = 0;
+        compat_uptr_t ptr;
 
         if (clear_user(ioc, sizeof(*ioc)))
                 return -EFAULT;
@@ -3294,9 +3897,22 @@ static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
             copy_in_user(&ioc->sge_count, &cioc->sge_count, sizeof(u32)))
                 return -EFAULT;
 
-        for (i = 0; i < MAX_IOCTL_SGE; i++) {
-                compat_uptr_t ptr;
+        /*
+         * The sense_ptr is used in megasas_mgmt_fw_ioctl only when
+         * sense_len is not null, so prepare the 64bit value under
+         * the same condition.
+         */
+        if (ioc->sense_len) {
+                void __user **sense_ioc_ptr =
+                        (void __user **)(ioc->frame.raw + ioc->sense_off);
+                compat_uptr_t *sense_cioc_ptr =
+                        (compat_uptr_t *)(cioc->frame.raw + cioc->sense_off);
+                if (get_user(ptr, sense_cioc_ptr) ||
+                    put_user(compat_ptr(ptr), sense_ioc_ptr))
+                        return -EFAULT;
+        }
 
+        for (i = 0; i < MAX_IOCTL_SGE; i++) {
                 if (get_user(ptr, &cioc->sgl[i].iov_base) ||
                     put_user(compat_ptr(ptr), &ioc->sgl[i].iov_base) ||
                     copy_in_user(&ioc->sgl[i].iov_len,
@@ -3337,6 +3953,7 @@ static const struct file_operations megasas_mgmt_fops = {
         .open = megasas_mgmt_open,
         .fasync = megasas_mgmt_fasync,
         .unlocked_ioctl = megasas_mgmt_ioctl,
+        .poll = megasas_mgmt_poll,
 #ifdef CONFIG_COMPAT
         .compat_ioctl = megasas_mgmt_compat_ioctl,
 #endif
@@ -3378,6 +3995,15 @@ static DRIVER_ATTR(release_date, S_IRUGO, megasas_sysfs_show_release_date,
                    NULL);
 
 static ssize_t
+megasas_sysfs_show_support_poll_for_event(struct device_driver *dd, char *buf)
+{
+        return sprintf(buf, "%u\n", support_poll_for_event);
+}
+
+static DRIVER_ATTR(support_poll_for_event, S_IRUGO,
+                        megasas_sysfs_show_support_poll_for_event, NULL);
+
+static ssize_t
 megasas_sysfs_show_dbg_lvl(struct device_driver *dd, char *buf)
 {
         return sprintf(buf, "%u\n", megasas_dbg_lvl);
@@ -3451,7 +4077,235 @@ out:
         return retval;
 }
 
-static DRIVER_ATTR(poll_mode_io, S_IRUGO|S_IWUGO,
+static void
+megasas_aen_polling(struct work_struct *work)
+{
+        struct megasas_aen_event *ev =
+                container_of(work, struct megasas_aen_event, hotplug_work);
+        struct megasas_instance *instance = ev->instance;
+        union megasas_evt_class_locale class_locale;
+        struct  Scsi_Host *host;
+        struct  scsi_device *sdev1;
+        u16     pd_index = 0;
+        u16     ld_index = 0;
+        int     i, j, doscan = 0;
+        u32 seq_num;
+        int error;
+
+        if (!instance) {
+                printk(KERN_ERR "invalid instance!\n");
+                kfree(ev);
+                return;
+        }
+        instance->ev = NULL;
+        host = instance->host;
+        if (instance->evt_detail) {
+
+                switch (instance->evt_detail->code) {
+                case MR_EVT_PD_INSERTED:
+                        if (megasas_get_pd_list(instance) == 0) {
+                        for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
+                                for (j = 0;
+                                j < MEGASAS_MAX_DEV_PER_CHANNEL;
+                                j++) {
+
+                                pd_index =
+                                (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                sdev1 =
+                                scsi_device_lookup(host, i, j, 0);
+
+                                if (instance->pd_list[pd_index].driveState
+                                                == MR_PD_STATE_SYSTEM) {
+                                                if (!sdev1) {
+                                                scsi_add_device(host, i, j, 0);
+                                                }
+
+                                        if (sdev1)
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                        }
+                        }
+                        doscan = 0;
+                        break;
+
+                case MR_EVT_PD_REMOVED:
+                        if (megasas_get_pd_list(instance) == 0) {
+                        megasas_get_pd_list(instance);
+                        for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
+                                for (j = 0;
+                                j < MEGASAS_MAX_DEV_PER_CHANNEL;
+                                j++) {
+
+                                pd_index =
+                                (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                sdev1 =
+                                scsi_device_lookup(host, i, j, 0);
+
+                                if (instance->pd_list[pd_index].driveState
+                                        == MR_PD_STATE_SYSTEM) {
+                                        if (sdev1) {
+                                                scsi_device_put(sdev1);
+                                        }
+                                } else {
+                                        if (sdev1) {
+                                                scsi_remove_device(sdev1);
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                                }
+                        }
+                        }
+                        doscan = 0;
+                        break;
+
+                case MR_EVT_LD_OFFLINE:
+                case MR_EVT_LD_DELETED:
+                        megasas_get_ld_list(instance);
+                        for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
+                                for (j = 0;
+                                j < MEGASAS_MAX_DEV_PER_CHANNEL;
+                                j++) {
+
+                                ld_index =
+                                (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                sdev1 = scsi_device_lookup(host,
+                                        i + MEGASAS_MAX_LD_CHANNELS,
+                                        j,
+                                        0);
+
+                                if (instance->ld_ids[ld_index] != 0xff) {
+                                        if (sdev1) {
+                                                scsi_device_put(sdev1);
+                                        }
+                                } else {
+                                        if (sdev1) {
+                                                scsi_remove_device(sdev1);
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                                }
+                        }
+                        doscan = 0;
+                        break;
+                case MR_EVT_LD_CREATED:
+                        megasas_get_ld_list(instance);
+                        for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
+                                for (j = 0;
+                                        j < MEGASAS_MAX_DEV_PER_CHANNEL;
+                                        j++) {
+                                        ld_index =
+                                        (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                        sdev1 = scsi_device_lookup(host,
+                                                i+MEGASAS_MAX_LD_CHANNELS,
+                                                j, 0);
+
+                                        if (instance->ld_ids[ld_index] !=
+                                                                0xff) {
+                                                if (!sdev1) {
+                                                        scsi_add_device(host,
+                                                                i + 2,
+                                                                j, 0);
+                                                }
+                                        }
+                                        if (sdev1) {
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                        }
+                        doscan = 0;
+                        break;
+                case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED:
+                case MR_EVT_FOREIGN_CFG_IMPORTED:
+                        doscan = 1;
+                        break;
+                default:
+                        doscan = 0;
+                        break;
+                }
+        } else {
+                printk(KERN_ERR "invalid evt_detail!\n");
+                kfree(ev);
+                return;
+        }
+
+        if (doscan) {
+                printk(KERN_INFO "scanning ...\n");
+                megasas_get_pd_list(instance);
+                for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
+                        for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
+                                pd_index = i*MEGASAS_MAX_DEV_PER_CHANNEL + j;
+                                sdev1 = scsi_device_lookup(host, i, j, 0);
+                                if (instance->pd_list[pd_index].driveState ==
+                                                        MR_PD_STATE_SYSTEM) {
+                                        if (!sdev1) {
+                                                scsi_add_device(host, i, j, 0);
+                                        }
+                                        if (sdev1)
+                                                scsi_device_put(sdev1);
+                                } else {
+                                        if (sdev1) {
+                                                scsi_remove_device(sdev1);
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                        }
+                }
+
+                megasas_get_ld_list(instance);
+                for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
+                        for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
+                                ld_index =
+                                (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                sdev1 = scsi_device_lookup(host,
+                                        i+MEGASAS_MAX_LD_CHANNELS, j, 0);
+                                if (instance->ld_ids[ld_index] != 0xff) {
+                                        if (!sdev1) {
+                                                scsi_add_device(host,
+                                                                i+2,
+                                                                j, 0);
+                                        } else {
+                                                scsi_device_put(sdev1);
+                                        }
+                                } else {
+                                        if (sdev1) {
+                                                scsi_remove_device(sdev1);
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                        }
+                }
+        }
+
+        if ( instance->aen_cmd != NULL ) {
+                kfree(ev);
+                return ;
+        }
+
+        seq_num = instance->evt_detail->seq_num + 1;
+
+        /* Register AEN with FW for latest sequence number plus 1 */
+        class_locale.members.reserved = 0;
+        class_locale.members.locale = MR_EVT_LOCALE_ALL;
+        class_locale.members.class = MR_EVT_CLASS_DEBUG;
+        mutex_lock(&instance->aen_mutex);
+        error = megasas_register_aen(instance, seq_num,
+                                        class_locale.word);
+        mutex_unlock(&instance->aen_mutex);
+
+        if (error)
+                printk(KERN_ERR "register aen failed error %x\n", error);
+
+        kfree(ev);
+}
+
+
+static DRIVER_ATTR(poll_mode_io, S_IRUGO|S_IWUSR,
                 megasas_sysfs_show_poll_mode_io,
                 megasas_sysfs_set_poll_mode_io);
 
@@ -3468,6 +4322,8 @@ static int __init megasas_init(void)
         printk(KERN_INFO "megasas: %s %s\n", MEGASAS_VERSION,
                MEGASAS_EXT_VERSION);
 
+        support_poll_for_event = 2;
+
         memset(&megasas_mgmt_info, 0, sizeof(megasas_mgmt_info));
 
         /*
@@ -3500,6 +4356,12 @@ static int __init megasas_init(void)
                                   &driver_attr_release_date);
         if (rval)
                 goto err_dcf_rel_date;
+
+        rval = driver_create_file(&megasas_pci_driver.driver,
+                                &driver_attr_support_poll_for_event);
+        if (rval)
+                goto err_dcf_support_poll_for_event;
+
         rval = driver_create_file(&megasas_pci_driver.driver,
                                   &driver_attr_dbg_lvl);
         if (rval)
@@ -3516,7 +4378,12 @@ err_dcf_poll_mode_io:
                            &driver_attr_dbg_lvl);
 err_dcf_dbg_lvl:
         driver_remove_file(&megasas_pci_driver.driver,
+                        &driver_attr_support_poll_for_event);
+
+err_dcf_support_poll_for_event:
+        driver_remove_file(&megasas_pci_driver.driver,
                            &driver_attr_release_date);
+
 err_dcf_rel_date:
         driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
 err_dcf_attr_ver:
diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
index 0d033248fdf1..9d8b6bf605aa 100644
--- a/drivers/scsi/megaraid/megaraid_sas.h
+++ b/drivers/scsi/megaraid/megaraid_sas.h
@@ -18,9 +18,9 @@
 /*
  * MegaRAID SAS Driver meta data
  */
-#define MEGASAS_VERSION                         "00.00.04.01"
-#define MEGASAS_RELDATE                         "July 24, 2008"
-#define MEGASAS_EXT_VERSION                     "Thu July 24 11:41:51 PST 2008"
+#define MEGASAS_VERSION                 "00.00.04.17.1-rc1"
+#define MEGASAS_RELDATE                 "Oct. 29, 2009"
+#define MEGASAS_EXT_VERSION             "Thu. Oct. 29, 11:41:51 PST 2009"
 
 /*
  * Device IDs
@@ -30,6 +30,8 @@
 #define PCI_DEVICE_ID_LSI_VERDE_ZCR             0x0413
 #define PCI_DEVICE_ID_LSI_SAS1078GEN2           0x0078
 #define PCI_DEVICE_ID_LSI_SAS0079GEN2           0x0079
+#define PCI_DEVICE_ID_LSI_SAS0073SKINNY         0x0073
+#define PCI_DEVICE_ID_LSI_SAS0071SKINNY         0x0071
 
 /*
  * =====================================
@@ -94,6 +96,7 @@
 #define MFI_FRAME_DIR_WRITE                     0x0008
 #define MFI_FRAME_DIR_READ                      0x0010
 #define MFI_FRAME_DIR_BOTH                      0x0018
+#define MFI_FRAME_IEEE                          0x0020
 
 /*
  * Definition for cmd_status
@@ -114,6 +117,7 @@
 #define MFI_CMD_STP                             0x08
 
 #define MR_DCMD_CTRL_GET_INFO                   0x01010000
+#define MR_DCMD_LD_GET_LIST                     0x03010000
 
 #define MR_DCMD_CTRL_CACHE_FLUSH                0x01101000
 #define MR_FLUSH_CTRL_CACHE                     0x01
@@ -131,6 +135,7 @@
 #define MR_DCMD_CLUSTER                         0x08000000
 #define MR_DCMD_CLUSTER_RESET_ALL               0x08010100
 #define MR_DCMD_CLUSTER_RESET_LD                0x08010200
+#define MR_DCMD_PD_LIST_QUERY                   0x02010100
 
 /*
  * MFI command completion codes
@@ -251,9 +256,126 @@ enum MR_EVT_ARGS {
         MR_EVT_ARGS_STR,
         MR_EVT_ARGS_TIME,
         MR_EVT_ARGS_ECC,
+        MR_EVT_ARGS_LD_PROP,
+        MR_EVT_ARGS_PD_SPARE,
+        MR_EVT_ARGS_PD_INDEX,
+        MR_EVT_ARGS_DIAG_PASS,
+        MR_EVT_ARGS_DIAG_FAIL,
+        MR_EVT_ARGS_PD_LBA_LBA,
+        MR_EVT_ARGS_PORT_PHY,
+        MR_EVT_ARGS_PD_MISSING,
+        MR_EVT_ARGS_PD_ADDRESS,
+        MR_EVT_ARGS_BITMAP,
+        MR_EVT_ARGS_CONNECTOR,
+        MR_EVT_ARGS_PD_PD,
+        MR_EVT_ARGS_PD_FRU,
+        MR_EVT_ARGS_PD_PATHINFO,
+        MR_EVT_ARGS_PD_POWER_STATE,
+        MR_EVT_ARGS_GENERIC,
+};
 
+/*
+ * define constants for device list query options
+ */
+enum MR_PD_QUERY_TYPE {
+        MR_PD_QUERY_TYPE_ALL                = 0,
+        MR_PD_QUERY_TYPE_STATE              = 1,
+        MR_PD_QUERY_TYPE_POWER_STATE        = 2,
+        MR_PD_QUERY_TYPE_MEDIA_TYPE         = 3,
+        MR_PD_QUERY_TYPE_SPEED              = 4,
+        MR_PD_QUERY_TYPE_EXPOSED_TO_HOST    = 5,
 };
 
+#define MR_EVT_CFG_CLEARED                              0x0004
+#define MR_EVT_LD_STATE_CHANGE                          0x0051
+#define MR_EVT_PD_INSERTED                              0x005b
+#define MR_EVT_PD_REMOVED                               0x0070
+#define MR_EVT_LD_CREATED                               0x008a
+#define MR_EVT_LD_DELETED                               0x008b
+#define MR_EVT_FOREIGN_CFG_IMPORTED                     0x00db
+#define MR_EVT_LD_OFFLINE                               0x00fc
+#define MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED             0x0152
+#define MAX_LOGICAL_DRIVES                              64
+
+enum MR_PD_STATE {
+        MR_PD_STATE_UNCONFIGURED_GOOD   = 0x00,
+        MR_PD_STATE_UNCONFIGURED_BAD    = 0x01,
+        MR_PD_STATE_HOT_SPARE           = 0x02,
+        MR_PD_STATE_OFFLINE             = 0x10,
+        MR_PD_STATE_FAILED              = 0x11,
+        MR_PD_STATE_REBUILD             = 0x14,
+        MR_PD_STATE_ONLINE              = 0x18,
+        MR_PD_STATE_COPYBACK            = 0x20,
+        MR_PD_STATE_SYSTEM              = 0x40,
+ };
+
+
+ /*
+ * defines the physical drive address structure
+ */
+struct MR_PD_ADDRESS {
+        u16     deviceId;
+        u16     enclDeviceId;
+
+        union {
+                struct {
+                        u8  enclIndex;
+                        u8  slotNumber;
+                } mrPdAddress;
+                struct {
+                        u8  enclPosition;
+                        u8  enclConnectorIndex;
+                } mrEnclAddress;
+        };
+        u8      scsiDevType;
+        union {
+                u8      connectedPortBitmap;
+                u8      connectedPortNumbers;
+        };
+        u64     sasAddr[2];
+} __packed;
+
+/*
+ * defines the physical drive list structure
+ */
+struct MR_PD_LIST {
+        u32             size;
+        u32             count;
+        struct MR_PD_ADDRESS   addr[1];
+} __packed;
+
+struct megasas_pd_list {
+        u16             tid;
+        u8             driveType;
+        u8             driveState;
+} __packed;
+
+ /*
+ * defines the logical drive reference structure
+ */
+union  MR_LD_REF {
+        struct {
+                u8      targetId;
+                u8      reserved;
+                u16     seqNum;
+        };
+        u32     ref;
+} __packed;
+
+/*
+ * defines the logical drive list structure
+ */
+struct MR_LD_LIST {
+        u32     ldCount;
+        u32     reserved;
+        struct {
+                union MR_LD_REF   ref;
+                u8          state;
+                u8          reserved[3];
+                u64         size;
+        } ldList[MAX_LOGICAL_DRIVES];
+} __packed;
+
 /*
  * SAS controller properties
  */
@@ -282,7 +404,7 @@ struct megasas_ctrl_prop {
         u8 expose_encl_devices;
         u8 reserved[38];
 
-} __attribute__ ((packed));
+} __packed;
 
 /*
  * SAS controller information
@@ -525,7 +647,7 @@ struct megasas_ctrl_info {
 
         u8 pad[0x800 - 0x6a0];
 
-} __attribute__ ((packed));
+} __packed;
 
 /*
  * ===============================
@@ -540,6 +662,10 @@ struct megasas_ctrl_info {
 #define MEGASAS_DEFAULT_INIT_ID                 -1
 #define MEGASAS_MAX_LUN                         8
 #define MEGASAS_MAX_LD                          64
+#define MEGASAS_MAX_PD                          (MEGASAS_MAX_PD_CHANNELS * \
+                                                MEGASAS_MAX_DEV_PER_CHANNEL)
+#define MEGASAS_MAX_LD_IDS                      (MEGASAS_MAX_LD_CHANNELS * \
+                                                MEGASAS_MAX_DEV_PER_CHANNEL)
 
 #define MEGASAS_DBG_LVL                         1
 
@@ -570,6 +696,7 @@ struct megasas_ctrl_info {
  * is shown below
  */
 #define MEGASAS_INT_CMDS                        32
+#define MEGASAS_SKINNY_INT_CMDS                 5
 
 /*
  * FW can accept both 32 and 64 bit SGLs. We want to allocate 32/64 bit
@@ -584,6 +711,8 @@ struct megasas_ctrl_info {
 #define MFI_REPLY_1078_MESSAGE_INTERRUPT        0x80000000
 #define MFI_REPLY_GEN2_MESSAGE_INTERRUPT        0x00000001
 #define MFI_GEN2_ENABLE_INTERRUPT_MASK          (0x00000001 | 0x00000004)
+#define MFI_REPLY_SKINNY_MESSAGE_INTERRUPT      0x40000000
+#define MFI_SKINNY_ENABLE_INTERRUPT_MASK        (0x00000001)
 
 /*
 * register set for both 1068 and 1078 controllers
@@ -644,10 +773,17 @@ struct megasas_sge64 {
 
 } __attribute__ ((packed));
 
+struct megasas_sge_skinny {
+        u64 phys_addr;
+        u32 length;
+        u32 flag;
+} __packed;
+
 union megasas_sgl {
 
         struct megasas_sge32 sge32[1];
         struct megasas_sge64 sge64[1];
+        struct megasas_sge_skinny sge_skinny[1];
 
 } __attribute__ ((packed));
 
@@ -1061,16 +1197,10 @@ struct megasas_evt_detail {
 
 } __attribute__ ((packed));
 
- struct megasas_instance_template {
-        void (*fire_cmd)(dma_addr_t ,u32 ,struct megasas_register_set __iomem *);
-
-        void (*enable_intr)(struct megasas_register_set __iomem *) ;
-        void (*disable_intr)(struct megasas_register_set __iomem *);
-
-        int (*clear_intr)(struct megasas_register_set __iomem *);
-
-        u32 (*read_fw_status_reg)(struct megasas_register_set __iomem *);
- };
+struct megasas_aen_event {
+        struct work_struct hotplug_work;
+        struct megasas_instance *instance;
+};
 
 struct megasas_instance {
 
@@ -1085,17 +1215,22 @@ struct megasas_instance {
         unsigned long base_addr;
         struct megasas_register_set __iomem *reg_set;
 
+        struct megasas_pd_list          pd_list[MEGASAS_MAX_PD];
+        u8     ld_ids[MEGASAS_MAX_LD_IDS];
         s8 init_id;
 
         u16 max_num_sge;
         u16 max_fw_cmds;
         u32 max_sectors_per_req;
+        struct megasas_aen_event *ev;
 
         struct megasas_cmd **cmd_list;
         struct list_head cmd_pool;
         spinlock_t cmd_pool_lock;
         /* used to synch producer, consumer ptrs in dpc */
         spinlock_t completion_lock;
+        /* used to sync fire the cmd to fw */
+        spinlock_t fire_lock;
         struct dma_pool *frame_dma_pool;
         struct dma_pool *sense_dma_pool;
 
@@ -1120,11 +1255,25 @@ struct megasas_instance {
         struct tasklet_struct isr_tasklet;
 
         u8 flag;
+        u8 unload;
+        u8 flag_ieee;
         unsigned long last_time;
 
         struct timer_list io_completion_timer;
 };
 
+struct megasas_instance_template {
+        void (*fire_cmd)(struct megasas_instance *, dma_addr_t, \
+                u32, struct megasas_register_set __iomem *);
+
+        void (*enable_intr)(struct megasas_register_set __iomem *) ;
+        void (*disable_intr)(struct megasas_register_set __iomem *);
+
+        int (*clear_intr)(struct megasas_register_set __iomem *);
+
+        u32 (*read_fw_status_reg)(struct megasas_register_set __iomem *);
+};
+
 #define MEGASAS_IS_LOGICAL(scp)                                         \
         (scp->device->channel < MEGASAS_MAX_PD_CHANNELS) ? 0 : 1
 
diff --git a/drivers/scsi/mesh.c b/drivers/scsi/mesh.c
index 11aa917629ac..a1c97e88068a 100644
--- a/drivers/scsi/mesh.c
+++ b/drivers/scsi/mesh.c
@@ -23,7 +23,6 @@
 #include <linux/delay.h>
 #include <linux/types.h>
 #include <linux/string.h>
-#include <linux/slab.h>
 #include <linux/blkdev.h>
 #include <linux/proc_fs.h>
 #include <linux/stat.h>
diff --git a/drivers/scsi/mpt2sas/Kconfig b/drivers/scsi/mpt2sas/Kconfig
index 70c4c2467dd8..ba8e128de238 100644
--- a/drivers/scsi/mpt2sas/Kconfig
+++ b/drivers/scsi/mpt2sas/Kconfig
@@ -44,6 +44,7 @@ config SCSI_MPT2SAS
         tristate "LSI MPT Fusion SAS 2.0 Device Driver"
         depends on PCI && SCSI
         select SCSI_SAS_ATTRS
+        select RAID_ATTRS
         ---help---
         This driver supports PCI-Express SAS 6Gb/s Host Adapters.
 
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2.h b/drivers/scsi/mpt2sas/mpi/mpi2.h
index f9f6c0839276..9958d847a88d 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2.h
@@ -8,7 +8,7 @@
  *                  scatter/gather formats.
  *  Creation Date:  June 21, 2006
  *
- *  mpi2.h Version:  02.00.12
+ *  mpi2.h Version:  02.00.14
  *
  *  Version History
  *  ---------------
@@ -52,6 +52,11 @@
  *                      MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR and made those
  *                      bytes reserved.
  *                      Added RAID Accelerator functionality.
+ *  07-30-09  02.00.13  Bumped MPI2_HEADER_VERSION_UNIT.
+ *  10-28-09  02.00.14  Bumped MPI2_HEADER_VERSION_UNIT.
+ *                      Added MSI-x index mask and shift for Reply Post Host
+ *                      Index register.
+ *                      Added function code for Host Based Discovery Action.
  *  --------------------------------------------------------------------------
  */
 
@@ -77,7 +82,7 @@
 #define MPI2_VERSION_02_00                  (0x0200)
 
 /* versioning for this MPI header set */
-#define MPI2_HEADER_VERSION_UNIT            (0x0C)
+#define MPI2_HEADER_VERSION_UNIT            (0x0E)
 #define MPI2_HEADER_VERSION_DEV             (0x00)
 #define MPI2_HEADER_VERSION_UNIT_MASK       (0xFF00)
 #define MPI2_HEADER_VERSION_UNIT_SHIFT      (8)
@@ -231,9 +236,12 @@ typedef volatile struct _MPI2_SYSTEM_INTERFACE_REGS
 #define MPI2_REPLY_FREE_HOST_INDEX_OFFSET       (0x00000048)
 
 /*
- * Offset for the Reply Descriptor Post Queue
+ * Defines for the Reply Descriptor Post Queue
  */
 #define MPI2_REPLY_POST_HOST_INDEX_OFFSET       (0x0000006C)
+#define MPI2_REPLY_POST_HOST_INDEX_MASK         (0x00FFFFFF)
+#define MPI2_RPHI_MSIX_INDEX_MASK               (0xFF000000)
+#define MPI2_RPHI_MSIX_INDEX_SHIFT              (24)
 
 /*
  * Defines for the HCBSize and address
@@ -496,12 +504,13 @@ typedef union _MPI2_REPLY_DESCRIPTORS_UNION
 #define MPI2_FUNCTION_TARGET_CMD_BUF_BASE_POST      (0x24) /* Target Command Buffer Post Base */
 #define MPI2_FUNCTION_TARGET_CMD_BUF_LIST_POST      (0x25) /* Target Command Buffer Post List */
 #define MPI2_FUNCTION_RAID_ACCELERATOR              (0x2C) /* RAID Accelerator*/
+/* Host Based Discovery Action */
+#define MPI2_FUNCTION_HOST_BASED_DISCOVERY_ACTION   (0x2F)
 
 
 
 /* Doorbell functions */
 #define MPI2_FUNCTION_IOC_MESSAGE_UNIT_RESET        (0x40)
-/* #define MPI2_FUNCTION_IO_UNIT_RESET                 (0x41) */
 #define MPI2_FUNCTION_HANDSHAKE                     (0x42)
 
 
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h b/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h
index ab47c4679640..cf0ac9f40c97 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h
@@ -6,7 +6,7 @@
  *          Title:  MPI Configuration messages and pages
  *  Creation Date:  November 10, 2006
  *
- *    mpi2_cnfg.h Version:  02.00.11
+ *    mpi2_cnfg.h Version:  02.00.13
  *
  *  Version History
  *  ---------------
@@ -100,6 +100,15 @@
  *                      Added expander reduced functionality data to SAS
  *                      Expander Page 0.
  *                      Added SAS PHY Page 2 and SAS PHY Page 3.
+ *  07-30-09  02.00.12  Added IO Unit Page 7.
+ *                      Added new device ids.
+ *                      Added SAS IO Unit Page 5.
+ *                      Added partial and slumber power management capable flags
+ *                      to SAS Device Page 0 Flags field.
+ *                      Added PhyInfo defines for power condition.
+ *                      Added Ethernet configuration pages.
+ *  10-28-09  02.00.13  Added MPI2_IOUNITPAGE1_ENABLE_HOST_BASED_DISCOVERY.
+ *                      Added SAS PHY Page 4 structure and defines.
  *  --------------------------------------------------------------------------
  */
 
@@ -182,6 +191,7 @@ typedef union _MPI2_CONFIG_EXT_PAGE_HEADER_UNION
 #define MPI2_CONFIG_EXTPAGETYPE_RAID_CONFIG         (0x16)
 #define MPI2_CONFIG_EXTPAGETYPE_DRIVER_MAPPING      (0x17)
 #define MPI2_CONFIG_EXTPAGETYPE_SAS_PORT            (0x18)
+#define MPI2_CONFIG_EXTPAGETYPE_ETHERNET            (0x19)
 
 
 /*****************************************************************************
@@ -268,6 +278,14 @@ typedef union _MPI2_CONFIG_EXT_PAGE_HEADER_UNION
 #define MPI2_DPM_PGAD_START_ENTRY_MASK              (0x0000FFFF)
 
 
+/* Ethernet PageAddress format */
+#define MPI2_ETHERNET_PGAD_FORM_MASK                (0xF0000000)
+#define MPI2_ETHERNET_PGAD_FORM_IF_NUM              (0x00000000)
+
+#define MPI2_ETHERNET_PGAD_IF_NUMBER_MASK           (0x000000FF)
+
+
+
 /****************************************************************************
 *   Configuration messages
 ****************************************************************************/
@@ -349,6 +367,15 @@ typedef struct _MPI2_CONFIG_REPLY
 #define MPI2_MFGPAGE_DEVID_SAS2116_1                (0x0064)
 #define MPI2_MFGPAGE_DEVID_SAS2116_2                (0x0065)
 
+#define MPI2_MFGPAGE_DEVID_SAS2208_1                (0x0080)
+#define MPI2_MFGPAGE_DEVID_SAS2208_2                (0x0081)
+#define MPI2_MFGPAGE_DEVID_SAS2208_3                (0x0082)
+#define MPI2_MFGPAGE_DEVID_SAS2208_4                (0x0083)
+#define MPI2_MFGPAGE_DEVID_SAS2208_5                (0x0084)
+#define MPI2_MFGPAGE_DEVID_SAS2208_6                (0x0085)
+#define MPI2_MFGPAGE_DEVID_SAS2208_7                (0x0086)
+#define MPI2_MFGPAGE_DEVID_SAS2208_8                (0x0087)
+
 
 /* Manufacturing Page 0 */
 
@@ -687,6 +714,7 @@ typedef struct _MPI2_CONFIG_PAGE_IO_UNIT_1
 #define MPI2_IOUNITPAGE1_PAGEVERSION                    (0x04)
 
 /* IO Unit Page 1 Flags defines */
+#define MPI2_IOUNITPAGE1_ENABLE_HOST_BASED_DISCOVERY    (0x00000800)
 #define MPI2_IOUNITPAGE1_MASK_SATA_WRITE_CACHE          (0x00000600)
 #define MPI2_IOUNITPAGE1_ENABLE_SATA_WRITE_CACHE        (0x00000000)
 #define MPI2_IOUNITPAGE1_DISABLE_SATA_WRITE_CACHE       (0x00000200)
@@ -787,6 +815,56 @@ typedef struct _MPI2_CONFIG_PAGE_IO_UNIT_6 {
 #define MPI2_IOUNITPAGE6_FLAGS_ENABLE_RAID_ACCELERATOR  (0x0001)
 
 
+/* IO Unit Page 7 */
+
+typedef struct _MPI2_CONFIG_PAGE_IO_UNIT_7 {
+    MPI2_CONFIG_PAGE_HEADER Header;                                 /* 0x00 */
+    U16                     Reserved1;                              /* 0x04 */
+    U8                      PCIeWidth;                              /* 0x06 */
+    U8                      PCIeSpeed;                              /* 0x07 */
+    U32                     ProcessorState;                         /* 0x08 */
+    U32                     Reserved2;                              /* 0x0C */
+    U16                     IOCTemperature;                         /* 0x10 */
+    U8                      IOCTemperatureUnits;                    /* 0x12 */
+    U8                      IOCSpeed;                               /* 0x13 */
+    U32                     Reserved3;                              /* 0x14 */
+} MPI2_CONFIG_PAGE_IO_UNIT_7, MPI2_POINTER PTR_MPI2_CONFIG_PAGE_IO_UNIT_7,
+  Mpi2IOUnitPage7_t, MPI2_POINTER pMpi2IOUnitPage7_t;
+
+#define MPI2_IOUNITPAGE7_PAGEVERSION                    (0x00)
+
+/* defines for IO Unit Page 7 PCIeWidth field */
+#define MPI2_IOUNITPAGE7_PCIE_WIDTH_X1              (0x01)
+#define MPI2_IOUNITPAGE7_PCIE_WIDTH_X2              (0x02)
+#define MPI2_IOUNITPAGE7_PCIE_WIDTH_X4              (0x04)
+#define MPI2_IOUNITPAGE7_PCIE_WIDTH_X8              (0x08)
+
+/* defines for IO Unit Page 7 PCIeSpeed field */
+#define MPI2_IOUNITPAGE7_PCIE_SPEED_2_5_GBPS        (0x00)
+#define MPI2_IOUNITPAGE7_PCIE_SPEED_5_0_GBPS        (0x01)
+#define MPI2_IOUNITPAGE7_PCIE_SPEED_8_0_GBPS        (0x02)
+
+/* defines for IO Unit Page 7 ProcessorState field */
+#define MPI2_IOUNITPAGE7_PSTATE_MASK_SECOND         (0x0000000F)
+#define MPI2_IOUNITPAGE7_PSTATE_SHIFT_SECOND        (0)
+
+#define MPI2_IOUNITPAGE7_PSTATE_NOT_PRESENT         (0x00)
+#define MPI2_IOUNITPAGE7_PSTATE_DISABLED            (0x01)
+#define MPI2_IOUNITPAGE7_PSTATE_ENABLED             (0x02)
+
+/* defines for IO Unit Page 7 IOCTemperatureUnits field */
+#define MPI2_IOUNITPAGE7_IOC_TEMP_NOT_PRESENT       (0x00)
+#define MPI2_IOUNITPAGE7_IOC_TEMP_FAHRENHEIT        (0x01)
+#define MPI2_IOUNITPAGE7_IOC_TEMP_CELSIUS           (0x02)
+
+/* defines for IO Unit Page 7 IOCSpeed field */
+#define MPI2_IOUNITPAGE7_IOC_SPEED_FULL             (0x01)
+#define MPI2_IOUNITPAGE7_IOC_SPEED_HALF             (0x02)
+#define MPI2_IOUNITPAGE7_IOC_SPEED_QUARTER          (0x04)
+#define MPI2_IOUNITPAGE7_IOC_SPEED_EIGHTH           (0x08)
+
+
+
 /****************************************************************************
 *   IOC Config Pages
 ****************************************************************************/
@@ -1470,6 +1548,12 @@ typedef struct _MPI2_CONFIG_PAGE_RD_PDISK_1
 
 /* values for PhyInfo fields */
 #define MPI2_SAS_PHYINFO_PHY_VACANT                     (0x80000000)
+
+#define MPI2_SAS_PHYINFO_PHY_POWER_CONDITION_MASK       (0x18000000)
+#define MPI2_SAS_PHYINFO_PHY_POWER_ACTIVE               (0x00000000)
+#define MPI2_SAS_PHYINFO_PHY_POWER_PARTIAL              (0x08000000)
+#define MPI2_SAS_PHYINFO_PHY_POWER_SLUMBER              (0x10000000)
+
 #define MPI2_SAS_PHYINFO_CHANGED_REQ_INSIDE_ZPSDS       (0x04000000)
 #define MPI2_SAS_PHYINFO_INSIDE_ZPSDS_PERSISTENT        (0x02000000)
 #define MPI2_SAS_PHYINFO_REQ_INSIDE_ZPSDS               (0x01000000)
@@ -1682,11 +1766,11 @@ typedef struct _MPI2_CONFIG_PAGE_SASIOUNIT_1
 /* values for SAS IO Unit Page 1 PortFlags */
 #define MPI2_SASIOUNIT1_PORT_FLAGS_AUTO_PORT_CONFIG                 (0x01)
 
-/* values for SAS IO Unit Page 2 PhyFlags */
+/* values for SAS IO Unit Page 1 PhyFlags */
 #define MPI2_SASIOUNIT1_PHYFLAGS_ZONING_ENABLE                      (0x10)
 #define MPI2_SASIOUNIT1_PHYFLAGS_PHY_DISABLE                        (0x08)
 
-/* values for SAS IO Unit Page 0 MaxMinLinkRate */
+/* values for SAS IO Unit Page 1 MaxMinLinkRate */
 #define MPI2_SASIOUNIT1_MAX_RATE_MASK                               (0xF0)
 #define MPI2_SASIOUNIT1_MAX_RATE_1_5                                (0x80)
 #define MPI2_SASIOUNIT1_MAX_RATE_3_0                                (0x90)
@@ -1745,6 +1829,74 @@ typedef struct _MPI2_CONFIG_PAGE_SASIOUNIT_4
 #define MPI2_SASIOUNIT4_PHY_SPINUP_GROUP_MASK               (0x03)
 
 
+/* SAS IO Unit Page 5 */
+
+typedef struct _MPI2_SAS_IO_UNIT5_PHY_PM_SETTINGS {
+    U8          ControlFlags;               /* 0x00 */
+    U8          Reserved1;                  /* 0x01 */
+    U16         InactivityTimerExponent;    /* 0x02 */
+    U8          SATAPartialTimeout;         /* 0x04 */
+    U8          Reserved2;                  /* 0x05 */
+    U8          SATASlumberTimeout;         /* 0x06 */
+    U8          Reserved3;                  /* 0x07 */
+    U8          SASPartialTimeout;          /* 0x08 */
+    U8          Reserved4;                  /* 0x09 */
+    U8          SASSlumberTimeout;          /* 0x0A */
+    U8          Reserved5;                  /* 0x0B */
+} MPI2_SAS_IO_UNIT5_PHY_PM_SETTINGS,
+  MPI2_POINTER PTR_MPI2_SAS_IO_UNIT5_PHY_PM_SETTINGS,
+  Mpi2SasIOUnit5PhyPmSettings_t, MPI2_POINTER pMpi2SasIOUnit5PhyPmSettings_t;
+
+/* defines for ControlFlags field */
+#define MPI2_SASIOUNIT5_CONTROL_SAS_SLUMBER_ENABLE      (0x08)
+#define MPI2_SASIOUNIT5_CONTROL_SAS_PARTIAL_ENABLE      (0x04)
+#define MPI2_SASIOUNIT5_CONTROL_SATA_SLUMBER_ENABLE     (0x02)
+#define MPI2_SASIOUNIT5_CONTROL_SATA_PARTIAL_ENABLE     (0x01)
+
+/* defines for InactivityTimerExponent field */
+#define MPI2_SASIOUNIT5_ITE_MASK_SAS_SLUMBER            (0x7000)
+#define MPI2_SASIOUNIT5_ITE_SHIFT_SAS_SLUMBER           (12)
+#define MPI2_SASIOUNIT5_ITE_MASK_SAS_PARTIAL            (0x0700)
+#define MPI2_SASIOUNIT5_ITE_SHIFT_SAS_PARTIAL           (8)
+#define MPI2_SASIOUNIT5_ITE_MASK_SATA_SLUMBER           (0x0070)
+#define MPI2_SASIOUNIT5_ITE_SHIFT_SATA_SLUMBER          (4)
+#define MPI2_SASIOUNIT5_ITE_MASK_SATA_PARTIAL           (0x0007)
+#define MPI2_SASIOUNIT5_ITE_SHIFT_SATA_PARTIAL          (0)
+
+#define MPI2_SASIOUNIT5_ITE_TEN_SECONDS                 (7)
+#define MPI2_SASIOUNIT5_ITE_ONE_SECOND                  (6)
+#define MPI2_SASIOUNIT5_ITE_HUNDRED_MILLISECONDS        (5)
+#define MPI2_SASIOUNIT5_ITE_TEN_MILLISECONDS            (4)
+#define MPI2_SASIOUNIT5_ITE_ONE_MILLISECOND             (3)
+#define MPI2_SASIOUNIT5_ITE_HUNDRED_MICROSECONDS        (2)
+#define MPI2_SASIOUNIT5_ITE_TEN_MICROSECONDS            (1)
+#define MPI2_SASIOUNIT5_ITE_ONE_MICROSECOND             (0)
+
+/*
+ * Host code (drivers, BIOS, utilities, etc.) should leave this define set to
+ * one and check Header.ExtPageLength or NumPhys at runtime.
+ */
+#ifndef MPI2_SAS_IOUNIT5_PHY_MAX
+#define MPI2_SAS_IOUNIT5_PHY_MAX        (1)
+#endif
+
+typedef struct _MPI2_CONFIG_PAGE_SASIOUNIT_5 {
+    MPI2_CONFIG_EXTENDED_PAGE_HEADER    Header;         /* 0x00 */
+    U8                                  NumPhys;        /* 0x08 */
+    U8                                  Reserved1;      /* 0x09 */
+    U16                                 Reserved2;      /* 0x0A */
+    U32                                 Reserved3;      /* 0x0C */
+    MPI2_SAS_IO_UNIT5_PHY_PM_SETTINGS   SASPhyPowerManagementSettings
+                                        [MPI2_SAS_IOUNIT5_PHY_MAX];  /* 0x10 */
+} MPI2_CONFIG_PAGE_SASIOUNIT_5,
+  MPI2_POINTER PTR_MPI2_CONFIG_PAGE_SASIOUNIT_5,
+  Mpi2SasIOUnitPage5_t, MPI2_POINTER pMpi2SasIOUnitPage5_t;
+
+#define MPI2_SASIOUNITPAGE5_PAGEVERSION     (0x00)
+
+
+
+
 /****************************************************************************
 *   SAS Expander Config Pages
 ****************************************************************************/
@@ -1927,6 +2079,8 @@ typedef struct _MPI2_CONFIG_PAGE_SAS_DEV_0
 /* see mpi2_sas.h for values for SAS Device Page 0 DeviceInfo values */
 
 /* values for SAS Device Page 0 Flags field */
+#define MPI2_SAS_DEVICE0_FLAGS_SLUMBER_PM_CAPABLE           (0x1000)
+#define MPI2_SAS_DEVICE0_FLAGS_PARTIAL_PM_CAPABLE           (0x0800)
 #define MPI2_SAS_DEVICE0_FLAGS_SATA_ASYNCHRONOUS_NOTIFY     (0x0400)
 #define MPI2_SAS_DEVICE0_FLAGS_SATA_SW_PRESERVE             (0x0200)
 #define MPI2_SAS_DEVICE0_FLAGS_UNSUPPORTED_DEVICE           (0x0100)
@@ -2140,6 +2294,26 @@ typedef struct _MPI2_CONFIG_PAGE_SAS_PHY_3 {
 #define MPI2_SASPHY3_PAGEVERSION            (0x00)
 
 
+/* SAS PHY Page 4 */
+
+typedef struct _MPI2_CONFIG_PAGE_SAS_PHY_4 {
+    MPI2_CONFIG_EXTENDED_PAGE_HEADER    Header;                     /* 0x00 */
+    U16                                 Reserved1;                  /* 0x08 */
+    U8                                  Reserved2;                  /* 0x0A */
+    U8                                  Flags;                      /* 0x0B */
+    U8                                  InitialFrame[28];           /* 0x0C */
+} MPI2_CONFIG_PAGE_SAS_PHY_4, MPI2_POINTER PTR_MPI2_CONFIG_PAGE_SAS_PHY_4,
+  Mpi2SasPhyPage4_t, MPI2_POINTER pMpi2SasPhyPage4_t;
+
+#define MPI2_SASPHY4_PAGEVERSION            (0x00)
+
+/* values for the Flags field */
+#define MPI2_SASPHY4_FLAGS_FRAME_VALID        (0x02)
+#define MPI2_SASPHY4_FLAGS_SATA_FRAME         (0x01)
+
+
+
+
 /****************************************************************************
 *   SAS Port Config Pages
 ****************************************************************************/
@@ -2343,5 +2517,122 @@ typedef struct _MPI2_CONFIG_PAGE_DRIVER_MAPPING_0
 #define MPI2_DRVMAP0_MAPINFO_MISSING_MASK           (0x000F)
 
 
+/****************************************************************************
+*   Ethernet Config Pages
+****************************************************************************/
+
+/* Ethernet Page 0 */
+
+/* IP address (union of IPv4 and IPv6) */
+typedef union _MPI2_ETHERNET_IP_ADDR {
+    U32     IPv4Addr;
+    U32     IPv6Addr[4];
+} MPI2_ETHERNET_IP_ADDR, MPI2_POINTER PTR_MPI2_ETHERNET_IP_ADDR,
+  Mpi2EthernetIpAddr_t, MPI2_POINTER pMpi2EthernetIpAddr_t;
+
+#define MPI2_ETHERNET_HOST_NAME_LENGTH          (32)
+
+typedef struct _MPI2_CONFIG_PAGE_ETHERNET_0 {
+    MPI2_CONFIG_EXTENDED_PAGE_HEADER    Header;                 /* 0x00 */
+    U8                                  NumInterfaces;          /* 0x08 */
+    U8                                  Reserved0;              /* 0x09 */
+    U16                                 Reserved1;              /* 0x0A */
+    U32                                 Status;                 /* 0x0C */
+    U8                                  MediaState;             /* 0x10 */
+    U8                                  Reserved2;              /* 0x11 */
+    U16                                 Reserved3;              /* 0x12 */
+    U8                                  MacAddress[6];          /* 0x14 */
+    U8                                  Reserved4;              /* 0x1A */
+    U8                                  Reserved5;              /* 0x1B */
+    MPI2_ETHERNET_IP_ADDR               IpAddress;              /* 0x1C */
+    MPI2_ETHERNET_IP_ADDR               SubnetMask;             /* 0x2C */
+    MPI2_ETHERNET_IP_ADDR               GatewayIpAddress;       /* 0x3C */
+    MPI2_ETHERNET_IP_ADDR               DNS1IpAddress;          /* 0x4C */
+    MPI2_ETHERNET_IP_ADDR               DNS2IpAddress;          /* 0x5C */
+    MPI2_ETHERNET_IP_ADDR               DhcpIpAddress;          /* 0x6C */
+    U8                                  HostName
+                                [MPI2_ETHERNET_HOST_NAME_LENGTH];/* 0x7C */
+} MPI2_CONFIG_PAGE_ETHERNET_0, MPI2_POINTER PTR_MPI2_CONFIG_PAGE_ETHERNET_0,
+  Mpi2EthernetPage0_t, MPI2_POINTER pMpi2EthernetPage0_t;
+
+#define MPI2_ETHERNETPAGE0_PAGEVERSION   (0x00)
+
+/* values for Ethernet Page 0 Status field */
+#define MPI2_ETHPG0_STATUS_IPV6_CAPABLE             (0x80000000)
+#define MPI2_ETHPG0_STATUS_IPV4_CAPABLE             (0x40000000)
+#define MPI2_ETHPG0_STATUS_CONSOLE_CONNECTED        (0x20000000)
+#define MPI2_ETHPG0_STATUS_DEFAULT_IF               (0x00000100)
+#define MPI2_ETHPG0_STATUS_FW_DWNLD_ENABLED         (0x00000080)
+#define MPI2_ETHPG0_STATUS_TELNET_ENABLED           (0x00000040)
+#define MPI2_ETHPG0_STATUS_SSH2_ENABLED             (0x00000020)
+#define MPI2_ETHPG0_STATUS_DHCP_CLIENT_ENABLED      (0x00000010)
+#define MPI2_ETHPG0_STATUS_IPV6_ENABLED             (0x00000008)
+#define MPI2_ETHPG0_STATUS_IPV4_ENABLED             (0x00000004)
+#define MPI2_ETHPG0_STATUS_IPV6_ADDRESSES           (0x00000002)
+#define MPI2_ETHPG0_STATUS_ETH_IF_ENABLED           (0x00000001)
+
+/* values for Ethernet Page 0 MediaState field */
+#define MPI2_ETHPG0_MS_DUPLEX_MASK                  (0x80)
+#define MPI2_ETHPG0_MS_HALF_DUPLEX                  (0x00)
+#define MPI2_ETHPG0_MS_FULL_DUPLEX                  (0x80)
+
+#define MPI2_ETHPG0_MS_CONNECT_SPEED_MASK           (0x07)
+#define MPI2_ETHPG0_MS_NOT_CONNECTED                (0x00)
+#define MPI2_ETHPG0_MS_10MBIT                       (0x01)
+#define MPI2_ETHPG0_MS_100MBIT                      (0x02)
+#define MPI2_ETHPG0_MS_1GBIT                        (0x03)
+
+
+/* Ethernet Page 1 */
+
+typedef struct _MPI2_CONFIG_PAGE_ETHERNET_1 {
+    MPI2_CONFIG_EXTENDED_PAGE_HEADER    Header;                 /* 0x00 */
+    U32                                 Reserved0;              /* 0x08 */
+    U32                                 Flags;                  /* 0x0C */
+    U8                                  MediaState;             /* 0x10 */
+    U8                                  Reserved1;              /* 0x11 */
+    U16                                 Reserved2;              /* 0x12 */
+    U8                                  MacAddress[6];          /* 0x14 */
+    U8                                  Reserved3;              /* 0x1A */
+    U8                                  Reserved4;              /* 0x1B */
+    MPI2_ETHERNET_IP_ADDR               StaticIpAddress;        /* 0x1C */
+    MPI2_ETHERNET_IP_ADDR               StaticSubnetMask;       /* 0x2C */
+    MPI2_ETHERNET_IP_ADDR               StaticGatewayIpAddress; /* 0x3C */
+    MPI2_ETHERNET_IP_ADDR               StaticDNS1IpAddress;    /* 0x4C */
+    MPI2_ETHERNET_IP_ADDR               StaticDNS2IpAddress;    /* 0x5C */
+    U32                                 Reserved5;              /* 0x6C */
+    U32                                 Reserved6;              /* 0x70 */
+    U32                                 Reserved7;              /* 0x74 */
+    U32                                 Reserved8;              /* 0x78 */
+    U8                                  HostName
+                                [MPI2_ETHERNET_HOST_NAME_LENGTH];/* 0x7C */
+} MPI2_CONFIG_PAGE_ETHERNET_1, MPI2_POINTER PTR_MPI2_CONFIG_PAGE_ETHERNET_1,
+  Mpi2EthernetPage1_t, MPI2_POINTER pMpi2EthernetPage1_t;
+
+#define MPI2_ETHERNETPAGE1_PAGEVERSION   (0x00)
+
+/* values for Ethernet Page 1 Flags field */
+#define MPI2_ETHPG1_FLAG_SET_DEFAULT_IF             (0x00000100)
+#define MPI2_ETHPG1_FLAG_ENABLE_FW_DOWNLOAD         (0x00000080)
+#define MPI2_ETHPG1_FLAG_ENABLE_TELNET              (0x00000040)
+#define MPI2_ETHPG1_FLAG_ENABLE_SSH2                (0x00000020)
+#define MPI2_ETHPG1_FLAG_ENABLE_DHCP_CLIENT         (0x00000010)
+#define MPI2_ETHPG1_FLAG_ENABLE_IPV6                (0x00000008)
+#define MPI2_ETHPG1_FLAG_ENABLE_IPV4                (0x00000004)
+#define MPI2_ETHPG1_FLAG_USE_IPV6_ADDRESSES         (0x00000002)
+#define MPI2_ETHPG1_FLAG_ENABLE_ETH_IF              (0x00000001)
+
+/* values for Ethernet Page 1 MediaState field */
+#define MPI2_ETHPG1_MS_DUPLEX_MASK                  (0x80)
+#define MPI2_ETHPG1_MS_HALF_DUPLEX                  (0x00)
+#define MPI2_ETHPG1_MS_FULL_DUPLEX                  (0x80)
+
+#define MPI2_ETHPG1_MS_DATA_RATE_MASK               (0x07)
+#define MPI2_ETHPG1_MS_DATA_RATE_AUTO               (0x00)
+#define MPI2_ETHPG1_MS_DATA_RATE_10MBIT             (0x01)
+#define MPI2_ETHPG1_MS_DATA_RATE_100MBIT            (0x02)
+#define MPI2_ETHPG1_MS_DATA_RATE_1GBIT              (0x03)
+
+
 #endif
 
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_history.txt b/drivers/scsi/mpt2sas/mpi/mpi2_history.txt
index 65fcaa31cb30..c4adf76b49d9 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_history.txt
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_history.txt
@@ -5,23 +5,24 @@
  Copyright (c) 2000-2009 LSI Corporation.
 
  ---------------------------------------
- Header Set Release Version:    02.00.12
- Header Set Release Date:       05-06-09
+ Header Set Release Version:    02.00.14
+ Header Set Release Date:       10-28-09
  ---------------------------------------
 
  Filename               Current version     Prior version
  ----------             ---------------     -------------
- mpi2.h                 02.00.12            02.00.11
- mpi2_cnfg.h            02.00.11            02.00.10
- mpi2_init.h            02.00.07            02.00.06
- mpi2_ioc.h             02.00.11            02.00.10
- mpi2_raid.h            02.00.03            02.00.03
- mpi2_sas.h             02.00.02            02.00.02
+ mpi2.h                 02.00.14            02.00.13
+ mpi2_cnfg.h            02.00.13            02.00.12
+ mpi2_init.h            02.00.08            02.00.07
+ mpi2_ioc.h             02.00.13            02.00.12
+ mpi2_raid.h            02.00.04            02.00.04
+ mpi2_sas.h             02.00.03            02.00.02
  mpi2_targ.h            02.00.03            02.00.03
- mpi2_tool.h            02.00.03            02.00.02
+ mpi2_tool.h            02.00.04            02.00.04
  mpi2_type.h            02.00.00            02.00.00
- mpi2_ra.h              02.00.00
- mpi2_history.txt       02.00.11            02.00.12
+ mpi2_ra.h              02.00.00            02.00.00
+ mpi2_hbd.h             02.00.00
+ mpi2_history.txt       02.00.14            02.00.13
 
 
  *  Date      Version   Description
@@ -65,6 +66,11 @@ mpi2.h
  *                      MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR and made those
  *                      bytes reserved.
  *                      Added RAID Accelerator functionality.
+ *  07-30-09  02.00.13  Bumped MPI2_HEADER_VERSION_UNIT.
+ *  10-28-09  02.00.14  Bumped MPI2_HEADER_VERSION_UNIT.
+ *                      Added MSI-x index mask and shift for Reply Post Host
+ *                      Index register.
+ *                      Added function code for Host Based Discovery Action.
  *  --------------------------------------------------------------------------
 
 mpi2_cnfg.h
@@ -155,6 +161,15 @@ mpi2_cnfg.h
  *                      Added expander reduced functionality data to SAS
  *                      Expander Page 0.
  *                      Added SAS PHY Page 2 and SAS PHY Page 3.
+ *  07-30-09  02.00.12  Added IO Unit Page 7.
+ *                      Added new device ids.
+ *                      Added SAS IO Unit Page 5.
+ *                      Added partial and slumber power management capable flags
+ *                      to SAS Device Page 0 Flags field.
+ *                      Added PhyInfo defines for power condition.
+ *                      Added Ethernet configuration pages.
+ *  10-28-09  02.00.13  Added MPI2_IOUNITPAGE1_ENABLE_HOST_BASED_DISCOVERY.
+ *                      Added SAS PHY Page 4 structure and defines.
  *  --------------------------------------------------------------------------
 
 mpi2_init.h
@@ -172,6 +187,10 @@ mpi2_init.h
  *                      Query Asynchronous Event.
  *                      Defined two new bits in the SlotStatus field of the SCSI
  *                      Enclosure Processor Request and Reply.
+ *  10-28-09  02.00.08  Added defines for decoding the ResponseInfo bytes for
+ *                      both SCSI IO Error Reply and SCSI Task Management Reply.
+ *                      Added ResponseInfo field to MPI2_SCSI_TASK_MANAGE_REPLY.
+ *                      Added MPI2_SCSITASKMGMT_RSP_TM_OVERLAPPED_TAG define.
  *  --------------------------------------------------------------------------
 
 mpi2_ioc.h
@@ -246,6 +265,20 @@ mpi2_ioc.h
  *                      Added two new reason codes for SAS Device Status Change
  *                      Event.
  *                      Added new event: SAS PHY Counter.
+ *  07-30-09  02.00.12  Added GPIO Interrupt event define and structure.
+ *                      Added MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER define.
+ *                      Added new product id family for 2208.
+ *  10-28-09  02.00.13  Added HostMSIxVectors field to MPI2_IOC_INIT_REQUEST.
+ *                      Added MaxMSIxVectors field to MPI2_IOC_FACTS_REPLY.
+ *                      Added MinDevHandle field to MPI2_IOC_FACTS_REPLY.
+ *                      Added MPI2_IOCFACTS_CAPABILITY_HOST_BASED_DISCOVERY.
+ *                      Added MPI2_EVENT_HOST_BASED_DISCOVERY_PHY define.
+ *                      Added MPI2_EVENT_SAS_TOPO_ES_NO_EXPANDER define.
+ *                      Added Host Based Discovery Phy Event data.
+ *                      Added defines for ProductID Product field
+ *                      (MPI2_FW_HEADER_PID_).
+ *                      Modified values for SAS ProductID Family
+ *                      (MPI2_FW_HEADER_PID_FAMILY_).
  *  --------------------------------------------------------------------------
 
 mpi2_raid.h
@@ -256,6 +289,8 @@ mpi2_raid.h
  *  05-21-08  02.00.03  Added MPI2_RAID_VOL_CREATION_NUM_PHYSDISKS so that
  *                      the PhysDisk array in MPI2_RAID_VOLUME_CREATION_STRUCT
  *                      can be sized by the build environment.
+ *  07-30-09  02.00.04  Added proper define for the Use Default Settings bit of
+ *                      VolumeCreationFlags and marked the old one as obsolete.
  *  --------------------------------------------------------------------------
 
 mpi2_sas.h
@@ -264,6 +299,8 @@ mpi2_sas.h
  *                      Control Request.
  *  10-02-08  02.00.02  Added Set IOC Parameter Operation to SAS IO Unit Control
  *                      Request.
+ *  10-28-09  02.00.03  Changed the type of SGL in MPI2_SATA_PASSTHROUGH_REQUEST
+ *                      to MPI2_SGE_IO_UNION since it supports chained SGLs.
  *  --------------------------------------------------------------------------
 
 mpi2_targ.h
@@ -283,6 +320,10 @@ mpi2_tool.h
  *                      structures and defines.
  *  02-29-08  02.00.02  Modified various names to make them 32-character unique.
  *  05-06-09  02.00.03  Added ISTWI Read Write Tool and Diagnostic CLI Tool.
+ *  07-30-09  02.00.04  Added ExtendedType field to DiagnosticBufferPost request
+ *                      and reply messages.
+ *                      Added MPI2_DIAG_BUF_TYPE_EXTENDED.
+ *                      Incremented MPI2_DIAG_BUF_TYPE_COUNT.
  *  --------------------------------------------------------------------------
 
 mpi2_type.h
@@ -293,20 +334,26 @@ mpi2_ra.h
  *  05-06-09  02.00.00  Initial version.
  *  --------------------------------------------------------------------------
 
+mpi2_hbd.h
+ *  10-28-09  02.00.00  Initial version.
+ *  --------------------------------------------------------------------------
+
+
 mpi2_history.txt         Parts list history
 
-Filename     02.00.12
-----------   --------
-mpi2.h       02.00.12
-mpi2_cnfg.h  02.00.11
-mpi2_init.h  02.00.07
-mpi2_ioc.h   02.00.11
-mpi2_raid.h  02.00.03
-mpi2_sas.h   02.00.02
-mpi2_targ.h  02.00.03
-mpi2_tool.h  02.00.03
-mpi2_type.h  02.00.00
-mpi2_ra.h    02.00.00
+Filename     02.00.14  02.00.13  02.00.12
+----------   --------  --------  --------
+mpi2.h       02.00.14  02.00.13  02.00.12
+mpi2_cnfg.h  02.00.13  02.00.12  02.00.11
+mpi2_init.h  02.00.08  02.00.07  02.00.07
+mpi2_ioc.h   02.00.13  02.00.12  02.00.11
+mpi2_raid.h  02.00.04  02.00.04  02.00.03
+mpi2_sas.h   02.00.03  02.00.02  02.00.02
+mpi2_targ.h  02.00.03  02.00.03  02.00.03
+mpi2_tool.h  02.00.04  02.00.04  02.00.03
+mpi2_type.h  02.00.00  02.00.00  02.00.00
+mpi2_ra.h    02.00.00  02.00.00  02.00.00
+mpi2_hbd.h   02.00.00
 
 Filename     02.00.11  02.00.10  02.00.09  02.00.08  02.00.07  02.00.06
 ----------   --------  --------  --------  --------  --------  --------
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_init.h b/drivers/scsi/mpt2sas/mpi/mpi2_init.h
index 563e56d2e945..6541945e97c3 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_init.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_init.h
@@ -6,7 +6,7 @@
  *          Title:  MPI SCSI initiator mode messages and structures
  *  Creation Date:  June 23, 2006
  *
- *    mpi2_init.h Version:  02.00.07
+ *    mpi2_init.h Version:  02.00.08
  *
  *  Version History
  *  ---------------
@@ -27,6 +27,10 @@
  *                      Query Asynchronous Event.
  *                      Defined two new bits in the SlotStatus field of the SCSI
  *                      Enclosure Processor Request and Reply.
+ *  10-28-09  02.00.08  Added defines for decoding the ResponseInfo bytes for
+ *                      both SCSI IO Error Reply and SCSI Task Management Reply.
+ *                      Added ResponseInfo field to MPI2_SCSI_TASK_MANAGE_REPLY.
+ *                      Added MPI2_SCSITASKMGMT_RSP_TM_OVERLAPPED_TAG define.
  *  --------------------------------------------------------------------------
  */
 
@@ -254,6 +258,11 @@ typedef struct _MPI2_SCSI_IO_REPLY
 #define MPI2_SCSI_STATE_AUTOSENSE_FAILED        (0x02)
 #define MPI2_SCSI_STATE_AUTOSENSE_VALID         (0x01)
 
+/* masks and shifts for the ResponseInfo field */
+
+#define MPI2_SCSI_RI_MASK_REASONCODE            (0x000000FF)
+#define MPI2_SCSI_RI_SHIFT_REASONCODE           (0)
+
 #define MPI2_SCSI_TASKTAG_UNKNOWN               (0xFFFF)
 
 
@@ -327,6 +336,7 @@ typedef struct _MPI2_SCSI_TASK_MANAGE_REPLY
     U16                     IOCStatus;                      /* 0x0E */
     U32                     IOCLogInfo;                     /* 0x10 */
     U32                     TerminationCount;               /* 0x14 */
+    U32                     ResponseInfo;                   /* 0x18 */
 } MPI2_SCSI_TASK_MANAGE_REPLY,
   MPI2_POINTER PTR_MPI2_SCSI_TASK_MANAGE_REPLY,
   Mpi2SCSITaskManagementReply_t, MPI2_POINTER pMpi2SCSIManagementReply_t;
@@ -339,8 +349,20 @@ typedef struct _MPI2_SCSI_TASK_MANAGE_REPLY
 #define MPI2_SCSITASKMGMT_RSP_TM_FAILED                 (0x05)
 #define MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED              (0x08)
 #define MPI2_SCSITASKMGMT_RSP_TM_INVALID_LUN            (0x09)
+#define MPI2_SCSITASKMGMT_RSP_TM_OVERLAPPED_TAG         (0x0A)
 #define MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC          (0x80)
 
+/* masks and shifts for the ResponseInfo field */
+
+#define MPI2_SCSITASKMGMT_RI_MASK_REASONCODE            (0x000000FF)
+#define MPI2_SCSITASKMGMT_RI_SHIFT_REASONCODE           (0)
+#define MPI2_SCSITASKMGMT_RI_MASK_ARI2                  (0x0000FF00)
+#define MPI2_SCSITASKMGMT_RI_SHIFT_ARI2                 (8)
+#define MPI2_SCSITASKMGMT_RI_MASK_ARI1                  (0x00FF0000)
+#define MPI2_SCSITASKMGMT_RI_SHIFT_ARI1                 (16)
+#define MPI2_SCSITASKMGMT_RI_MASK_ARI0                  (0xFF000000)
+#define MPI2_SCSITASKMGMT_RI_SHIFT_ARI0                 (24)
+
 
 /****************************************************************************
 *  SCSI Enclosure Processor messages
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_ioc.h b/drivers/scsi/mpt2sas/mpi/mpi2_ioc.h
index c294128bdeb4..754938422f6a 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_ioc.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_ioc.h
@@ -6,7 +6,7 @@
  *          Title:  MPI IOC, Port, Event, FW Download, and FW Upload messages
  *  Creation Date:  October 11, 2006
  *
- *  mpi2_ioc.h Version:  02.00.11
+ *  mpi2_ioc.h Version:  02.00.13
  *
  *  Version History
  *  ---------------
@@ -84,6 +84,20 @@
  *                      Added two new reason codes for SAS Device Status Change
  *                      Event.
  *                      Added new event: SAS PHY Counter.
+ *  07-30-09  02.00.12  Added GPIO Interrupt event define and structure.
+ *                      Added MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER define.
+ *                      Added new product id family for 2208.
+ *  10-28-09  02.00.13  Added HostMSIxVectors field to MPI2_IOC_INIT_REQUEST.
+ *                      Added MaxMSIxVectors field to MPI2_IOC_FACTS_REPLY.
+ *                      Added MinDevHandle field to MPI2_IOC_FACTS_REPLY.
+ *                      Added MPI2_IOCFACTS_CAPABILITY_HOST_BASED_DISCOVERY.
+ *                      Added MPI2_EVENT_HOST_BASED_DISCOVERY_PHY define.
+ *                      Added MPI2_EVENT_SAS_TOPO_ES_NO_EXPANDER define.
+ *                      Added Host Based Discovery Phy Event data.
+ *                      Added defines for ProductID Product field
+ *                      (MPI2_FW_HEADER_PID_).
+ *                      Modified values for SAS ProductID Family
+ *                      (MPI2_FW_HEADER_PID_FAMILY_).
  *  --------------------------------------------------------------------------
  */
 
@@ -116,8 +130,10 @@ typedef struct _MPI2_IOC_INIT_REQUEST
     U16                     MsgVersion;                     /* 0x0C */
     U16                     HeaderVersion;                  /* 0x0E */
     U32                     Reserved5;                      /* 0x10 */
-    U32                     Reserved6;                      /* 0x14 */
-    U16                     Reserved7;                      /* 0x18 */
+    U16                     Reserved6;                      /* 0x14 */
+    U8                      Reserved7;                      /* 0x16 */
+    U8                      HostMSIxVectors;                /* 0x17 */
+    U16                     Reserved8;                      /* 0x18 */
     U16                     SystemRequestFrameSize;         /* 0x1A */
     U16                     ReplyDescriptorPostQueueDepth;  /* 0x1C */
     U16                     ReplyFreeQueueDepth;            /* 0x1E */
@@ -212,7 +228,7 @@ typedef struct _MPI2_IOC_FACTS_REPLY
     U8                      MaxChainDepth;                  /* 0x14 */
     U8                      WhoInit;                        /* 0x15 */
     U8                      NumberOfPorts;                  /* 0x16 */
-    U8                      Reserved2;                      /* 0x17 */
+    U8                      MaxMSIxVectors;                 /* 0x17 */
     U16                     RequestCredit;                  /* 0x18 */
     U16                     ProductID;                      /* 0x1A */
     U32                     IOCCapabilities;                /* 0x1C */
@@ -230,7 +246,8 @@ typedef struct _MPI2_IOC_FACTS_REPLY
     U8                      MaxVolumes;                     /* 0x37 */
     U16                     MaxDevHandle;                   /* 0x38 */
     U16                     MaxPersistentEntries;           /* 0x3A */
-    U32                     Reserved4;                      /* 0x3C */
+    U16                     MinDevHandle;                   /* 0x3C */
+    U16                     Reserved4;                      /* 0x3E */
 } MPI2_IOC_FACTS_REPLY, MPI2_POINTER PTR_MPI2_IOC_FACTS_REPLY,
   Mpi2IOCFactsReply_t, MPI2_POINTER pMpi2IOCFactsReply_t;
 
@@ -266,6 +283,7 @@ typedef struct _MPI2_IOC_FACTS_REPLY
 /* ProductID field uses MPI2_FW_HEADER_PID_ */
 
 /* IOCCapabilities */
+#define MPI2_IOCFACTS_CAPABILITY_HOST_BASED_DISCOVERY   (0x00010000)
 #define MPI2_IOCFACTS_CAPABILITY_MSI_X_INDEX            (0x00008000)
 #define MPI2_IOCFACTS_CAPABILITY_RAID_ACCELERATOR       (0x00004000)
 #define MPI2_IOCFACTS_CAPABILITY_EVENT_REPLAY           (0x00002000)
@@ -274,6 +292,7 @@ typedef struct _MPI2_IOC_FACTS_REPLY
 #define MPI2_IOCFACTS_CAPABILITY_MULTICAST              (0x00000100)
 #define MPI2_IOCFACTS_CAPABILITY_BIDIRECTIONAL_TARGET   (0x00000080)
 #define MPI2_IOCFACTS_CAPABILITY_EEDP                   (0x00000040)
+#define MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER        (0x00000020)
 #define MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER        (0x00000010)
 #define MPI2_IOCFACTS_CAPABILITY_DIAG_TRACE_BUFFER      (0x00000008)
 #define MPI2_IOCFACTS_CAPABILITY_TASK_SET_FULL_HANDLING (0x00000004)
@@ -448,6 +467,8 @@ typedef struct _MPI2_EVENT_NOTIFICATION_REPLY
 #define MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST     (0x0020)
 #define MPI2_EVENT_LOG_ENTRY_ADDED                  (0x0021)
 #define MPI2_EVENT_SAS_PHY_COUNTER                  (0x0022)
+#define MPI2_EVENT_GPIO_INTERRUPT                   (0x0023)
+#define MPI2_EVENT_HOST_BASED_DISCOVERY_PHY         (0x0024)
 
 
 /* Log Entry Added Event data */
@@ -469,6 +490,16 @@ typedef struct _MPI2_EVENT_DATA_LOG_ENTRY_ADDED
   MPI2_POINTER PTR_MPI2_EVENT_DATA_LOG_ENTRY_ADDED,
   Mpi2EventDataLogEntryAdded_t, MPI2_POINTER pMpi2EventDataLogEntryAdded_t;
 
+/* GPIO Interrupt Event data */
+
+typedef struct _MPI2_EVENT_DATA_GPIO_INTERRUPT {
+    U8          GPIONum;                            /* 0x00 */
+    U8          Reserved1;                          /* 0x01 */
+    U16         Reserved2;                          /* 0x02 */
+} MPI2_EVENT_DATA_GPIO_INTERRUPT,
+  MPI2_POINTER PTR_MPI2_EVENT_DATA_GPIO_INTERRUPT,
+  Mpi2EventDataGpioInterrupt_t, MPI2_POINTER pMpi2EventDataGpioInterrupt_t;
+
 /* Hard Reset Received Event data */
 
 typedef struct _MPI2_EVENT_DATA_HARD_RESET_RECEIVED
@@ -778,6 +809,7 @@ typedef struct _MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST
   MPI2_POINTER pMpi2EventDataSasTopologyChangeList_t;
 
 /* values for the ExpStatus field */
+#define MPI2_EVENT_SAS_TOPO_ES_NO_EXPANDER                  (0x00)
 #define MPI2_EVENT_SAS_TOPO_ES_ADDED                        (0x01)
 #define MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING               (0x02)
 #define MPI2_EVENT_SAS_TOPO_ES_RESPONDING                   (0x03)
@@ -863,6 +895,44 @@ typedef struct _MPI2_EVENT_DATA_SAS_PHY_COUNTER {
  * */
 
 
+/* Host Based Discovery Phy Event data */
+
+typedef struct _MPI2_EVENT_HBD_PHY_SAS {
+    U8          Flags;                      /* 0x00 */
+    U8          NegotiatedLinkRate;         /* 0x01 */
+    U8          PhyNum;                     /* 0x02 */
+    U8          PhysicalPort;               /* 0x03 */
+    U32         Reserved1;                  /* 0x04 */
+    U8          InitialFrame[28];           /* 0x08 */
+} MPI2_EVENT_HBD_PHY_SAS, MPI2_POINTER PTR_MPI2_EVENT_HBD_PHY_SAS,
+  Mpi2EventHbdPhySas_t, MPI2_POINTER pMpi2EventHbdPhySas_t;
+
+/* values for the Flags field */
+#define MPI2_EVENT_HBD_SAS_FLAGS_FRAME_VALID        (0x02)
+#define MPI2_EVENT_HBD_SAS_FLAGS_SATA_FRAME         (0x01)
+
+/* use MPI2_SAS_NEG_LINK_RATE_ defines from mpi2_cnfg.h for
+ * the NegotiatedLinkRate field */
+
+typedef union _MPI2_EVENT_HBD_DESCRIPTOR {
+    MPI2_EVENT_HBD_PHY_SAS      Sas;
+} MPI2_EVENT_HBD_DESCRIPTOR, MPI2_POINTER PTR_MPI2_EVENT_HBD_DESCRIPTOR,
+  Mpi2EventHbdDescriptor_t, MPI2_POINTER pMpi2EventHbdDescriptor_t;
+
+typedef struct _MPI2_EVENT_DATA_HBD_PHY {
+    U8                          DescriptorType;     /* 0x00 */
+    U8                          Reserved1;          /* 0x01 */
+    U16                         Reserved2;          /* 0x02 */
+    U32                         Reserved3;          /* 0x04 */
+    MPI2_EVENT_HBD_DESCRIPTOR   Descriptor;         /* 0x08 */
+} MPI2_EVENT_DATA_HBD_PHY, MPI2_POINTER PTR_MPI2_EVENT_DATA_HBD_PHY,
+  Mpi2EventDataHbdPhy_t, MPI2_POINTER pMpi2EventDataMpi2EventDataHbdPhy_t;
+
+/* values for the DescriptorType field */
+#define MPI2_EVENT_HBD_DT_SAS               (0x01)
+
+
+
 /****************************************************************************
 *  EventAck message
 ****************************************************************************/
@@ -1111,12 +1181,17 @@ typedef struct _MPI2_FW_IMAGE_HEADER
 #define MPI2_FW_HEADER_PID_TYPE_MASK            (0xF000)
 #define MPI2_FW_HEADER_PID_TYPE_SAS             (0x2000)
 
-#define MPI2_FW_HEADER_PID_PROD_MASK            (0x0F00)
-#define MPI2_FW_HEADER_PID_PROD_A               (0x0000)
+#define MPI2_FW_HEADER_PID_PROD_MASK                    (0x0F00)
+#define MPI2_FW_HEADER_PID_PROD_A                       (0x0000)
+#define MPI2_FW_HEADER_PID_PROD_MASK                    (0x0F00)
+#define MPI2_FW_HEADER_PID_PROD_TARGET_INITIATOR_SCSI   (0x0200)
+#define MPI2_FW_HEADER_PID_PROD_IR_SCSI                 (0x0700)
+
 
 #define MPI2_FW_HEADER_PID_FAMILY_MASK          (0x00FF)
 /* SAS */
-#define MPI2_FW_HEADER_PID_FAMILY_2108_SAS      (0x0010)
+#define MPI2_FW_HEADER_PID_FAMILY_2108_SAS      (0x0013)
+#define MPI2_FW_HEADER_PID_FAMILY_2208_SAS      (0x0014)
 
 /* use MPI2_IOCFACTS_PROTOCOL_ defines for ProtocolFlags field */
 
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_raid.h b/drivers/scsi/mpt2sas/mpi/mpi2_raid.h
index 7134816d9046..5160c33d2a00 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_raid.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_raid.h
@@ -6,7 +6,7 @@
  *          Title:  MPI Integrated RAID messages and structures
  *  Creation Date:  April 26, 2007
  *
- *    mpi2_raid.h Version:  02.00.03
+ *    mpi2_raid.h Version:  02.00.04
  *
  *  Version History
  *  ---------------
@@ -20,6 +20,8 @@
  *  05-21-08  02.00.03  Added MPI2_RAID_VOL_CREATION_NUM_PHYSDISKS so that
  *                      the PhysDisk array in MPI2_RAID_VOLUME_CREATION_STRUCT
  *                      can be sized by the build environment.
+ *  07-30-09  02.00.04  Added proper define for the Use Default Settings bit of
+ *                      VolumeCreationFlags and marked the old one as obsolete.
  *  --------------------------------------------------------------------------
  */
 
@@ -217,10 +219,14 @@ typedef struct _MPI2_RAID_VOLUME_CREATION_STRUCT
 /* use MPI2_RAID_VOL_TYPE_ defines from mpi2_cnfg.h for VolumeType */
 
 /* defines for the VolumeCreationFlags field */
+#define MPI2_RAID_VOL_CREATION_DEFAULT_SETTINGS     (0x80000000)
+#define MPI2_RAID_VOL_CREATION_BACKGROUND_INIT      (0x00000004)
+#define MPI2_RAID_VOL_CREATION_LOW_LEVEL_INIT       (0x00000002)
+#define MPI2_RAID_VOL_CREATION_MIGRATE_DATA         (0x00000001)
+/* The following is an obsolete define.
+ * It must be shifted left 24 bits in order to set the proper bit.
+ */
 #define MPI2_RAID_VOL_CREATION_USE_DEFAULT_SETTINGS (0x80)
-#define MPI2_RAID_VOL_CREATION_BACKGROUND_INIT      (0x04)
-#define MPI2_RAID_VOL_CREATION_LOW_LEVEL_INIT       (0x02)
-#define MPI2_RAID_VOL_CREATION_MIGRATE_DATA         (0x01)
 
 
 /* RAID Online Capacity Expansion Structure */
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_sas.h b/drivers/scsi/mpt2sas/mpi/mpi2_sas.h
index 8a42b136cf53..2d8aeed51392 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_sas.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_sas.h
@@ -6,7 +6,7 @@
  *          Title:  MPI Serial Attached SCSI structures and definitions
  *  Creation Date:  February 9, 2007
  *
- *  mpi2.h Version:  02.00.02
+ *  mpi2.h Version:  02.00.03
  *
  *  Version History
  *  ---------------
@@ -18,6 +18,8 @@
  *                      Control Request.
  *  10-02-08  02.00.02  Added Set IOC Parameter Operation to SAS IO Unit Control
  *                      Request.
+ *  10-28-09  02.00.03  Changed the type of SGL in MPI2_SATA_PASSTHROUGH_REQUEST
+ *                      to MPI2_SGE_IO_UNION since it supports chained SGLs.
  *  --------------------------------------------------------------------------
  */
 
@@ -160,7 +162,7 @@ typedef struct _MPI2_SATA_PASSTHROUGH_REQUEST
     U32                     Reserved4;          /* 0x14 */
     U32                     DataLength;         /* 0x18 */
     U8                      CommandFIS[20];     /* 0x1C */
-    MPI2_SIMPLE_SGE_UNION   SGL;                /* 0x20 */
+    MPI2_SGE_IO_UNION       SGL;                /* 0x20 */
 } MPI2_SATA_PASSTHROUGH_REQUEST, MPI2_POINTER PTR_MPI2_SATA_PASSTHROUGH_REQUEST,
   Mpi2SataPassthroughRequest_t, MPI2_POINTER pMpi2SataPassthroughRequest_t;
 
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_tool.h b/drivers/scsi/mpt2sas/mpi/mpi2_tool.h
index 007e950f7bfa..73fcdbf92632 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_tool.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_tool.h
@@ -6,7 +6,7 @@
  *          Title:  MPI diagnostic tool structures and definitions
  *  Creation Date:  March 26, 2007
  *
- *    mpi2_tool.h Version:  02.00.03
+ *    mpi2_tool.h Version:  02.00.04
  *
  *  Version History
  *  ---------------
@@ -18,6 +18,10 @@
  *                      structures and defines.
  *  02-29-08  02.00.02  Modified various names to make them 32-character unique.
  *  05-06-09  02.00.03  Added ISTWI Read Write Tool and Diagnostic CLI Tool.
+ *  07-30-09  02.00.04  Added ExtendedType field to DiagnosticBufferPost request
+ *                      and reply messages.
+ *                      Added MPI2_DIAG_BUF_TYPE_EXTENDED.
+ *                      Incremented MPI2_DIAG_BUF_TYPE_COUNT.
  *  --------------------------------------------------------------------------
  */
 
@@ -282,7 +286,7 @@ typedef struct _MPI2_TOOLBOX_DIAGNOSTIC_CLI_REPLY {
 
 typedef struct _MPI2_DIAG_BUFFER_POST_REQUEST
 {
-    U8                      Reserved1;                  /* 0x00 */
+    U8                      ExtendedType;               /* 0x00 */
     U8                      BufferType;                 /* 0x01 */
     U8                      ChainOffset;                /* 0x02 */
     U8                      Function;                   /* 0x03 */
@@ -301,11 +305,15 @@ typedef struct _MPI2_DIAG_BUFFER_POST_REQUEST
 } MPI2_DIAG_BUFFER_POST_REQUEST, MPI2_POINTER PTR_MPI2_DIAG_BUFFER_POST_REQUEST,
   Mpi2DiagBufferPostRequest_t, MPI2_POINTER pMpi2DiagBufferPostRequest_t;
 
+/* values for the ExtendedType field */
+#define MPI2_DIAG_EXTENDED_TYPE_UTILIZATION         (0x02)
+
 /* values for the BufferType field */
 #define MPI2_DIAG_BUF_TYPE_TRACE                    (0x00)
 #define MPI2_DIAG_BUF_TYPE_SNAPSHOT                 (0x01)
+#define MPI2_DIAG_BUF_TYPE_EXTENDED                 (0x02)
 /* count of the number of buffer types */
-#define MPI2_DIAG_BUF_TYPE_COUNT                    (0x02)
+#define MPI2_DIAG_BUF_TYPE_COUNT                    (0x03)
 
 
 /****************************************************************************
@@ -314,7 +322,7 @@ typedef struct _MPI2_DIAG_BUFFER_POST_REQUEST
 
 typedef struct _MPI2_DIAG_BUFFER_POST_REPLY
 {
-    U8                      Reserved1;                  /* 0x00 */
+    U8                      ExtendedType;               /* 0x00 */
     U8                      BufferType;                 /* 0x01 */
     U8                      MsgLength;                  /* 0x02 */
     U8                      Function;                   /* 0x03 */
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.c b/drivers/scsi/mpt2sas/mpt2sas_base.c
index 670241efa4b5..88e6eebc3159 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.c
@@ -57,6 +57,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/sort.h>
 #include <linux/io.h>
+#include <linux/time.h>
 
 #include "mpt2sas_base.h"
 
@@ -77,6 +78,43 @@ static int msix_disable = -1;
 module_param(msix_disable, int, 0);
 MODULE_PARM_DESC(msix_disable, " disable msix routed interrupts (default=0)");
 
+/* diag_buffer_enable is bitwise
+ * bit 0 set = TRACE
+ * bit 1 set = SNAPSHOT
+ * bit 2 set = EXTENDED
+ *
+ * Either bit can be set, or both
+ */
+static int diag_buffer_enable;
+module_param(diag_buffer_enable, int, 0);
+MODULE_PARM_DESC(diag_buffer_enable, " post diag buffers "
+    "(TRACE=1/SNAPSHOT=2/EXTENDED=4/default=0)");
+
+int mpt2sas_fwfault_debug;
+MODULE_PARM_DESC(mpt2sas_fwfault_debug, " enable detection of firmware fault "
+    "and halt firmware - (default=0)");
+
+/**
+ * _scsih_set_fwfault_debug - global setting of ioc->fwfault_debug.
+ *
+ */
+static int
+_scsih_set_fwfault_debug(const char *val, struct kernel_param *kp)
+{
+        int ret = param_set_int(val, kp);
+        struct MPT2SAS_ADAPTER *ioc;
+
+        if (ret)
+                return ret;
+
+        printk(KERN_INFO "setting fwfault_debug(%d)\n", mpt2sas_fwfault_debug);
+        list_for_each_entry(ioc, &mpt2sas_ioc_list, list)
+                ioc->fwfault_debug = mpt2sas_fwfault_debug;
+        return 0;
+}
+module_param_call(mpt2sas_fwfault_debug, _scsih_set_fwfault_debug,
+    param_get_int, &mpt2sas_fwfault_debug, 0644);
+
 /**
  * _base_fault_reset_work - workq handling ioc fault conditions
  * @work: input argument, used to derive ioc
@@ -121,7 +159,7 @@ _base_fault_reset_work(struct work_struct *work)
 
 /**
  * mpt2sas_base_start_watchdog - start the fault_reset_work_q
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * Context: sleep.
  *
  * Return nothing.
@@ -155,7 +193,7 @@ mpt2sas_base_start_watchdog(struct MPT2SAS_ADAPTER *ioc)
 
 /**
  * mpt2sas_base_stop_watchdog - stop the fault_reset_work_q
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * Context: sleep.
  *
  * Return nothing.
@@ -177,10 +215,55 @@ mpt2sas_base_stop_watchdog(struct MPT2SAS_ADAPTER *ioc)
         }
 }
 
+/**
+ * mpt2sas_base_fault_info - verbose translation of firmware FAULT code
+ * @ioc: per adapter object
+ * @fault_code: fault code
+ *
+ * Return nothing.
+ */
+void
+mpt2sas_base_fault_info(struct MPT2SAS_ADAPTER *ioc , u16 fault_code)
+{
+        printk(MPT2SAS_ERR_FMT "fault_state(0x%04x)!\n",
+            ioc->name, fault_code);
+}
+
+/**
+ * mpt2sas_halt_firmware - halt's mpt controller firmware
+ * @ioc: per adapter object
+ *
+ * For debugging timeout related issues.  Writing 0xCOFFEE00
+ * to the doorbell register will halt controller firmware. With
+ * the purpose to stop both driver and firmware, the enduser can
+ * obtain a ring buffer from controller UART.
+ */
+void
+mpt2sas_halt_firmware(struct MPT2SAS_ADAPTER *ioc)
+{
+        u32 doorbell;
+
+        if (!ioc->fwfault_debug)
+                return;
+
+        dump_stack();
+
+        doorbell = readl(&ioc->chip->Doorbell);
+        if ((doorbell & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT)
+                mpt2sas_base_fault_info(ioc , doorbell);
+        else {
+                writel(0xC0FFEE00, &ioc->chip->Doorbell);
+                printk(MPT2SAS_ERR_FMT "Firmware is halted due to command "
+                    "timeout\n", ioc->name);
+        }
+
+        panic("panic in %s\n", __func__);
+}
+
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
 /**
  * _base_sas_ioc_info - verbose translation of the ioc status
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * @mpi_reply: reply mf payload returned from firmware
  * @request_hdr: request mf
  *
@@ -394,7 +477,7 @@ _base_sas_ioc_info(struct MPT2SAS_ADAPTER *ioc, MPI2DefaultReply_t *mpi_reply,
 
 /**
  * _base_display_event_data - verbose translation of firmware asyn events
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * @mpi_reply: reply mf payload returned from firmware
  *
  * Return nothing.
@@ -474,7 +557,7 @@ _base_display_event_data(struct MPT2SAS_ADAPTER *ioc,
 
 /**
  * _base_sas_log_info - verbose translation of firmware log info
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * @log_info: log info
  *
  * Return nothing.
@@ -526,22 +609,8 @@ _base_sas_log_info(struct MPT2SAS_ADAPTER *ioc , u32 log_info)
 }
 
 /**
- * mpt2sas_base_fault_info - verbose translation of firmware FAULT code
- * @ioc: pointer to scsi command object
- * @fault_code: fault code
- *
- * Return nothing.
- */
-void
-mpt2sas_base_fault_info(struct MPT2SAS_ADAPTER *ioc , u16 fault_code)
-{
-        printk(MPT2SAS_ERR_FMT "fault_state(0x%04x)!\n",
-            ioc->name, fault_code);
-}
-
-/**
  * _base_display_reply_info -
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * @smid: system request message index
  * @msix_index: MSIX table index supplied by the OS
  * @reply: reply message frame(lower 32bit addr)
@@ -570,7 +639,7 @@ _base_display_reply_info(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
 
 /**
  * mpt2sas_base_done - base internal command completion routine
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * @smid: system request message index
  * @msix_index: MSIX table index supplied by the OS
  * @reply: reply message frame(lower 32bit addr)
@@ -603,7 +672,7 @@ mpt2sas_base_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
 
 /**
  * _base_async_event - main callback handler for firmware asyn events
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  * @msix_index: MSIX table index supplied by the OS
  * @reply: reply message frame(lower 32bit addr)
  *
@@ -684,7 +753,7 @@ _base_get_cb_idx(struct MPT2SAS_ADAPTER *ioc, u16 smid)
 
 /**
  * _base_mask_interrupts - disable interrupts
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  *
  * Disabling ResetIRQ, Reply and Doorbell Interrupts
  *
@@ -704,7 +773,7 @@ _base_mask_interrupts(struct MPT2SAS_ADAPTER *ioc)
 
 /**
  * _base_unmask_interrupts - enable interrupts
- * @ioc: pointer to scsi command object
+ * @ioc: per adapter object
  *
  * Enabling only Reply Interrupts
  *
@@ -1152,6 +1221,8 @@ mpt2sas_base_map_resources(struct MPT2SAS_ADAPTER *ioc)
         u32 memap_sz;
         u32 pio_sz;
         int i, r = 0;
+        u64 pio_chip = 0;
+        u64 chip_phys = 0;
 
         dinitprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n",
             ioc->name, __func__));
@@ -1185,12 +1256,13 @@ mpt2sas_base_map_resources(struct MPT2SAS_ADAPTER *ioc)
                 if (pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE_IO) {
                         if (pio_sz)
                                 continue;
-                        ioc->pio_chip = pci_resource_start(pdev, i);
+                        pio_chip = (u64)pci_resource_start(pdev, i);
                         pio_sz = pci_resource_len(pdev, i);
                 } else {
                         if (memap_sz)
                                 continue;
                         ioc->chip_phys = pci_resource_start(pdev, i);
+                        chip_phys = (u64)ioc->chip_phys;
                         memap_sz = pci_resource_len(pdev, i);
                         ioc->chip = ioremap(ioc->chip_phys, memap_sz);
                         if (ioc->chip == NULL) {
@@ -1210,10 +1282,10 @@ mpt2sas_base_map_resources(struct MPT2SAS_ADAPTER *ioc)
         printk(MPT2SAS_INFO_FMT "%s: IRQ %d\n",
             ioc->name,  ((ioc->msix_enable) ? "PCI-MSI-X enabled" :
             "IO-APIC enabled"), ioc->pci_irq);
-        printk(MPT2SAS_INFO_FMT "iomem(0x%lx), mapped(0x%p), size(%d)\n",
-            ioc->name, ioc->chip_phys, ioc->chip, memap_sz);
-        printk(MPT2SAS_INFO_FMT "ioport(0x%lx), size(%d)\n",
-            ioc->name, ioc->pio_chip, pio_sz);
+        printk(MPT2SAS_INFO_FMT "iomem(0x%016llx), mapped(0x%p), size(%d)\n",
+            ioc->name, (unsigned long long)chip_phys, ioc->chip, memap_sz);
+        printk(MPT2SAS_INFO_FMT "ioport(0x%016llx), size(%d)\n",
+            ioc->name, (unsigned long long)pio_chip, pio_sz);
 
         return 0;
 
@@ -1258,12 +1330,13 @@ mpt2sas_base_get_sense_buffer(struct MPT2SAS_ADAPTER *ioc, u16 smid)
  * @ioc: per adapter object
  * @smid: system request message index
  *
- * Returns phys pointer to sense buffer.
+ * Returns phys pointer to the low 32bit address of the sense buffer.
  */
-dma_addr_t
+__le32
 mpt2sas_base_get_sense_buffer_dma(struct MPT2SAS_ADAPTER *ioc, u16 smid)
 {
-        return ioc->sense_dma + ((smid - 1) * SCSI_SENSE_BUFFERSIZE);
+        return cpu_to_le32(ioc->sense_dma +
+                        ((smid - 1) * SCSI_SENSE_BUFFERSIZE));
 }
 
 /**
@@ -1697,6 +1770,12 @@ _base_display_ioc_capabilities(struct MPT2SAS_ADAPTER *ioc)
         }
 
         if (ioc->facts.IOCCapabilities &
+            MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER) {
+                printk(KERN_INFO "%sDiag Extended Buffer", i ? "," : "");
+                i++;
+        }
+
+        if (ioc->facts.IOCCapabilities &
             MPI2_IOCFACTS_CAPABILITY_TASK_SET_FULL_HANDLING) {
                 printk("%sTask Set Full", i ? "," : "");
                 i++;
@@ -2871,6 +2950,8 @@ _base_send_ioc_init(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
         Mpi2IOCInitRequest_t mpi_request;
         Mpi2IOCInitReply_t mpi_reply;
         int r;
+        struct timeval current_time;
+        u16 ioc_status;
 
         dinitprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
             __func__));
@@ -2921,6 +3002,13 @@ _base_send_ioc_init(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
             cpu_to_le32(ioc->reply_post_free_dma);
 #endif
 
+        /* This time stamp specifies number of milliseconds
+         * since epoch ~ midnight January 1, 1970.
+         */
+        do_gettimeofday(&current_time);
+        mpi_request.TimeStamp = (current_time.tv_sec * 1000) +
+            (current_time.tv_usec >> 3);
+
         if (ioc->logging_level & MPT_DEBUG_INIT) {
                 u32 *mfp;
                 int i;
@@ -2943,7 +3031,8 @@ _base_send_ioc_init(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
                 return r;
         }
 
-        if (mpi_reply.IOCStatus != MPI2_IOCSTATUS_SUCCESS ||
+        ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
+        if (ioc_status != MPI2_IOCSTATUS_SUCCESS ||
             mpi_reply.IOCLogInfo) {
                 printk(MPT2SAS_ERR_FMT "%s: failed\n", ioc->name, __func__);
                 r = -EIO;
@@ -3461,11 +3550,11 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
                 return r;
 
         pci_set_drvdata(ioc->pdev, ioc->shost);
-        r = _base_make_ioc_ready(ioc, CAN_SLEEP, SOFT_RESET);
+        r = _base_get_ioc_facts(ioc, CAN_SLEEP);
         if (r)
                 goto out_free_resources;
 
-        r = _base_get_ioc_facts(ioc, CAN_SLEEP);
+        r = _base_make_ioc_ready(ioc, CAN_SLEEP, SOFT_RESET);
         if (r)
                 goto out_free_resources;
 
@@ -3486,6 +3575,8 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
 
         init_waitqueue_head(&ioc->reset_wq);
 
+        ioc->fwfault_debug = mpt2sas_fwfault_debug;
+
         /* base internal command bits */
         mutex_init(&ioc->base_cmds.mutex);
         ioc->base_cmds.reply = kzalloc(ioc->reply_sz, GFP_KERNEL);
@@ -3496,6 +3587,11 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
         ioc->transport_cmds.status = MPT2_CMD_NOT_USED;
         mutex_init(&ioc->transport_cmds.mutex);
 
+        /* scsih internal command bits */
+        ioc->scsih_cmds.reply = kzalloc(ioc->reply_sz, GFP_KERNEL);
+        ioc->scsih_cmds.status = MPT2_CMD_NOT_USED;
+        mutex_init(&ioc->scsih_cmds.mutex);
+
         /* task management internal command bits */
         ioc->tm_cmds.reply = kzalloc(ioc->reply_sz, GFP_KERNEL);
         ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
@@ -3531,6 +3627,8 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
                 goto out_free_resources;
 
         mpt2sas_base_start_watchdog(ioc);
+        if (diag_buffer_enable != 0)
+                mpt2sas_enable_diag_buffer(ioc, diag_buffer_enable);
         return 0;
 
  out_free_resources:
@@ -3684,6 +3782,9 @@ mpt2sas_base_hard_reset_handler(struct MPT2SAS_ADAPTER *ioc, int sleep_flag,
         dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: enter\n", ioc->name,
             __func__));
 
+        if (mpt2sas_fwfault_debug)
+                mpt2sas_halt_firmware(ioc);
+
         spin_lock_irqsave(&ioc->ioc_reset_in_progress_lock, flags);
         if (ioc->shost_recovery) {
                 spin_unlock_irqrestore(&ioc->ioc_reset_in_progress_lock, flags);
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.h b/drivers/scsi/mpt2sas/mpt2sas_base.h
index 0cf6bc236e4d..e18b0544c38f 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.h
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.h
@@ -69,10 +69,10 @@
 #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          "02.100.03.00"
-#define MPT2SAS_MAJOR_VERSION           02
+#define MPT2SAS_DRIVER_VERSION          "04.100.01.00"
+#define MPT2SAS_MAJOR_VERSION           04
 #define MPT2SAS_MINOR_VERSION           100
-#define MPT2SAS_BUILD_VERSION           03
+#define MPT2SAS_BUILD_VERSION           01
 #define MPT2SAS_RELEASE_VERSION         00
 
 /*
@@ -278,7 +278,7 @@ struct _internal_cmd {
  * @sas_address: device sas address
  * @device_name: retrieved from the SAS IDENTIFY frame.
  * @handle: device handle
- * @parent_handle: handle to parent device
+ * @sas_address_parent: sas address of parent expander or sas host
  * @enclosure_handle: enclosure handle
  * @enclosure_logical_id: enclosure logical identifier
  * @volume_handle: volume handle (valid when hidden raid member)
@@ -296,7 +296,7 @@ struct _sas_device {
         u64     sas_address;
         u64     device_name;
         u16     handle;
-        u16     parent_handle;
+        u64     sas_address_parent;
         u16     enclosure_handle;
         u64     enclosure_logical_id;
         u16     volume_handle;
@@ -323,6 +323,7 @@ struct _sas_device {
  * @device_info: bitfield provides detailed info about the hidden components
  * @num_pds: number of hidden raid components
  * @responding: used in _scsih_raid_device_mark_responding
+ * @percent_complete: resync percent complete
  */
 struct _raid_device {
         struct list_head list;
@@ -336,6 +337,7 @@ struct _raid_device {
         u32     device_info;
         u8      num_pds;
         u8      responding;
+        u8      percent_complete;
 };
 
 /**
@@ -352,8 +354,6 @@ struct _boot_device {
 /**
  * struct _sas_port - wide/narrow sas port information
  * @port_list: list of ports belonging to expander
- * @handle: device handle for this port
- * @sas_address: sas address of this port
  * @num_phys: number of phys belonging to this port
  * @remote_identify: attached device identification
  * @rphy: sas transport rphy object
@@ -362,8 +362,6 @@ struct _boot_device {
  */
 struct _sas_port {
         struct list_head port_list;
-        u16     handle;
-        u64     sas_address;
         u8      num_phys;
         struct sas_identify remote_identify;
         struct sas_rphy *rphy;
@@ -398,7 +396,7 @@ struct _sas_phy {
  * @num_phys: number phys belonging to this sas_host/expander
  * @sas_address: sas address of this sas_host/expander
  * @handle: handle for this sas_host/expander
- * @parent_handle: parent handle
+ * @sas_address_parent: sas address of parent expander or sas host
  * @enclosure_handle: handle for this a member of an enclosure
  * @device_info: bitwise defining capabilities of this sas_host/expander
  * @responding: used in _scsih_expander_device_mark_responding
@@ -411,7 +409,7 @@ struct _sas_node {
         u8      num_phys;
         u64     sas_address;
         u16     handle;
-        u16     parent_handle;
+        u64     sas_address_parent;
         u16     enclosure_handle;
         u64     enclosure_logical_id;
         u8      responding;
@@ -468,8 +466,8 @@ typedef void (*MPT_ADD_SGE)(void *paddr, u32 flags_length, dma_addr_t dma_addr);
  * @pdev: pci pdev object
  * @chip: memory mapped register space
  * @chip_phys: physical addrss prior to mapping
- * @pio_chip: I/O mapped register space
  * @logging_level: see mpt2sas_debug.h
+ * @fwfault_debug: debuging FW timeouts
  * @ir_firmware: IR firmware present
  * @bars: bitmask of BAR's that must be configured
  * @mask_interrupts: ignore interrupt
@@ -495,12 +493,14 @@ typedef void (*MPT_ADD_SGE)(void *paddr, u32 flags_length, dma_addr_t dma_addr);
  * @msix_table_backup: backup msix table
  * @scsi_io_cb_idx: shost generated commands
  * @tm_cb_idx: task management commands
+ * @scsih_cb_idx: scsih internal commands
  * @transport_cb_idx: transport internal commands
  * @ctl_cb_idx: clt internal commands
  * @base_cb_idx: base internal commands
  * @config_cb_idx: base internal commands
  * @base_cmds:
  * @transport_cmds:
+ * @scsih_cmds:
  * @tm_cmds:
  * @ctl_cmds:
  * @config_cmds:
@@ -588,9 +588,9 @@ struct MPT2SAS_ADAPTER {
         char            tmp_string[MPT_STRING_LENGTH];
         struct pci_dev  *pdev;
         Mpi2SystemInterfaceRegs_t __iomem *chip;
-        unsigned long   chip_phys;
-        unsigned long   pio_chip;
+        resource_size_t chip_phys;
         int             logging_level;
+        int             fwfault_debug;
         u8              ir_firmware;
         int             bars;
         u8              mask_interrupts;
@@ -626,6 +626,7 @@ struct MPT2SAS_ADAPTER {
         u8              scsi_io_cb_idx;
         u8              tm_cb_idx;
         u8              transport_cb_idx;
+        u8              scsih_cb_idx;
         u8              ctl_cb_idx;
         u8              base_cb_idx;
         u8              config_cb_idx;
@@ -633,6 +634,7 @@ struct MPT2SAS_ADAPTER {
         u8              tm_sas_control_cb_idx;
         struct _internal_cmd base_cmds;
         struct _internal_cmd transport_cmds;
+        struct _internal_cmd scsih_cmds;
         struct _internal_cmd tm_cmds;
         struct _internal_cmd ctl_cmds;
         struct _internal_cmd config_cmds;
@@ -773,7 +775,7 @@ int mpt2sas_base_hard_reset_handler(struct MPT2SAS_ADAPTER *ioc, int sleep_flag,
 void *mpt2sas_base_get_msg_frame(struct MPT2SAS_ADAPTER *ioc, u16 smid);
 void *mpt2sas_base_get_sense_buffer(struct MPT2SAS_ADAPTER *ioc, u16 smid);
 void mpt2sas_base_build_zero_len_sge(struct MPT2SAS_ADAPTER *ioc, void *paddr);
-dma_addr_t mpt2sas_base_get_sense_buffer_dma(struct MPT2SAS_ADAPTER *ioc,
+__le32 mpt2sas_base_get_sense_buffer_dma(struct MPT2SAS_ADAPTER *ioc,
     u16 smid);
 
 /* hi-priority queue */
@@ -807,6 +809,8 @@ int mpt2sas_base_scsi_enclosure_processor(struct MPT2SAS_ADAPTER *ioc,
     Mpi2SepReply_t *mpi_reply, Mpi2SepRequest_t *mpi_request);
 void mpt2sas_base_validate_event_type(struct MPT2SAS_ADAPTER *ioc, u32 *event_type);
 
+void mpt2sas_halt_firmware(struct MPT2SAS_ADAPTER *ioc);
+
 /* scsih shared API */
 u8 mpt2sas_scsih_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index,
     u32 reply);
@@ -849,6 +853,8 @@ int mpt2sas_config_set_iounit_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
     *mpi_reply, Mpi2IOUnitPage1_t *config_page);
 int mpt2sas_config_get_sas_iounit_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
     *mpi_reply, Mpi2SasIOUnitPage1_t *config_page, u16 sz);
+int mpt2sas_config_set_sas_iounit_pg1(struct MPT2SAS_ADAPTER *ioc,
+    Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage1_t *config_page, u16 sz);
 int mpt2sas_config_get_ioc_pg8(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
     *mpi_reply, Mpi2IOCPage8_t *config_page);
 int mpt2sas_config_get_expander_pg0(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
@@ -886,19 +892,22 @@ u8 mpt2sas_ctl_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index,
 void mpt2sas_ctl_add_to_event_log(struct MPT2SAS_ADAPTER *ioc,
     Mpi2EventNotificationReply_t *mpi_reply);
 
+void mpt2sas_enable_diag_buffer(struct MPT2SAS_ADAPTER *ioc,
+        u8 bits_to_regsiter);
+
 /* transport shared API */
 u8 mpt2sas_transport_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
     u32 reply);
 struct _sas_port *mpt2sas_transport_port_add(struct MPT2SAS_ADAPTER *ioc,
-    u16 handle, u16 parent_handle);
+     u16 handle, u64 sas_address);
 void mpt2sas_transport_port_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
-    u16 parent_handle);
+     u64 sas_address_parent);
 int mpt2sas_transport_add_host_phy(struct MPT2SAS_ADAPTER *ioc, struct _sas_phy
     *mpt2sas_phy, Mpi2SasPhyPage0_t phy_pg0, struct device *parent_dev);
 int mpt2sas_transport_add_expander_phy(struct MPT2SAS_ADAPTER *ioc, struct _sas_phy
     *mpt2sas_phy, Mpi2ExpanderPage1_t expander_pg1, struct device *parent_dev);
-void mpt2sas_transport_update_links(struct MPT2SAS_ADAPTER *ioc, u16 handle,
-   u16 attached_handle, u8 phy_number, u8 link_rate);
+void mpt2sas_transport_update_links(struct MPT2SAS_ADAPTER *ioc,
+     u64 sas_address, u16 handle, u8 phy_number, u8 link_rate);
 extern struct sas_function_template mpt2sas_transport_functions;
 extern struct scsi_transport_template *mpt2sas_transport_template;
 extern int scsi_internal_device_block(struct scsi_device *sdev);
diff --git a/drivers/scsi/mpt2sas/mpt2sas_config.c b/drivers/scsi/mpt2sas/mpt2sas_config.c
index 594a389c6526..cf44b355bc97 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_config.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_config.c
@@ -51,6 +51,7 @@
 #include <linux/workqueue.h>
 #include <linux/delay.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 
 #include "mpt2sas_base.h"
 
@@ -324,7 +325,9 @@ _config_request(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigRequest_t
                 if (r != 0)
                         goto out;
                 if (mpi_request->Action ==
-                    MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT) {
+                    MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT ||
+                    mpi_request->Action ==
+                    MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM) {
                         ioc->base_add_sg_single(&mpi_request->PageBufferSGE,
                             MPT2_CONFIG_COMMON_WRITE_SGLFLAGS | mem.sz,
                             mem.page_dma);
@@ -882,7 +885,7 @@ mpt2sas_config_get_sas_iounit_pg0(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
 }
 
 /**
- * mpt2sas_config_get_sas_iounit_pg1 - obtain sas iounit page 0
+ * mpt2sas_config_get_sas_iounit_pg1 - obtain sas iounit page 1
  * @ioc: per adapter object
  * @mpi_reply: reply mf payload returned from firmware
  * @config_page: contents of the config page
@@ -907,7 +910,7 @@ mpt2sas_config_get_sas_iounit_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
         mpi_request.Header.PageNumber = 1;
-        mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE0_PAGEVERSION;
+        mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE1_PAGEVERSION;
         mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
         r = _config_request(ioc, &mpi_request, mpi_reply,
             MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
@@ -922,6 +925,49 @@ mpt2sas_config_get_sas_iounit_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
 }
 
 /**
+ * mpt2sas_config_set_sas_iounit_pg1 - send sas iounit page 1
+ * @ioc: per adapter object
+ * @mpi_reply: reply mf payload returned from firmware
+ * @config_page: contents of the config page
+ * @sz: size of buffer passed in config_page
+ * Context: sleep.
+ *
+ * Calling function should call config_get_number_hba_phys prior to
+ * this function, so enough memory is allocated for config_page.
+ *
+ * Returns 0 for success, non-zero for failure.
+ */
+int
+mpt2sas_config_set_sas_iounit_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
+    *mpi_reply, Mpi2SasIOUnitPage1_t *config_page, u16 sz)
+{
+        Mpi2ConfigRequest_t mpi_request;
+        int r;
+
+        memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
+        mpi_request.Function = MPI2_FUNCTION_CONFIG;
+        mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
+        mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
+        mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
+        mpi_request.Header.PageNumber = 1;
+        mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE1_PAGEVERSION;
+        mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
+        r = _config_request(ioc, &mpi_request, mpi_reply,
+            MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
+        if (r)
+                goto out;
+
+        mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
+        _config_request(ioc, &mpi_request, mpi_reply,
+            MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
+        mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM;
+        r = _config_request(ioc, &mpi_request, mpi_reply,
+            MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
+ out:
+        return r;
+}
+
+/**
  * mpt2sas_config_get_expander_pg0 - obtain expander page 0
  * @ioc: per adapter object
  * @mpi_reply: reply mf payload returned from firmware
diff --git a/drivers/scsi/mpt2sas/mpt2sas_ctl.c b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
index 57d724633906..fa9bf83819d5 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_ctl.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
@@ -740,7 +740,7 @@ _ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
                 Mpi2SCSIIORequest_t *scsiio_request =
                     (Mpi2SCSIIORequest_t *)mpi_request;
                 scsiio_request->SenseBufferLowAddress =
-                    (u32)mpt2sas_base_get_sense_buffer_dma(ioc, smid);
+                    mpt2sas_base_get_sense_buffer_dma(ioc, smid);
                 priv_sense = mpt2sas_base_get_sense_buffer(ioc, smid);
                 memset(priv_sense, 0, SCSI_SENSE_BUFFERSIZE);
                 mpt2sas_base_put_smid_scsi_io(ioc, smid,
@@ -848,8 +848,9 @@ _ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
                 printk(MPT2SAS_DEBUG_FMT "TASK_MGMT: "
                     "IOCStatus(0x%04x), IOCLogInfo(0x%08x), "
                     "TerminationCount(0x%08x)\n", ioc->name,
-                    tm_reply->IOCStatus, tm_reply->IOCLogInfo,
-                    tm_reply->TerminationCount);
+                    le16_to_cpu(tm_reply->IOCStatus),
+                    le32_to_cpu(tm_reply->IOCLogInfo),
+                    le32_to_cpu(tm_reply->TerminationCount));
         }
 #endif
         /* copy out xdata to user */
@@ -890,12 +891,14 @@ _ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
 
  issue_host_reset:
         if (issue_reset) {
+                ret = -ENODATA;
                 if ((mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
                     mpi_request->Function ==
                     MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
                         printk(MPT2SAS_INFO_FMT "issue target reset: handle "
                             "= (0x%04x)\n", ioc->name,
                             mpi_request->FunctionDependent1);
+                        mpt2sas_halt_firmware(ioc);
                         mutex_lock(&ioc->tm_cmds.mutex);
                         mpt2sas_scsih_issue_tm(ioc,
                             mpi_request->FunctionDependent1, 0,
@@ -1229,7 +1232,7 @@ _ctl_btdh_mapping(void __user *arg)
 /**
  * _ctl_diag_capability - return diag buffer capability
  * @ioc: per adapter object
- * @buffer_type: specifies either TRACE or SNAPSHOT
+ * @buffer_type: specifies either TRACE, SNAPSHOT, or EXTENDED
  *
  * returns 1 when diag buffer support is enabled in firmware
  */
@@ -1249,24 +1252,25 @@ _ctl_diag_capability(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type)
                     MPI2_IOCFACTS_CAPABILITY_SNAPSHOT_BUFFER)
                         rc = 1;
                 break;
+        case MPI2_DIAG_BUF_TYPE_EXTENDED:
+                if (ioc->facts.IOCCapabilities &
+                    MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER)
+                        rc = 1;
         }
 
         return rc;
 }
 
 /**
- * _ctl_diag_register - application register with driver
- * @arg - user space buffer containing ioctl content
- * @state - NON_BLOCKING or BLOCKING
+ * _ctl_diag_register_2 - wrapper for registering diag buffer support
+ * @ioc: per adapter object
+ * @diag_register: the diag_register struct passed in from user space
  *
- * This will allow the driver to setup any required buffers that will be
- * needed by firmware to communicate with the driver.
  */
 static long
-_ctl_diag_register(void __user *arg, enum block_state state)
+_ctl_diag_register_2(struct MPT2SAS_ADAPTER *ioc,
+    struct mpt2_diag_register *diag_register)
 {
-        struct mpt2_diag_register karg;
-        struct MPT2SAS_ADAPTER *ioc;
         int rc, i;
         void *request_data = NULL;
         dma_addr_t request_data_dma;
@@ -1279,18 +1283,17 @@ _ctl_diag_register(void __user *arg, enum block_state state)
         u16 ioc_status;
         u8 issue_reset = 0;
 
-        if (copy_from_user(&karg, arg, sizeof(karg))) {
-                printk(KERN_ERR "failure at %s:%d/%s()!\n",
-                    __FILE__, __LINE__, __func__);
-                return -EFAULT;
-        }
-        if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
-                return -ENODEV;
-
         dctlprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n", ioc->name,
             __func__));
 
-        buffer_type = karg.buffer_type;
+        if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
+                printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
+                    ioc->name, __func__);
+                rc = -EAGAIN;
+                goto out;
+        }
+
+        buffer_type = diag_register->buffer_type;
         if (!_ctl_diag_capability(ioc, buffer_type)) {
                 printk(MPT2SAS_ERR_FMT "%s: doesn't have capability for "
                     "buffer_type(0x%02x)\n", ioc->name, __func__, buffer_type);
@@ -1305,24 +1308,12 @@ _ctl_diag_register(void __user *arg, enum block_state state)
                 return -EINVAL;
         }
 
-        if (karg.requested_buffer_size % 4)  {
+        if (diag_register->requested_buffer_size % 4)  {
                 printk(MPT2SAS_ERR_FMT "%s: the requested_buffer_size "
                     "is not 4 byte aligned\n", ioc->name, __func__);
                 return -EINVAL;
         }
 
-        if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
-                return -EAGAIN;
-        else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
-                return -ERESTARTSYS;
-
-        if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
-                printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
-                    ioc->name, __func__);
-                rc = -EAGAIN;
-                goto out;
-        }
-
         smid = mpt2sas_base_get_smid(ioc, ioc->ctl_cb_idx);
         if (!smid) {
                 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
@@ -1338,12 +1329,12 @@ _ctl_diag_register(void __user *arg, enum block_state state)
         ioc->ctl_cmds.smid = smid;
 
         request_data = ioc->diag_buffer[buffer_type];
-        request_data_sz = karg.requested_buffer_size;
-        ioc->unique_id[buffer_type] = karg.unique_id;
+        request_data_sz = diag_register->requested_buffer_size;
+        ioc->unique_id[buffer_type] = diag_register->unique_id;
         ioc->diag_buffer_status[buffer_type] = 0;
-        memcpy(ioc->product_specific[buffer_type], karg.product_specific,
-            MPT2_PRODUCT_SPECIFIC_DWORDS);
-        ioc->diagnostic_flags[buffer_type] = karg.diagnostic_flags;
+        memcpy(ioc->product_specific[buffer_type],
+            diag_register->product_specific, MPT2_PRODUCT_SPECIFIC_DWORDS);
+        ioc->diagnostic_flags[buffer_type] = diag_register->diagnostic_flags;
 
         if (request_data) {
                 request_data_dma = ioc->diag_buffer_dma[buffer_type];
@@ -1373,8 +1364,8 @@ _ctl_diag_register(void __user *arg, enum block_state state)
         }
 
         mpi_request->Function = MPI2_FUNCTION_DIAG_BUFFER_POST;
-        mpi_request->BufferType = karg.buffer_type;
-        mpi_request->Flags = cpu_to_le32(karg.diagnostic_flags);
+        mpi_request->BufferType = diag_register->buffer_type;
+        mpi_request->Flags = cpu_to_le32(diag_register->diagnostic_flags);
         mpi_request->BufferAddress = cpu_to_le64(request_data_dma);
         mpi_request->BufferLength = cpu_to_le32(request_data_sz);
         mpi_request->VF_ID = 0; /* TODO */
@@ -1422,7 +1413,7 @@ _ctl_diag_register(void __user *arg, enum block_state state)
         } else {
                 printk(MPT2SAS_DEBUG_FMT "%s: ioc_status(0x%04x) "
                     "log_info(0x%08x)\n", ioc->name, __func__,
-                    ioc_status, mpi_reply->IOCLogInfo);
+                    ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
                 rc = -EFAULT;
         }
 
@@ -1438,6 +1429,83 @@ _ctl_diag_register(void __user *arg, enum block_state state)
                     request_data, request_data_dma);
 
         ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
+        return rc;
+}
+
+/**
+ * mpt2sas_enable_diag_buffer - enabling diag_buffers support driver load time
+ * @ioc: per adapter object
+ * @bits_to_register: bitwise field where trace is bit 0, and snapshot is bit 1
+ *
+ * This is called when command line option diag_buffer_enable is enabled
+ * at driver load time.
+ */
+void
+mpt2sas_enable_diag_buffer(struct MPT2SAS_ADAPTER *ioc, u8 bits_to_register)
+{
+        struct mpt2_diag_register diag_register;
+
+        memset(&diag_register, 0, sizeof(struct mpt2_diag_register));
+
+        if (bits_to_register & 1) {
+                printk(MPT2SAS_INFO_FMT "registering trace buffer support\n",
+                    ioc->name);
+                diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_TRACE;
+                /* register for 1MB buffers  */
+                diag_register.requested_buffer_size = (1024 * 1024);
+                diag_register.unique_id = 0x7075900;
+                _ctl_diag_register_2(ioc,  &diag_register);
+        }
+
+        if (bits_to_register & 2) {
+                printk(MPT2SAS_INFO_FMT "registering snapshot buffer support\n",
+                    ioc->name);
+                diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_SNAPSHOT;
+                /* register for 2MB buffers  */
+                diag_register.requested_buffer_size = 2 * (1024 * 1024);
+                diag_register.unique_id = 0x7075901;
+                _ctl_diag_register_2(ioc,  &diag_register);
+        }
+
+        if (bits_to_register & 4) {
+                printk(MPT2SAS_INFO_FMT "registering extended buffer support\n",
+                    ioc->name);
+                diag_register.buffer_type = MPI2_DIAG_BUF_TYPE_EXTENDED;
+                /* register for 2MB buffers  */
+                diag_register.requested_buffer_size = 2 * (1024 * 1024);
+                diag_register.unique_id = 0x7075901;
+                _ctl_diag_register_2(ioc,  &diag_register);
+        }
+}
+
+/**
+ * _ctl_diag_register - application register with driver
+ * @arg - user space buffer containing ioctl content
+ * @state - NON_BLOCKING or BLOCKING
+ *
+ * This will allow the driver to setup any required buffers that will be
+ * needed by firmware to communicate with the driver.
+ */
+static long
+_ctl_diag_register(void __user *arg, enum block_state state)
+{
+        struct mpt2_diag_register karg;
+        struct MPT2SAS_ADAPTER *ioc;
+        long rc;
+
+        if (copy_from_user(&karg, arg, sizeof(karg))) {
+                printk(KERN_ERR "failure at %s:%d/%s()!\n",
+                    __FILE__, __LINE__, __func__);
+                return -EFAULT;
+        }
+        if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
+                return -ENODEV;
+
+        if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
+                return -EAGAIN;
+        else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
+                return -ERESTARTSYS;
+        rc = _ctl_diag_register_2(ioc, &karg);
         mutex_unlock(&ioc->ctl_cmds.mutex);
         return rc;
 }
@@ -1600,7 +1668,7 @@ _ctl_diag_query(void __user *arg)
 /**
  * _ctl_send_release - Diag Release Message
  * @ioc: per adapter object
- * @buffer_type - specifies either TRACE or SNAPSHOT
+ * @buffer_type - specifies either TRACE, SNAPSHOT, or EXTENDED
  * @issue_reset - specifies whether host reset is required.
  *
  */
@@ -1690,7 +1758,7 @@ _ctl_send_release(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type, u8 *issue_reset)
         } else {
                 printk(MPT2SAS_DEBUG_FMT "%s: ioc_status(0x%04x) "
                     "log_info(0x%08x)\n", ioc->name, __func__,
-                    ioc_status, mpi_reply->IOCLogInfo);
+                    ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
                 rc = -EFAULT;
         }
 
@@ -1951,7 +2019,7 @@ _ctl_diag_read_buffer(void __user *arg, enum block_state state)
         } else {
                 printk(MPT2SAS_DEBUG_FMT "%s: ioc_status(0x%04x) "
                     "log_info(0x%08x)\n", ioc->name, __func__,
-                    ioc_status, mpi_reply->IOCLogInfo);
+                    ioc_status, le32_to_cpu(mpi_reply->IOCLogInfo));
                 rc = -EFAULT;
         }
 
@@ -2135,14 +2203,10 @@ _ctl_compat_mpt_command(struct file *file, unsigned cmd, unsigned long arg)
         karg.data_out_size = karg32.data_out_size;
         karg.max_sense_bytes = karg32.max_sense_bytes;
         karg.data_sge_offset = karg32.data_sge_offset;
-        memcpy(&karg.reply_frame_buf_ptr, &karg32.reply_frame_buf_ptr,
-            sizeof(uint32_t));
-        memcpy(&karg.data_in_buf_ptr, &karg32.data_in_buf_ptr,
-            sizeof(uint32_t));
-        memcpy(&karg.data_out_buf_ptr, &karg32.data_out_buf_ptr,
-            sizeof(uint32_t));
-        memcpy(&karg.sense_data_ptr, &karg32.sense_data_ptr,
-            sizeof(uint32_t));
+        karg.reply_frame_buf_ptr = compat_ptr(karg32.reply_frame_buf_ptr);
+        karg.data_in_buf_ptr = compat_ptr(karg32.data_in_buf_ptr);
+        karg.data_out_buf_ptr = compat_ptr(karg32.data_out_buf_ptr);
+        karg.sense_data_ptr = compat_ptr(karg32.sense_data_ptr);
         state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING;
         return _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
 }
@@ -2474,6 +2538,43 @@ _ctl_logging_level_store(struct device *cdev, struct device_attribute *attr,
 static DEVICE_ATTR(logging_level, S_IRUGO | S_IWUSR,
     _ctl_logging_level_show, _ctl_logging_level_store);
 
+/* device attributes */
+/*
+ * _ctl_fwfault_debug_show - show/store fwfault_debug
+ * @cdev - pointer to embedded class device
+ * @buf - the buffer returned
+ *
+ * mpt2sas_fwfault_debug is command line option
+ * A sysfs 'read/write' shost attribute.
+ */
+static ssize_t
+_ctl_fwfault_debug_show(struct device *cdev,
+    struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
+
+        return snprintf(buf, PAGE_SIZE, "%d\n", ioc->fwfault_debug);
+}
+static ssize_t
+_ctl_fwfault_debug_store(struct device *cdev,
+    struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
+        int val = 0;
+
+        if (sscanf(buf, "%d", &val) != 1)
+                return -EINVAL;
+
+        ioc->fwfault_debug = val;
+        printk(MPT2SAS_INFO_FMT "fwfault_debug=%d\n", ioc->name,
+            ioc->fwfault_debug);
+        return strlen(buf);
+}
+static DEVICE_ATTR(fwfault_debug, S_IRUGO | S_IWUSR,
+    _ctl_fwfault_debug_show, _ctl_fwfault_debug_store);
+
 struct device_attribute *mpt2sas_host_attrs[] = {
         &dev_attr_version_fw,
         &dev_attr_version_bios,
@@ -2487,13 +2588,12 @@ struct device_attribute *mpt2sas_host_attrs[] = {
         &dev_attr_io_delay,
         &dev_attr_device_delay,
         &dev_attr_logging_level,
+        &dev_attr_fwfault_debug,
         &dev_attr_fw_queue_depth,
         &dev_attr_host_sas_address,
         NULL,
 };
 
-/* device attributes */
-
 /**
  * _ctl_device_sas_address_show - sas address
  * @cdev - pointer to embedded class device
diff --git a/drivers/scsi/mpt2sas/mpt2sas_ctl.h b/drivers/scsi/mpt2sas/mpt2sas_ctl.h
index 211f296dd191..8a5eeb1a5c84 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_ctl.h
+++ b/drivers/scsi/mpt2sas/mpt2sas_ctl.h
@@ -313,7 +313,7 @@ struct mpt2_ioctl_btdh_mapping {
  * struct mpt2_diag_register - application register with driver
  * @hdr - generic header
  * @reserved -
- * @buffer_type - specifies either TRACE or SNAPSHOT
+ * @buffer_type - specifies either TRACE, SNAPSHOT, or EXTENDED
  * @application_flags - misc flags
  * @diagnostic_flags - specifies flags affecting command processing
  * @product_specific - product specific information
@@ -352,7 +352,7 @@ struct mpt2_diag_unregister {
  * struct mpt2_diag_query - query relevant info associated with diag buffers
  * @hdr - generic header
  * @reserved -
- * @buffer_type - specifies either TRACE or SNAPSHOT
+ * @buffer_type - specifies either TRACE, SNAPSHOT, or EXTENDED
  * @application_flags - misc flags
  * @diagnostic_flags - specifies flags affecting command processing
  * @product_specific - product specific information
diff --git a/drivers/scsi/mpt2sas/mpt2sas_scsih.c b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
index 86ab32d7ab15..be171ed682e0 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_scsih.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
@@ -52,6 +52,8 @@
 #include <linux/delay.h>
 #include <linux/pci.h>
 #include <linux/interrupt.h>
+#include <linux/raid_class.h>
+#include <linux/slab.h>
 
 #include "mpt2sas_base.h"
 
@@ -76,6 +78,7 @@ static u8 tm_cb_idx = -1;
 static u8 ctl_cb_idx = -1;
 static u8 base_cb_idx = -1;
 static u8 transport_cb_idx = -1;
+static u8 scsih_cb_idx = -1;
 static u8 config_cb_idx = -1;
 static int mpt_ids;
 
@@ -132,6 +135,9 @@ struct fw_event_work {
         void                    *event_data;
 };
 
+/* raid transport support */
+static struct raid_template *mpt2sas_raid_template;
+
 /**
  * struct _scsi_io_transfer - scsi io transfer
  * @handle: sas device handle (assigned by firmware)
@@ -196,10 +202,28 @@ static struct pci_device_id scsih_pci_table[] = {
                 PCI_ANY_ID, PCI_ANY_ID },
         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_3,
                 PCI_ANY_ID, PCI_ANY_ID },
+        /* Meteor ~ 2116 */
         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_1,
                 PCI_ANY_ID, PCI_ANY_ID },
         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_2,
                 PCI_ANY_ID, PCI_ANY_ID },
+        /* Thunderbolt ~ 2208 */
+        { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_1,
+                PCI_ANY_ID, PCI_ANY_ID },
+        { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_2,
+                PCI_ANY_ID, PCI_ANY_ID },
+        { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_3,
+                PCI_ANY_ID, PCI_ANY_ID },
+        { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_4,
+                PCI_ANY_ID, PCI_ANY_ID },
+        { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_5,
+                PCI_ANY_ID, PCI_ANY_ID },
+        { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_6,
+                PCI_ANY_ID, PCI_ANY_ID },
+        { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_7,
+                PCI_ANY_ID, PCI_ANY_ID },
+        { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_8,
+                PCI_ANY_ID, PCI_ANY_ID },
         {0}     /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(pci, scsih_pci_table);
@@ -317,6 +341,47 @@ _scsih_is_boot_device(u64 sas_address, u64 device_name,
 }
 
 /**
+ * _scsih_get_sas_address - set the sas_address for given device handle
+ * @handle: device handle
+ * @sas_address: sas address
+ *
+ * Returns 0 success, non-zero when failure
+ */
+static int
+_scsih_get_sas_address(struct MPT2SAS_ADAPTER *ioc, u16 handle,
+    u64 *sas_address)
+{
+        Mpi2SasDevicePage0_t sas_device_pg0;
+        Mpi2ConfigReply_t mpi_reply;
+        u32 ioc_status;
+
+        if (handle <= ioc->sas_hba.num_phys) {
+                *sas_address = ioc->sas_hba.sas_address;
+                return 0;
+        } else
+                *sas_address = 0;
+
+        if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
+            MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                return -ENXIO;
+        }
+
+        ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
+            MPI2_IOCSTATUS_MASK;
+        if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
+                printk(MPT2SAS_ERR_FMT "handle(0x%04x), ioc_status(0x%04x)"
+                    "\nfailure at %s:%d/%s()!\n", ioc->name, handle, ioc_status,
+                     __FILE__, __LINE__, __func__);
+                return -EIO;
+        }
+
+        *sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
+        return 0;
+}
+
+/**
  * _scsih_determine_boot_device - determine boot device.
  * @ioc: per adapter object
  * @device: either sas_device or raid_device object
@@ -510,8 +575,6 @@ _scsih_sas_device_add(struct MPT2SAS_ADAPTER *ioc,
     struct _sas_device *sas_device)
 {
         unsigned long flags;
-        u16 handle, parent_handle;
-        u64 sas_address;
 
         dewtprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: handle"
             "(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
@@ -521,10 +584,8 @@ _scsih_sas_device_add(struct MPT2SAS_ADAPTER *ioc,
         list_add_tail(&sas_device->list, &ioc->sas_device_list);
         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 
-        handle = sas_device->handle;
-        parent_handle = sas_device->parent_handle;
-        sas_address = sas_device->sas_address;
-        if (!mpt2sas_transport_port_add(ioc, handle, parent_handle))
+        if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
+             sas_device->sas_address_parent))
                 _scsih_sas_device_remove(ioc, sas_device);
 }
 
@@ -553,31 +614,6 @@ _scsih_sas_device_init_add(struct MPT2SAS_ADAPTER *ioc,
 }
 
 /**
- * mpt2sas_scsih_expander_find_by_handle - expander device search
- * @ioc: per adapter object
- * @handle: expander handle (assigned by firmware)
- * Context: Calling function should acquire ioc->sas_device_lock
- *
- * This searches for expander device based on handle, then returns the
- * sas_node object.
- */
-struct _sas_node *
-mpt2sas_scsih_expander_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
-{
-        struct _sas_node *sas_expander, *r;
-
-        r = NULL;
-        list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
-                if (sas_expander->handle != handle)
-                        continue;
-                r = sas_expander;
-                goto out;
-        }
- out:
-        return r;
-}
-
-/**
  * _scsih_raid_device_find_by_id - raid device search
  * @ioc: per adapter object
  * @id: sas device target id
@@ -699,6 +735,31 @@ _scsih_raid_device_remove(struct MPT2SAS_ADAPTER *ioc,
 }
 
 /**
+ * mpt2sas_scsih_expander_find_by_handle - expander device search
+ * @ioc: per adapter object
+ * @handle: expander handle (assigned by firmware)
+ * Context: Calling function should acquire ioc->sas_device_lock
+ *
+ * This searches for expander device based on handle, then returns the
+ * sas_node object.
+ */
+struct _sas_node *
+mpt2sas_scsih_expander_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
+{
+        struct _sas_node *sas_expander, *r;
+
+        r = NULL;
+        list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
+                if (sas_expander->handle != handle)
+                        continue;
+                r = sas_expander;
+                goto out;
+        }
+ out:
+        return r;
+}
+
+/**
  * mpt2sas_scsih_expander_find_by_sas_address - expander device search
  * @ioc: per adapter object
  * @sas_address: sas address
@@ -1043,17 +1104,46 @@ _scsih_build_scatter_gather(struct MPT2SAS_ADAPTER *ioc,
  * _scsih_change_queue_depth - setting device queue depth
  * @sdev: scsi device struct
  * @qdepth: requested queue depth
+ * @reason: calling context
  *
  * Returns queue depth.
  */
 static int
-_scsih_change_queue_depth(struct scsi_device *sdev, int qdepth)
+_scsih_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
 {
         struct Scsi_Host *shost = sdev->host;
         int max_depth;
         int tag_type;
+        struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
+        struct MPT2SAS_DEVICE *sas_device_priv_data;
+        struct MPT2SAS_TARGET *sas_target_priv_data;
+        struct _sas_device *sas_device;
+        unsigned long flags;
+
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
 
         max_depth = shost->can_queue;
+
+        /* limit max device queue for SATA to 32 */
+        sas_device_priv_data = sdev->hostdata;
+        if (!sas_device_priv_data)
+                goto not_sata;
+        sas_target_priv_data = sas_device_priv_data->sas_target;
+        if (!sas_target_priv_data)
+                goto not_sata;
+        if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME))
+                goto not_sata;
+        spin_lock_irqsave(&ioc->sas_device_lock, flags);
+        sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
+           sas_device_priv_data->sas_target->sas_address);
+        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
+        if (sas_device && sas_device->device_info &
+            MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
+                max_depth = MPT2SAS_SATA_QUEUE_DEPTH;
+
+ not_sata:
+
         if (!sdev->tagged_supported)
                 max_depth = 1;
         if (qdepth > max_depth)
@@ -1220,7 +1310,6 @@ _scsih_slave_alloc(struct scsi_device *sdev)
         struct MPT2SAS_DEVICE *sas_device_priv_data;
         struct scsi_target *starget;
         struct _raid_device *raid_device;
-        struct _sas_device *sas_device;
         unsigned long flags;
 
         sas_device_priv_data = kzalloc(sizeof(struct scsi_device), GFP_KERNEL);
@@ -1247,21 +1336,8 @@ _scsih_slave_alloc(struct scsi_device *sdev)
                 if (raid_device)
                         raid_device->sdev = sdev; /* raid is single lun */
                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
-        } else {
-                /* set TLR bit for SSP devices */
-                if (!(ioc->facts.IOCCapabilities &
-                     MPI2_IOCFACTS_CAPABILITY_TLR))
-                        goto out;
-                spin_lock_irqsave(&ioc->sas_device_lock, flags);
-                sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
-                   sas_device_priv_data->sas_target->sas_address);
-                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-                if (sas_device && sas_device->device_info &
-                    MPI2_SAS_DEVICE_INFO_SSP_TARGET)
-                        sas_device_priv_data->flags |= MPT_DEVICE_TLR_ON;
         }
 
- out:
         return 0;
 }
 
@@ -1334,6 +1410,140 @@ _scsih_display_sata_capabilities(struct MPT2SAS_ADAPTER *ioc,
 }
 
 /**
+ * _scsih_is_raid - return boolean indicating device is raid volume
+ * @dev the device struct object
+ */
+static int
+_scsih_is_raid(struct device *dev)
+{
+        struct scsi_device *sdev = to_scsi_device(dev);
+
+        return (sdev->channel == RAID_CHANNEL) ? 1 : 0;
+}
+
+/**
+ * _scsih_get_resync - get raid volume resync percent complete
+ * @dev the device struct object
+ */
+static void
+_scsih_get_resync(struct device *dev)
+{
+        struct scsi_device *sdev = to_scsi_device(dev);
+        struct MPT2SAS_ADAPTER *ioc = shost_priv(sdev->host);
+        static struct _raid_device *raid_device;
+        unsigned long flags;
+        Mpi2RaidVolPage0_t vol_pg0;
+        Mpi2ConfigReply_t mpi_reply;
+        u32 volume_status_flags;
+        u8 percent_complete = 0;
+
+        spin_lock_irqsave(&ioc->raid_device_lock, flags);
+        raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
+            sdev->channel);
+        spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
+
+        if (!raid_device)
+                goto out;
+
+        if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
+             MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle,
+             sizeof(Mpi2RaidVolPage0_t))) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                goto out;
+        }
+
+        volume_status_flags = le32_to_cpu(vol_pg0.VolumeStatusFlags);
+        if (volume_status_flags & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS)
+                percent_complete = raid_device->percent_complete;
+ out:
+        raid_set_resync(mpt2sas_raid_template, dev, percent_complete);
+}
+
+/**
+ * _scsih_get_state - get raid volume level
+ * @dev the device struct object
+ */
+static void
+_scsih_get_state(struct device *dev)
+{
+        struct scsi_device *sdev = to_scsi_device(dev);
+        struct MPT2SAS_ADAPTER *ioc = shost_priv(sdev->host);
+        static struct _raid_device *raid_device;
+        unsigned long flags;
+        Mpi2RaidVolPage0_t vol_pg0;
+        Mpi2ConfigReply_t mpi_reply;
+        u32 volstate;
+        enum raid_state state = RAID_STATE_UNKNOWN;
+
+        spin_lock_irqsave(&ioc->raid_device_lock, flags);
+        raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
+            sdev->channel);
+        spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
+
+        if (!raid_device)
+                goto out;
+
+        if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
+             MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle,
+             sizeof(Mpi2RaidVolPage0_t))) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                goto out;
+        }
+
+        volstate = le32_to_cpu(vol_pg0.VolumeStatusFlags);
+        if (volstate & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) {
+                state = RAID_STATE_RESYNCING;
+                goto out;
+        }
+
+        switch (vol_pg0.VolumeState) {
+        case MPI2_RAID_VOL_STATE_OPTIMAL:
+        case MPI2_RAID_VOL_STATE_ONLINE:
+                state = RAID_STATE_ACTIVE;
+                break;
+        case  MPI2_RAID_VOL_STATE_DEGRADED:
+                state = RAID_STATE_DEGRADED;
+                break;
+        case MPI2_RAID_VOL_STATE_FAILED:
+        case MPI2_RAID_VOL_STATE_MISSING:
+                state = RAID_STATE_OFFLINE;
+                break;
+        }
+ out:
+        raid_set_state(mpt2sas_raid_template, dev, state);
+}
+
+/**
+ * _scsih_set_level - set raid level
+ * @sdev: scsi device struct
+ * @raid_device: raid_device object
+ */
+static void
+_scsih_set_level(struct scsi_device *sdev, struct _raid_device *raid_device)
+{
+        enum raid_level level = RAID_LEVEL_UNKNOWN;
+
+        switch (raid_device->volume_type) {
+        case MPI2_RAID_VOL_TYPE_RAID0:
+                level = RAID_LEVEL_0;
+                break;
+        case MPI2_RAID_VOL_TYPE_RAID10:
+                level = RAID_LEVEL_10;
+                break;
+        case MPI2_RAID_VOL_TYPE_RAID1E:
+                level = RAID_LEVEL_1E;
+                break;
+        case MPI2_RAID_VOL_TYPE_RAID1:
+                level = RAID_LEVEL_1;
+                break;
+        }
+
+        raid_set_level(mpt2sas_raid_template, &sdev->sdev_gendev, level);
+}
+
+/**
  * _scsih_get_volume_capabilities - volume capabilities
  * @ioc: per adapter object
  * @sas_device: the raid_device object
@@ -1394,6 +1604,32 @@ _scsih_get_volume_capabilities(struct MPT2SAS_ADAPTER *ioc,
 }
 
 /**
+ * _scsih_enable_tlr - setting TLR flags
+ * @ioc: per adapter object
+ * @sdev: scsi device struct
+ *
+ * Enabling Transaction Layer Retries for tape devices when
+ * vpd page 0x90 is present
+ *
+ */
+static void
+_scsih_enable_tlr(struct MPT2SAS_ADAPTER *ioc, struct scsi_device *sdev)
+{
+        /* only for TAPE */
+        if (sdev->type != TYPE_TAPE)
+                return;
+
+        if (!(ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR))
+                return;
+
+        sas_enable_tlr(sdev);
+        sdev_printk(KERN_INFO, sdev, "TLR %s\n",
+            sas_is_tlr_enabled(sdev) ? "Enabled" : "Disabled");
+        return;
+
+}
+
+/**
  * _scsih_slave_configure - device configure routine.
  * @sdev: scsi device struct
  *
@@ -1488,7 +1724,9 @@ _scsih_slave_configure(struct scsi_device *sdev)
                     r_level, raid_device->handle,
                     (unsigned long long)raid_device->wwid,
                     raid_device->num_pds, ds);
-                _scsih_change_queue_depth(sdev, qdepth);
+                _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
+                /* raid transport support */
+                _scsih_set_level(sdev, raid_device);
                 return 0;
         }
 
@@ -1534,10 +1772,12 @@ _scsih_slave_configure(struct scsi_device *sdev)
                         _scsih_display_sata_capabilities(ioc, sas_device, sdev);
         }
 
-        _scsih_change_queue_depth(sdev, qdepth);
+        _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
 
-        if (ssp_target)
+        if (ssp_target) {
                 sas_read_port_mode_page(sdev);
+                _scsih_enable_tlr(ioc, sdev);
+        }
         return 0;
 }
 
@@ -1874,6 +2114,8 @@ _scsih_abort(struct scsi_cmnd *scmd)
                 goto out;
         }
 
+        mpt2sas_halt_firmware(ioc);
+
         mutex_lock(&ioc->tm_cmds.mutex);
         handle = sas_device_priv_data->sas_target->handle;
         mpt2sas_scsih_issue_tm(ioc, handle, sas_device_priv_data->lun,
@@ -2297,7 +2539,6 @@ _scsih_block_io_to_children_attached_directly(struct MPT2SAS_ADAPTER *ioc,
         u16 handle;
         u16 reason_code;
         u8 phy_number;
-        u8 link_rate;
 
         for (i = 0; i < event_data->NumEntries; i++) {
                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
@@ -2308,11 +2549,6 @@ _scsih_block_io_to_children_attached_directly(struct MPT2SAS_ADAPTER *ioc,
                     MPI2_EVENT_SAS_TOPO_RC_MASK;
                 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING)
                         _scsih_block_io_device(ioc, handle);
-                if (reason_code == MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED) {
-                        link_rate = event_data->PHY[i].LinkRate >> 4;
-                        if (link_rate >= MPI2_SAS_NEG_LINK_RATE_1_5)
-                                _scsih_ublock_io_device(ioc, handle);
-                }
         }
 }
 
@@ -2349,16 +2585,10 @@ _scsih_tm_tr_send(struct MPT2SAS_ADAPTER *ioc, u16 handle)
 
         spin_lock_irqsave(&ioc->sas_device_lock, flags);
         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
-        if (!sas_device) {
-                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-                printk(MPT2SAS_ERR_FMT "%s: failed finding sas_device\n",
-                    ioc->name, __func__);
-                return;
-        }
         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 
         /* skip is hidden raid component */
-        if (sas_device->hidden_raid_component)
+        if (sas_device && sas_device->hidden_raid_component)
                 return;
 
         smid = mpt2sas_base_get_smid_hpr(ioc, ioc->tm_tr_cb_idx);
@@ -2371,18 +2601,31 @@ _scsih_tm_tr_send(struct MPT2SAS_ADAPTER *ioc, u16 handle)
                 delayed_tr->state = MPT2SAS_REQ_SAS_CNTRL;
                 list_add_tail(&delayed_tr->list,
                     &ioc->delayed_tr_list);
-                if (sas_device->starget)
+                if (sas_device && sas_device->starget) {
                         dewtprintk(ioc, starget_printk(KERN_INFO,
                             sas_device->starget, "DELAYED:tr:handle(0x%04x), "
-                            "(open)\n", sas_device->handle));
+                            "(open)\n", handle));
+                } else {
+                        dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
+                            "DELAYED:tr:handle(0x%04x), (open)\n",
+                            ioc->name, handle));
+                }
                 return;
         }
 
-        if (sas_device->starget && sas_device->starget->hostdata) {
-                sas_target_priv_data = sas_device->starget->hostdata;
-                sas_target_priv_data->tm_busy = 1;
-                dewtprintk(ioc, starget_printk(KERN_INFO, sas_device->starget,
-                    "tr:handle(0x%04x), (open)\n", sas_device->handle));
+        if (sas_device) {
+                sas_device->state |= MPTSAS_STATE_TR_SEND;
+                sas_device->state |= MPT2SAS_REQ_SAS_CNTRL;
+                if (sas_device->starget && sas_device->starget->hostdata) {
+                        sas_target_priv_data = sas_device->starget->hostdata;
+                        sas_target_priv_data->tm_busy = 1;
+                        dewtprintk(ioc, starget_printk(KERN_INFO,
+                            sas_device->starget, "tr:handle(0x%04x), (open)\n",
+                            handle));
+                }
+        } else {
+                dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
+                    "tr:handle(0x%04x), (open)\n", ioc->name, handle));
         }
 
         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
@@ -2390,8 +2633,6 @@ _scsih_tm_tr_send(struct MPT2SAS_ADAPTER *ioc, u16 handle)
         mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT;
         mpi_request->DevHandle = cpu_to_le16(handle);
         mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET;
-        sas_device->state |= MPTSAS_STATE_TR_SEND;
-        sas_device->state |= MPT2SAS_REQ_SAS_CNTRL;
         mpt2sas_base_put_smid_hi_priority(ioc, smid);
 }
 
@@ -2426,21 +2667,25 @@ _scsih_sas_control_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid,
 
         spin_lock_irqsave(&ioc->sas_device_lock, flags);
         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
-        if (!sas_device) {
-                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-                printk(MPT2SAS_ERR_FMT "%s: failed finding sas_device\n",
-                    ioc->name, __func__);
-                return 1;
-        }
-        sas_device->state |= MPTSAS_STATE_CNTRL_COMPLETE;
         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 
-        if (sas_device->starget)
-                dewtprintk(ioc, starget_printk(KERN_INFO, sas_device->starget,
+        if (sas_device) {
+                sas_device->state |= MPTSAS_STATE_CNTRL_COMPLETE;
+                if (sas_device->starget)
+                        dewtprintk(ioc, starget_printk(KERN_INFO,
+                            sas_device->starget,
+                            "sc_complete:handle(0x%04x), "
+                            "ioc_status(0x%04x), loginfo(0x%08x)\n",
+                            handle, le16_to_cpu(mpi_reply->IOCStatus),
+                            le32_to_cpu(mpi_reply->IOCLogInfo)));
+        } else {
+                dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
                     "sc_complete:handle(0x%04x), "
                     "ioc_status(0x%04x), loginfo(0x%08x)\n",
-                    handle, le16_to_cpu(mpi_reply->IOCStatus),
+                    ioc->name, handle, le16_to_cpu(mpi_reply->IOCStatus),
                     le32_to_cpu(mpi_reply->IOCLogInfo)));
+        }
+
         return 1;
 }
 
@@ -2478,28 +2723,33 @@ _scsih_tm_tr_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
         handle = le16_to_cpu(mpi_reply->DevHandle);
         spin_lock_irqsave(&ioc->sas_device_lock, flags);
         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
-        if (!sas_device) {
-                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-                printk(MPT2SAS_ERR_FMT "%s: failed finding sas_device\n",
-                    ioc->name, __func__);
-                return 1;
-        }
-        sas_device->state |= MPTSAS_STATE_TR_COMPLETE;
         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 
-        if (sas_device->starget)
-                dewtprintk(ioc, starget_printk(KERN_INFO, sas_device->starget,
-                    "tr_complete:handle(0x%04x), (%s) ioc_status(0x%04x), "
-                    "loginfo(0x%08x), completed(%d)\n",
-                    sas_device->handle, (sas_device->state &
-                    MPT2SAS_REQ_SAS_CNTRL) ? "open" : "active",
-                    le16_to_cpu(mpi_reply->IOCStatus),
+        if (sas_device) {
+                sas_device->state |= MPTSAS_STATE_TR_COMPLETE;
+                if (sas_device->starget) {
+                        dewtprintk(ioc, starget_printk(KERN_INFO,
+                            sas_device->starget, "tr_complete:handle(0x%04x), "
+                            "(%s) ioc_status(0x%04x), loginfo(0x%08x), "
+                            "completed(%d)\n", sas_device->handle,
+                            (sas_device->state & MPT2SAS_REQ_SAS_CNTRL) ?
+                            "open" : "active",
+                            le16_to_cpu(mpi_reply->IOCStatus),
+                            le32_to_cpu(mpi_reply->IOCLogInfo),
+                            le32_to_cpu(mpi_reply->TerminationCount)));
+                        if (sas_device->starget->hostdata) {
+                                sas_target_priv_data =
+                                    sas_device->starget->hostdata;
+                                sas_target_priv_data->tm_busy = 0;
+                        }
+                }
+        } else {
+                dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
+                    "tr_complete:handle(0x%04x), (open) ioc_status(0x%04x), "
+                    "loginfo(0x%08x), completed(%d)\n", ioc->name,
+                    handle, le16_to_cpu(mpi_reply->IOCStatus),
                     le32_to_cpu(mpi_reply->IOCLogInfo),
                     le32_to_cpu(mpi_reply->TerminationCount)));
-
-        if (sas_device->starget && sas_device->starget->hostdata) {
-                sas_target_priv_data = sas_device->starget->hostdata;
-                sas_target_priv_data->tm_busy = 0;
         }
 
         if (!list_empty(&ioc->delayed_tr_list)) {
@@ -2514,8 +2764,7 @@ _scsih_tm_tr_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
         } else
                 rc = 1;
 
-
-        if (!(sas_device->state & MPT2SAS_REQ_SAS_CNTRL))
+        if (sas_device && !(sas_device->state & MPT2SAS_REQ_SAS_CNTRL))
                 return rc;
 
         if (ioc->shost_recovery) {
@@ -2531,12 +2780,14 @@ _scsih_tm_tr_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
                 return rc;
         }
 
+        if (sas_device)
+                sas_device->state |= MPTSAS_STATE_CNTRL_SEND;
+
         mpi_request = mpt2sas_base_get_msg_frame(ioc, smid_sas_ctrl);
         memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t));
         mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL;
         mpi_request->Operation = MPI2_SAS_OP_REMOVE_DEVICE;
         mpi_request->DevHandle = mpi_reply->DevHandle;
-        sas_device->state |= MPTSAS_STATE_CNTRL_SEND;
         mpt2sas_base_put_smid_default(ioc, smid_sas_ctrl);
         return rc;
 }
@@ -2678,8 +2929,6 @@ _scsih_setup_eedp(struct scsi_cmnd *scmd, Mpi2SCSIIORequest_t *mpi_request)
         else
                 return;
 
-        mpi_request->EEDPBlockSize = scmd->device->sector_size;
-
         switch (prot_type) {
         case SCSI_PROT_DIF_TYPE1:
 
@@ -2687,8 +2936,7 @@ _scsih_setup_eedp(struct scsi_cmnd *scmd, Mpi2SCSIIORequest_t *mpi_request)
                 * enable ref/guard checking
                 * auto increment ref tag
                 */
-                mpi_request->EEDPFlags = eedp_flags |
-                    MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
+                eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
                     MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
                     MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
                 mpi_request->CDB.EEDP32.PrimaryReferenceTag =
@@ -2701,11 +2949,11 @@ _scsih_setup_eedp(struct scsi_cmnd *scmd, Mpi2SCSIIORequest_t *mpi_request)
                 /*
                 * enable guard checking
                 */
-                mpi_request->EEDPFlags = eedp_flags |
-                    MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
-
+                eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
                 break;
         }
+        mpi_request->EEDPBlockSize = cpu_to_le32(scmd->device->sector_size);
+        mpi_request->EEDPFlags = cpu_to_le16(eedp_flags);
 }
 
 /**
@@ -2788,7 +3036,7 @@ _scsih_qcmd(struct scsi_cmnd *scmd, void (*done)(struct scsi_cmnd *))
         }
 
         /* see if we are busy with task managment stuff */
-        if (sas_target_priv_data->tm_busy)
+        if (sas_device_priv_data->block || sas_target_priv_data->tm_busy)
                 return SCSI_MLQUEUE_DEVICE_BUSY;
         else if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress)
                 return SCSI_MLQUEUE_HOST_BUSY;
@@ -2815,8 +3063,9 @@ _scsih_qcmd(struct scsi_cmnd *scmd, void (*done)(struct scsi_cmnd *))
 
         } else
                 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
-
-        if ((sas_device_priv_data->flags & MPT_DEVICE_TLR_ON))
+        /* Make sure Device is not raid volume */
+        if (!_scsih_is_raid(&scmd->device->sdev_gendev) &&
+            sas_is_tlr_enabled(scmd->device))
                 mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON;
 
         smid = mpt2sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
@@ -2842,7 +3091,7 @@ _scsih_qcmd(struct scsi_cmnd *scmd, void (*done)(struct scsi_cmnd *))
         mpi_request->MsgFlags = MPI2_SCSIIO_MSGFLAGS_SYSTEM_SENSE_ADDR;
         mpi_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE;
         mpi_request->SenseBufferLowAddress =
-            (u32)mpt2sas_base_get_sense_buffer_dma(ioc, smid);
+            mpt2sas_base_get_sense_buffer_dma(ioc, smid);
         mpi_request->SGLOffset0 = offsetof(Mpi2SCSIIORequest_t, SGL) / 4;
         mpi_request->SGLFlags = cpu_to_le16(MPI2_SCSIIO_SGLFLAGS_TYPE_MPI +
             MPI2_SCSIIO_SGLFLAGS_SYSTEM_ADDR);
@@ -2894,7 +3143,7 @@ _scsih_normalize_sense(char *sense_buffer, struct sense_info *data)
 
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
 /**
- * _scsih_scsi_ioc_info - translated non-succesfull SCSI_IO request
+ * _scsih_scsi_ioc_info - translated non-successfull SCSI_IO request
  * @ioc: per adapter object
  * @scmd: pointer to scsi command object
  * @mpi_reply: reply mf payload returned from firmware
@@ -3059,7 +3308,7 @@ _scsih_scsi_ioc_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
         if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) {
                 response_info = le32_to_cpu(mpi_reply->ResponseInfo);
                 response_bytes = (u8 *)&response_info;
-                _scsih_response_code(ioc, response_bytes[3]);
+                _scsih_response_code(ioc, response_bytes[0]);
         }
 }
 #endif
@@ -3177,7 +3426,7 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
         u8 scsi_status;
         u32 log_info;
         struct MPT2SAS_DEVICE *sas_device_priv_data;
-        u32 response_code;
+        u32 response_code = 0;
 
         mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
         scmd = _scsih_scsi_lookup_get(ioc, smid);
@@ -3199,15 +3448,17 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
         }
 
         /* turning off TLR */
+        scsi_state = mpi_reply->SCSIState;
+        if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID)
+                response_code =
+                    le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF;
         if (!sas_device_priv_data->tlr_snoop_check) {
                 sas_device_priv_data->tlr_snoop_check++;
-                if (sas_device_priv_data->flags & MPT_DEVICE_TLR_ON) {
-                        response_code = (le32_to_cpu(mpi_reply->ResponseInfo)
-                            >> 24);
-                        if (response_code ==
-                            MPI2_SCSITASKMGMT_RSP_INVALID_FRAME)
-                                sas_device_priv_data->flags &=
-                                    ~MPT_DEVICE_TLR_ON;
+        if (!_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);
+                        sdev_printk(KERN_INFO, scmd->device, "TLR disabled\n");
                 }
         }
 
@@ -3219,7 +3470,6 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
         else
                 log_info = 0;
         ioc_status &= MPI2_IOCSTATUS_MASK;
-        scsi_state = mpi_reply->SCSIState;
         scsi_status = mpi_reply->SCSIStatus;
 
         if (ioc_status == MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 &&
@@ -3255,10 +3505,9 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
 
         case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED:
                 if (sas_device_priv_data->block) {
-                        scmd->result = (DID_BUS_BUSY << 16);
-                        break;
+                        scmd->result = DID_TRANSPORT_DISRUPTED << 16;
+                        goto out;
                 }
-
         case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
         case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED:
                 scmd->result = DID_RESET << 16;
@@ -3304,8 +3553,10 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
         case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR:
         case MPI2_IOCSTATUS_SUCCESS:
                 scmd->result = (DID_OK << 16) | scsi_status;
-                if (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
-                     MPI2_SCSI_STATE_NO_SCSI_STATUS))
+                if (response_code ==
+                    MPI2_SCSITASKMGMT_RSP_INVALID_FRAME ||
+                    (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED |
+                     MPI2_SCSI_STATE_NO_SCSI_STATUS)))
                         scmd->result = DID_SOFT_ERROR << 16;
                 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED)
                         scmd->result = DID_RESET << 16;
@@ -3344,7 +3595,6 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
 /**
  * _scsih_sas_host_refresh - refreshing sas host object contents
  * @ioc: per adapter object
- * @update: update link information
  * Context: user
  *
  * During port enable, fw will send topology events for every device. Its
@@ -3354,13 +3604,14 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
  * Return nothing.
  */
 static void
-_scsih_sas_host_refresh(struct MPT2SAS_ADAPTER *ioc, u8 update)
+_scsih_sas_host_refresh(struct MPT2SAS_ADAPTER *ioc)
 {
         u16 sz;
         u16 ioc_status;
         int i;
         Mpi2ConfigReply_t mpi_reply;
         Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
+        u16 attached_handle;
 
         dtmprintk(ioc, printk(MPT2SAS_INFO_FMT
             "updating handles for sas_host(0x%016llx)\n",
@@ -3374,27 +3625,24 @@ _scsih_sas_host_refresh(struct MPT2SAS_ADAPTER *ioc, u8 update)
                     ioc->name, __FILE__, __LINE__, __func__);
                 return;
         }
-        if (!(mpt2sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
-            sas_iounit_pg0, sz))) {
-                ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
-                    MPI2_IOCSTATUS_MASK;
-                if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
-                        goto out;
-                for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
-                        ioc->sas_hba.phy[i].handle =
-                            le16_to_cpu(sas_iounit_pg0->PhyData[i].
-                                ControllerDevHandle);
-                        if (update)
-                                mpt2sas_transport_update_links(
-                                    ioc,
-                                    ioc->sas_hba.phy[i].handle,
-                                    le16_to_cpu(sas_iounit_pg0->PhyData[i].
-                                    AttachedDevHandle), i,
-                                    sas_iounit_pg0->PhyData[i].
-                                    NegotiatedLinkRate >> 4);
-                }
-        }
 
+        if ((mpt2sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
+            sas_iounit_pg0, sz)) != 0)
+                goto out;
+        ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK;
+        if (ioc_status != MPI2_IOCSTATUS_SUCCESS)
+                goto out;
+        for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
+                if (i == 0)
+                        ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
+                            PhyData[0].ControllerDevHandle);
+                ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
+                attached_handle = le16_to_cpu(sas_iounit_pg0->PhyData[i].
+                    AttachedDevHandle);
+                mpt2sas_transport_update_links(ioc, ioc->sas_hba.sas_address,
+                    attached_handle, i, sas_iounit_pg0->PhyData[i].
+                    NegotiatedLinkRate >> 4);
+        }
  out:
         kfree(sas_iounit_pg0);
 }
@@ -3507,19 +3755,21 @@ _scsih_sas_host_add(struct MPT2SAS_ADAPTER *ioc)
                             ioc->name, __FILE__, __LINE__, __func__);
                         goto out;
                 }
-                ioc->sas_hba.phy[i].handle =
-                    le16_to_cpu(sas_iounit_pg0->PhyData[i].ControllerDevHandle);
+
+                if (i == 0)
+                        ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0->
+                            PhyData[0].ControllerDevHandle);
+                ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle;
                 ioc->sas_hba.phy[i].phy_id = i;
                 mpt2sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i],
                     phy_pg0, ioc->sas_hba.parent_dev);
         }
         if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
-            MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.phy[0].handle))) {
+            MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) {
                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
                     ioc->name, __FILE__, __LINE__, __func__);
                 goto out;
         }
-        ioc->sas_hba.handle = le16_to_cpu(sas_device_pg0.DevHandle);
         ioc->sas_hba.enclosure_handle =
             le16_to_cpu(sas_device_pg0.EnclosureHandle);
         ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
@@ -3562,7 +3812,7 @@ _scsih_expander_add(struct MPT2SAS_ADAPTER *ioc, u16 handle)
         Mpi2SasEnclosurePage0_t enclosure_pg0;
         u32 ioc_status;
         u16 parent_handle;
-        __le64 sas_address;
+        __le64 sas_address, sas_address_parent = 0;
         int i;
         unsigned long flags;
         struct _sas_port *mpt2sas_port = NULL;
@@ -3591,10 +3841,16 @@ _scsih_expander_add(struct MPT2SAS_ADAPTER *ioc, u16 handle)
 
         /* handle out of order topology events */
         parent_handle = le16_to_cpu(expander_pg0.ParentDevHandle);
-        if (parent_handle >= ioc->sas_hba.num_phys) {
+        if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent)
+            != 0) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                return -1;
+        }
+        if (sas_address_parent != ioc->sas_hba.sas_address) {
                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
-                sas_expander = mpt2sas_scsih_expander_find_by_handle(ioc,
-                    parent_handle);
+                sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
+                    sas_address_parent);
                 spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
                 if (!sas_expander) {
                         rc = _scsih_expander_add(ioc, parent_handle);
@@ -3622,14 +3878,12 @@ _scsih_expander_add(struct MPT2SAS_ADAPTER *ioc, u16 handle)
 
         sas_expander->handle = handle;
         sas_expander->num_phys = expander_pg0.NumPhys;
-        sas_expander->parent_handle = parent_handle;
-        sas_expander->enclosure_handle =
-            le16_to_cpu(expander_pg0.EnclosureHandle);
+        sas_expander->sas_address_parent = sas_address_parent;
         sas_expander->sas_address = sas_address;
 
         printk(MPT2SAS_INFO_FMT "expander_add: handle(0x%04x),"
             " parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n", ioc->name,
-            handle, sas_expander->parent_handle, (unsigned long long)
+            handle, parent_handle, (unsigned long long)
             sas_expander->sas_address, sas_expander->num_phys);
 
         if (!sas_expander->num_phys)
@@ -3645,7 +3899,7 @@ _scsih_expander_add(struct MPT2SAS_ADAPTER *ioc, u16 handle)
 
         INIT_LIST_HEAD(&sas_expander->sas_port_list);
         mpt2sas_port = mpt2sas_transport_port_add(ioc, handle,
-            sas_expander->parent_handle);
+            sas_address_parent);
         if (!mpt2sas_port) {
                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
                     ioc->name, __FILE__, __LINE__, __func__);
@@ -3691,20 +3945,54 @@ _scsih_expander_add(struct MPT2SAS_ADAPTER *ioc, u16 handle)
 
         if (mpt2sas_port)
                 mpt2sas_transport_port_remove(ioc, sas_expander->sas_address,
-                    sas_expander->parent_handle);
+                    sas_address_parent);
         kfree(sas_expander);
         return rc;
 }
 
 /**
+ * _scsih_done -  scsih callback handler.
+ * @ioc: per adapter object
+ * @smid: system request message index
+ * @msix_index: MSIX table index supplied by the OS
+ * @reply: reply message frame(lower 32bit addr)
+ *
+ * Callback handler when sending internal generated message frames.
+ * The callback index passed is `ioc->scsih_cb_idx`
+ *
+ * Return 1 meaning mf should be freed from _base_interrupt
+ *        0 means the mf is freed from this function.
+ */
+static u8
+_scsih_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
+{
+        MPI2DefaultReply_t *mpi_reply;
+
+        mpi_reply =  mpt2sas_base_get_reply_virt_addr(ioc, reply);
+        if (ioc->scsih_cmds.status == MPT2_CMD_NOT_USED)
+                return 1;
+        if (ioc->scsih_cmds.smid != smid)
+                return 1;
+        ioc->scsih_cmds.status |= MPT2_CMD_COMPLETE;
+        if (mpi_reply) {
+                memcpy(ioc->scsih_cmds.reply, mpi_reply,
+                    mpi_reply->MsgLength*4);
+                ioc->scsih_cmds.status |= MPT2_CMD_REPLY_VALID;
+        }
+        ioc->scsih_cmds.status &= ~MPT2_CMD_PENDING;
+        complete(&ioc->scsih_cmds.done);
+        return 1;
+}
+
+/**
  * _scsih_expander_remove - removing expander object
  * @ioc: per adapter object
- * @handle: expander handle
+ * @sas_address: expander sas_address
  *
  * Return nothing.
  */
 static void
-_scsih_expander_remove(struct MPT2SAS_ADAPTER *ioc, u16 handle)
+_scsih_expander_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
 {
         struct _sas_node *sas_expander;
         unsigned long flags;
@@ -3713,7 +4001,8 @@ _scsih_expander_remove(struct MPT2SAS_ADAPTER *ioc, u16 handle)
                 return;
 
         spin_lock_irqsave(&ioc->sas_node_lock, flags);
-        sas_expander = mpt2sas_scsih_expander_find_by_handle(ioc, handle);
+        sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
+            sas_address);
         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
         _scsih_expander_node_remove(ioc, sas_expander);
 }
@@ -3805,8 +4094,11 @@ _scsih_add_device(struct MPT2SAS_ADAPTER *ioc, u16 handle, u8 phy_num, u8 is_pd)
         }
 
         sas_device->handle = handle;
-        sas_device->parent_handle =
-            le16_to_cpu(sas_device_pg0.ParentDevHandle);
+        if (_scsih_get_sas_address(ioc, le16_to_cpu
+                (sas_device_pg0.ParentDevHandle),
+                &sas_device->sas_address_parent) != 0)
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
         sas_device->enclosure_handle =
             le16_to_cpu(sas_device_pg0.EnclosureHandle);
         sas_device->slot =
@@ -3836,43 +4128,39 @@ _scsih_add_device(struct MPT2SAS_ADAPTER *ioc, u16 handle, u8 phy_num, u8 is_pd)
 /**
  * _scsih_remove_device -  removing sas device object
  * @ioc: per adapter object
- * @handle: sas device handle
+ * @sas_device: the sas_device object
  *
  * Return nothing.
  */
 static void
-_scsih_remove_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
+_scsih_remove_device(struct MPT2SAS_ADAPTER *ioc, struct _sas_device
+    *sas_device)
 {
         struct MPT2SAS_TARGET *sas_target_priv_data;
-        struct _sas_device *sas_device;
-        unsigned long flags;
         Mpi2SasIoUnitControlReply_t mpi_reply;
         Mpi2SasIoUnitControlRequest_t mpi_request;
-        u16 device_handle;
+        u16 device_handle, handle;
 
-        /* lookup sas_device */
-        spin_lock_irqsave(&ioc->sas_device_lock, flags);
-        sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
-        if (!sas_device) {
-                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
+        if (!sas_device)
                 return;
-        }
 
-        dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter: handle"
-            "(0x%04x)\n", ioc->name, __func__, handle));
+        handle = sas_device->handle;
+        dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter: handle(0x%04x),"
+            " sas_addr(0x%016llx)\n", ioc->name, __func__, handle,
+            (unsigned long long) sas_device->sas_address));
 
         if (sas_device->starget && sas_device->starget->hostdata) {
                 sas_target_priv_data = sas_device->starget->hostdata;
                 sas_target_priv_data->deleted = 1;
         }
-        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 
-        if (ioc->remove_host)
+        if (ioc->remove_host || ioc->shost_recovery || !handle)
                 goto out;
 
         if ((sas_device->state & MPTSAS_STATE_TR_COMPLETE)) {
                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "\tskip "
-                   "target_reset handle(0x%04x)\n", ioc->name, handle));
+                   "target_reset handle(0x%04x)\n", ioc->name,
+                   handle));
                 goto skip_tr;
         }
 
@@ -3925,10 +4213,10 @@ _scsih_remove_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
         _scsih_ublock_io_device(ioc, handle);
 
         mpt2sas_transport_port_remove(ioc, sas_device->sas_address,
-            sas_device->parent_handle);
+            sas_device->sas_address_parent);
 
         printk(MPT2SAS_INFO_FMT "removing handle(0x%04x), sas_addr"
-            "(0x%016llx)\n", ioc->name, sas_device->handle,
+            "(0x%016llx)\n", ioc->name, handle,
             (unsigned long long) sas_device->sas_address);
         _scsih_sas_device_remove(ioc, sas_device);
 
@@ -3952,7 +4240,7 @@ _scsih_sas_topology_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
         u16 reason_code;
         u8 phy_number;
         char *status_str = NULL;
-        char link_rate[25];
+        u8 link_rate, prev_link_rate;
 
         switch (event_data->ExpStatus) {
         case MPI2_EVENT_SAS_TOPO_ES_ADDED:
@@ -3962,6 +4250,7 @@ _scsih_sas_topology_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
                 status_str = "remove";
                 break;
         case MPI2_EVENT_SAS_TOPO_ES_RESPONDING:
+        case 0:
                 status_str =  "responding";
                 break;
         case MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING:
@@ -3987,30 +4276,30 @@ _scsih_sas_topology_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
                     MPI2_EVENT_SAS_TOPO_RC_MASK;
                 switch (reason_code) {
                 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
-                        snprintf(link_rate, 25, ": add, link(0x%02x)",
-                            (event_data->PHY[i].LinkRate >> 4));
-                        status_str = link_rate;
+                        status_str = "target add";
                         break;
                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
-                        status_str = ": remove";
+                        status_str = "target remove";
                         break;
                 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING:
-                        status_str = ": remove_delay";
+                        status_str = "delay target remove";
                         break;
                 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
-                        snprintf(link_rate, 25, ": link(0x%02x)",
-                            (event_data->PHY[i].LinkRate >> 4));
-                        status_str = link_rate;
+                        status_str = "link rate change";
                         break;
                 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE:
-                        status_str = ": responding";
+                        status_str = "target responding";
                         break;
                 default:
-                        status_str = ": unknown";
+                        status_str = "unknown";
                         break;
                 }
-                printk(KERN_DEBUG "\tphy(%02d), attached_handle(0x%04x)%s\n",
-                    phy_number, handle, status_str);
+                link_rate = event_data->PHY[i].LinkRate >> 4;
+                prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
+                printk(KERN_DEBUG "\tphy(%02d), attached_handle(0x%04x): %s:"
+                    " link rate: new(0x%02x), old(0x%02x)\n", phy_number,
+                    handle, status_str, link_rate, prev_link_rate);
+
         }
 }
 #endif
@@ -4031,8 +4320,10 @@ _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
         u16 reason_code;
         u8 phy_number;
         struct _sas_node *sas_expander;
+        struct _sas_device *sas_device;
+        u64 sas_address;
         unsigned long flags;
-        u8 link_rate_;
+        u8 link_rate, prev_link_rate;
         Mpi2EventDataSasTopologyChangeList_t *event_data = fw_event->event_data;
 
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
@@ -4040,10 +4331,13 @@ _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
                 _scsih_sas_topology_change_event_debug(ioc, event_data);
 #endif
 
+        if (ioc->shost_recovery)
+                return;
+
         if (!ioc->sas_hba.num_phys)
                 _scsih_sas_host_add(ioc);
         else
-                _scsih_sas_host_refresh(ioc, 0);
+                _scsih_sas_host_refresh(ioc);
 
         if (fw_event->ignore) {
                 dewtprintk(ioc, printk(MPT2SAS_DEBUG_FMT "ignoring expander "
@@ -4058,6 +4352,17 @@ _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
                 if (_scsih_expander_add(ioc, parent_handle) != 0)
                         return;
 
+        spin_lock_irqsave(&ioc->sas_node_lock, flags);
+        sas_expander = mpt2sas_scsih_expander_find_by_handle(ioc,
+            parent_handle);
+        spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
+        if (sas_expander)
+                sas_address = sas_expander->sas_address;
+        else if (parent_handle < ioc->sas_hba.num_phys)
+                sas_address = ioc->sas_hba.sas_address;
+        else
+                return;
+
         /* handle siblings events */
         for (i = 0; i < event_data->NumEntries; i++) {
                 if (fw_event->ignore) {
@@ -4077,48 +4382,47 @@ _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
                 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle);
                 if (!handle)
                         continue;
-                link_rate_ = event_data->PHY[i].LinkRate >> 4;
+                link_rate = event_data->PHY[i].LinkRate >> 4;
+                prev_link_rate = event_data->PHY[i].LinkRate & 0xF;
                 switch (reason_code) {
                 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED:
+
+                        if (link_rate == prev_link_rate)
+                                break;
+
+                        mpt2sas_transport_update_links(ioc, sas_address,
+                            handle, phy_number, link_rate);
+
+                        if (link_rate >= MPI2_SAS_NEG_LINK_RATE_1_5)
+                                _scsih_ublock_io_device(ioc, handle);
+                        break;
                 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED:
-                        if (!parent_handle) {
-                                if (phy_number < ioc->sas_hba.num_phys)
-                                        mpt2sas_transport_update_links(
-                                        ioc,
-                                        ioc->sas_hba.phy[phy_number].handle,
-                                        handle, phy_number, link_rate_);
-                        } else {
-                                spin_lock_irqsave(&ioc->sas_node_lock, flags);
-                                sas_expander =
-                                    mpt2sas_scsih_expander_find_by_handle(ioc,
-                                        parent_handle);
-                                spin_unlock_irqrestore(&ioc->sas_node_lock,
-                                    flags);
-                                if (sas_expander) {
-                                        if (phy_number < sas_expander->num_phys)
-                                                mpt2sas_transport_update_links(
-                                                ioc,
-                                                sas_expander->
-                                                phy[phy_number].handle,
-                                                handle, phy_number,
-                                                link_rate_);
-                                }
-                        }
-                        if (reason_code == MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED) {
-                                if (link_rate_ < MPI2_SAS_NEG_LINK_RATE_1_5)
-                                        break;
-                                _scsih_add_device(ioc, handle, phy_number, 0);
-                        }
+
+                        mpt2sas_transport_update_links(ioc, sas_address,
+                            handle, phy_number, link_rate);
+
+                        _scsih_add_device(ioc, handle, phy_number, 0);
                         break;
                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
-                        _scsih_remove_device(ioc, handle);
+
+                        spin_lock_irqsave(&ioc->sas_device_lock, flags);
+                        sas_device = _scsih_sas_device_find_by_handle(ioc,
+                            handle);
+                        if (!sas_device) {
+                                spin_unlock_irqrestore(&ioc->sas_device_lock,
+                                    flags);
+                                break;
+                        }
+                        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
+                        _scsih_remove_device(ioc, sas_device);
                         break;
                 }
         }
 
         /* handle expander removal */
-        if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING)
-                _scsih_expander_remove(ioc, parent_handle);
+        if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING &&
+            sas_expander)
+                _scsih_expander_remove(ioc, sas_address);
 
 }
 
@@ -4170,6 +4474,12 @@ _scsih_sas_device_status_change_event_debug(struct MPT2SAS_ADAPTER *ioc,
         case MPI2_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION:
                 reason_str = "internal async notification";
                 break;
+        case MPI2_EVENT_SAS_DEV_STAT_RC_EXPANDER_REDUCED_FUNCTIONALITY:
+                reason_str = "expander reduced functionality";
+                break;
+        case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_EXPANDER_REDUCED_FUNCTIONALITY:
+                reason_str = "expander reduced functionality complete";
+                break;
         default:
                 reason_str = "unknown reason";
                 break;
@@ -4197,11 +4507,43 @@ static void
 _scsih_sas_device_status_change_event(struct MPT2SAS_ADAPTER *ioc,
     struct fw_event_work *fw_event)
 {
+        struct MPT2SAS_TARGET *target_priv_data;
+        struct _sas_device *sas_device;
+        __le64 sas_address;
+        unsigned long flags;
+        Mpi2EventDataSasDeviceStatusChange_t *event_data =
+            fw_event->event_data;
+
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
                 _scsih_sas_device_status_change_event_debug(ioc,
-                     fw_event->event_data);
+                     event_data);
 #endif
+
+        if (!(event_data->ReasonCode ==
+            MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET &&
+           event_data->ReasonCode ==
+            MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET))
+                return;
+
+        spin_lock_irqsave(&ioc->sas_device_lock, flags);
+        sas_address = le64_to_cpu(event_data->SASAddress);
+        sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
+            sas_address);
+        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
+
+        if (!sas_device || !sas_device->starget)
+                return;
+
+        target_priv_data = sas_device->starget->hostdata;
+        if (!target_priv_data)
+                return;
+
+        if (event_data->ReasonCode ==
+            MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET)
+                target_priv_data->tm_busy = 1;
+        else
+                target_priv_data->tm_busy = 0;
 }
 
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
@@ -4281,6 +4623,7 @@ _scsih_sas_broadcast_primative_event(struct MPT2SAS_ADAPTER *ioc,
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
         Mpi2EventDataSasBroadcastPrimitive_t *event_data = fw_event->event_data;
 #endif
+        u16 ioc_status;
         dewtprintk(ioc, printk(MPT2SAS_DEBUG_FMT "broadcast primative: "
             "phy number(%d), width(%d)\n", ioc->name, event_data->PhyNum,
             event_data->PortWidth));
@@ -4314,8 +4657,9 @@ _scsih_sas_broadcast_primative_event(struct MPT2SAS_ADAPTER *ioc,
                 mpt2sas_scsih_issue_tm(ioc, handle, lun,
                     MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, smid, 30);
                 ioc->tm_cmds.status = MPT2_CMD_NOT_USED;
-
-                if ((mpi_reply->IOCStatus == MPI2_IOCSTATUS_SUCCESS) &&
+                ioc_status = le16_to_cpu(mpi_reply->IOCStatus)
+                    & MPI2_IOCSTATUS_MASK;
+                if ((ioc_status == MPI2_IOCSTATUS_SUCCESS) &&
                     (mpi_reply->ResponseCode ==
                      MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED ||
                      mpi_reply->ResponseCode ==
@@ -4570,7 +4914,7 @@ _scsih_sas_pd_delete(struct MPT2SAS_ADAPTER *ioc,
         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
         if (!sas_device)
                 return;
-        _scsih_remove_device(ioc, handle);
+        _scsih_remove_device(ioc, sas_device);
 }
 
 /**
@@ -4591,6 +4935,8 @@ _scsih_sas_pd_add(struct MPT2SAS_ADAPTER *ioc,
         Mpi2ConfigReply_t mpi_reply;
         Mpi2SasDevicePage0_t sas_device_pg0;
         u32 ioc_status;
+        u64 sas_address;
+        u16 parent_handle;
 
         spin_lock_irqsave(&ioc->sas_device_lock, flags);
         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
@@ -4615,9 +4961,10 @@ _scsih_sas_pd_add(struct MPT2SAS_ADAPTER *ioc,
                 return;
         }
 
-        mpt2sas_transport_update_links(ioc,
-            le16_to_cpu(sas_device_pg0.ParentDevHandle),
-            handle, sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
+        parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
+        if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
+                mpt2sas_transport_update_links(ioc, sas_address, handle,
+                    sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
 
         _scsih_add_device(ioc, handle, 0, 1);
 }
@@ -4857,7 +5204,7 @@ static void
 _scsih_sas_ir_physical_disk_event(struct MPT2SAS_ADAPTER *ioc,
     struct fw_event_work *fw_event)
 {
-        u16 handle;
+        u16 handle, parent_handle;
         u32 state;
         struct _sas_device *sas_device;
         unsigned long flags;
@@ -4865,6 +5212,7 @@ _scsih_sas_ir_physical_disk_event(struct MPT2SAS_ADAPTER *ioc,
         Mpi2SasDevicePage0_t sas_device_pg0;
         u32 ioc_status;
         Mpi2EventDataIrPhysicalDisk_t *event_data = fw_event->event_data;
+        u64 sas_address;
 
         if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED)
                 return;
@@ -4906,9 +5254,10 @@ _scsih_sas_ir_physical_disk_event(struct MPT2SAS_ADAPTER *ioc,
                         return;
                 }
 
-                mpt2sas_transport_update_links(ioc,
-                    le16_to_cpu(sas_device_pg0.ParentDevHandle),
-                    handle, sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
+                parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
+                if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address))
+                        mpt2sas_transport_update_links(ioc, sas_address, handle,
+                            sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5);
 
                 _scsih_add_device(ioc, handle, 0, 1);
 
@@ -4948,11 +5297,17 @@ _scsih_sas_ir_operation_status_event_debug(struct MPT2SAS_ADAPTER *ioc,
         case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK:
                 reason_str = "consistency check";
                 break;
-        default:
-                reason_str = "unknown reason";
+        case MPI2_EVENT_IR_RAIDOP_BACKGROUND_INIT:
+                reason_str = "background init";
+                break;
+        case MPI2_EVENT_IR_RAIDOP_MAKE_DATA_CONSISTENT:
+                reason_str = "make data consistent";
                 break;
         }
 
+        if (!reason_str)
+                return;
+
         printk(MPT2SAS_INFO_FMT "raid operational status: (%s)"
             "\thandle(0x%04x), percent complete(%d)\n",
             ioc->name, reason_str,
@@ -4973,11 +5328,33 @@ static void
 _scsih_sas_ir_operation_status_event(struct MPT2SAS_ADAPTER *ioc,
     struct fw_event_work *fw_event)
 {
+        Mpi2EventDataIrOperationStatus_t *event_data = fw_event->event_data;
+        static struct _raid_device *raid_device;
+        unsigned long flags;
+        u16 handle;
+
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
                 _scsih_sas_ir_operation_status_event_debug(ioc,
-                     fw_event->event_data);
+                     event_data);
 #endif
+
+        /* code added for raid transport support */
+        if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC) {
+
+                handle = le16_to_cpu(event_data->VolDevHandle);
+
+                spin_lock_irqsave(&ioc->raid_device_lock, flags);
+                raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
+                spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
+
+                if (!raid_device)
+                        return;
+
+                if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC)
+                        raid_device->percent_complete =
+                            event_data->PercentComplete;
+        }
 }
 
 /**
@@ -5252,18 +5629,23 @@ _scsih_mark_responding_expander(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
 {
         struct _sas_node *sas_expander;
         unsigned long flags;
+        int i;
 
         spin_lock_irqsave(&ioc->sas_node_lock, flags);
         list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
-                if (sas_expander->sas_address == sas_address) {
-                        sas_expander->responding = 1;
-                        if (sas_expander->handle != handle) {
-                                printk(KERN_INFO "old handle(0x%04x)\n",
-                                    sas_expander->handle);
-                                sas_expander->handle = handle;
-                        }
+                if (sas_expander->sas_address != sas_address)
+                        continue;
+                sas_expander->responding = 1;
+                if (sas_expander->handle == handle)
                         goto out;
-                }
+                printk(KERN_INFO "\texpander(0x%016llx): handle changed"
+                    " from(0x%04x) to (0x%04x)!!!\n",
+                    (unsigned long long)sas_expander->sas_address,
+                    sas_expander->handle, handle);
+                sas_expander->handle = handle;
+                for (i = 0 ; i < sas_expander->num_phys ; i++)
+                        sas_expander->phy[i].handle = handle;
+                goto out;
         }
  out:
         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
@@ -5340,7 +5722,9 @@ _scsih_remove_unresponding_devices(struct MPT2SAS_ADAPTER *ioc)
                             (unsigned long long)
                             sas_device->enclosure_logical_id,
                             sas_device->slot);
-                _scsih_remove_device(ioc, sas_device->handle);
+                /* invalidate the device handle */
+                sas_device->handle = 0;
+                _scsih_remove_device(ioc, sas_device);
         }
 
         list_for_each_entry_safe(raid_device, raid_device_next,
@@ -5366,7 +5750,7 @@ _scsih_remove_unresponding_devices(struct MPT2SAS_ADAPTER *ioc)
                         sas_expander->responding = 0;
                         continue;
                 }
-                _scsih_expander_remove(ioc, sas_expander->handle);
+                _scsih_expander_remove(ioc, sas_expander->sas_address);
                 goto retry_expander_search;
         }
 }
@@ -5406,7 +5790,7 @@ mpt2sas_scsih_reset_handler(struct MPT2SAS_ADAPTER *ioc, int reset_phase)
         case MPT2_IOC_DONE_RESET:
                 dtmprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s: "
                     "MPT2_IOC_DONE_RESET\n", ioc->name, __func__));
-                _scsih_sas_host_refresh(ioc, 0);
+                _scsih_sas_host_refresh(ioc);
                 _scsih_search_responding_sas_devices(ioc);
                 _scsih_search_responding_raid_devices(ioc);
                 _scsih_search_responding_expanders(ioc);
@@ -5646,7 +6030,7 @@ _scsih_expander_node_remove(struct MPT2SAS_ADAPTER *ioc,
                         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
                         if (!sas_device)
                                 continue;
-                        _scsih_remove_device(ioc, sas_device->handle);
+                        _scsih_remove_device(ioc, sas_device);
                         if (ioc->shost_recovery)
                                 return;
                         goto retry_device_search;
@@ -5669,7 +6053,8 @@ _scsih_expander_node_remove(struct MPT2SAS_ADAPTER *ioc,
                         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
                         if (!expander_sibling)
                                 continue;
-                        _scsih_expander_remove(ioc, expander_sibling->handle);
+                        _scsih_expander_remove(ioc,
+                            expander_sibling->sas_address);
                         if (ioc->shost_recovery)
                                 return;
                         goto retry_expander_search;
@@ -5677,7 +6062,7 @@ _scsih_expander_node_remove(struct MPT2SAS_ADAPTER *ioc,
         }
 
         mpt2sas_transport_port_remove(ioc, sas_expander->sas_address,
-            sas_expander->parent_handle);
+            sas_expander->sas_address_parent);
 
         printk(MPT2SAS_INFO_FMT "expander_remove: handle"
            "(0x%04x), sas_addr(0x%016llx)\n", ioc->name,
@@ -5690,9 +6075,99 @@ _scsih_expander_node_remove(struct MPT2SAS_ADAPTER *ioc,
 }
 
 /**
+ * _scsih_ir_shutdown - IR shutdown notification
+ * @ioc: per adapter object
+ *
+ * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that
+ * the host system is shutting down.
+ *
+ * Return nothing.
+ */
+static void
+_scsih_ir_shutdown(struct MPT2SAS_ADAPTER *ioc)
+{
+        Mpi2RaidActionRequest_t *mpi_request;
+        Mpi2RaidActionReply_t *mpi_reply;
+        u16 smid;
+
+        /* is IR firmware build loaded ? */
+        if (!ioc->ir_firmware)
+                return;
+
+        /* are there any volumes ? */
+        if (list_empty(&ioc->raid_device_list))
+                return;
+
+        mutex_lock(&ioc->scsih_cmds.mutex);
+
+        if (ioc->scsih_cmds.status != MPT2_CMD_NOT_USED) {
+                printk(MPT2SAS_ERR_FMT "%s: scsih_cmd in use\n",
+                    ioc->name, __func__);
+                goto out;
+        }
+        ioc->scsih_cmds.status = MPT2_CMD_PENDING;
+
+        smid = mpt2sas_base_get_smid(ioc, ioc->scsih_cb_idx);
+        if (!smid) {
+                printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
+                    ioc->name, __func__);
+                ioc->scsih_cmds.status = MPT2_CMD_NOT_USED;
+                goto out;
+        }
+
+        mpi_request = mpt2sas_base_get_msg_frame(ioc, smid);
+        ioc->scsih_cmds.smid = smid;
+        memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t));
+
+        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);
+        init_completion(&ioc->scsih_cmds.done);
+        mpt2sas_base_put_smid_default(ioc, smid);
+        wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
+
+        if (!(ioc->scsih_cmds.status & MPT2_CMD_COMPLETE)) {
+                printk(MPT2SAS_ERR_FMT "%s: timeout\n",
+                    ioc->name, __func__);
+                goto out;
+        }
+
+        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));
+        }
+
+ out:
+        ioc->scsih_cmds.status = MPT2_CMD_NOT_USED;
+        mutex_unlock(&ioc->scsih_cmds.mutex);
+}
+
+/**
+ * _scsih_shutdown - routine call during system shutdown
+ * @pdev: PCI device struct
+ *
+ * Return nothing.
+ */
+static void
+_scsih_shutdown(struct pci_dev *pdev)
+{
+        struct Scsi_Host *shost = pci_get_drvdata(pdev);
+        struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
+
+        _scsih_ir_shutdown(ioc);
+        mpt2sas_base_detach(ioc);
+}
+
+/**
  * _scsih_remove - detach and remove add host
  * @pdev: PCI device struct
  *
+ * Routine called when unloading the driver.
  * Return nothing.
  */
 static void __devexit
@@ -5703,6 +6178,8 @@ _scsih_remove(struct pci_dev *pdev)
         struct _sas_port *mpt2sas_port;
         struct _sas_device *sas_device;
         struct _sas_node *expander_sibling;
+        struct _raid_device *raid_device, *next;
+        struct MPT2SAS_TARGET *sas_target_priv_data;
         struct workqueue_struct *wq;
         unsigned long flags;
 
@@ -5716,6 +6193,21 @@ _scsih_remove(struct pci_dev *pdev)
         if (wq)
                 destroy_workqueue(wq);
 
+        /* release all the volumes */
+        list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list,
+            list) {
+                if (raid_device->starget) {
+                        sas_target_priv_data =
+                            raid_device->starget->hostdata;
+                        sas_target_priv_data->deleted = 1;
+                        scsi_remove_target(&raid_device->starget->dev);
+                }
+                printk(MPT2SAS_INFO_FMT "removing handle(0x%04x), wwid"
+                    "(0x%016llx)\n", ioc->name,  raid_device->handle,
+                    (unsigned long long) raid_device->wwid);
+                _scsih_raid_device_remove(ioc, raid_device);
+        }
+
         /* free ports attached to the sas_host */
  retry_again:
         list_for_each_entry(mpt2sas_port,
@@ -5726,7 +6218,7 @@ _scsih_remove(struct pci_dev *pdev)
                             mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
                            mpt2sas_port->remote_identify.sas_address);
                         if (sas_device) {
-                                _scsih_remove_device(ioc, sas_device->handle);
+                                _scsih_remove_device(ioc, sas_device);
                                 goto retry_again;
                         }
                 } else {
@@ -5735,7 +6227,7 @@ _scsih_remove(struct pci_dev *pdev)
                             mpt2sas_port->remote_identify.sas_address);
                         if (expander_sibling) {
                                 _scsih_expander_remove(ioc,
-                                    expander_sibling->handle);
+                                    expander_sibling->sas_address);
                                 goto retry_again;
                         }
                 }
@@ -5749,7 +6241,7 @@ _scsih_remove(struct pci_dev *pdev)
         }
 
         sas_remove_host(shost);
-        mpt2sas_base_detach(ioc);
+        _scsih_shutdown(pdev);
         list_del(&ioc->list);
         scsi_remove_host(shost);
         scsi_host_put(shost);
@@ -5770,7 +6262,8 @@ _scsih_probe_boot_devices(struct MPT2SAS_ADAPTER *ioc)
         void *device;
         struct _sas_device *sas_device;
         struct _raid_device *raid_device;
-        u16 handle, parent_handle;
+        u16 handle;
+        u64 sas_address_parent;
         u64 sas_address;
         unsigned long flags;
         int rc;
@@ -5799,17 +6292,17 @@ _scsih_probe_boot_devices(struct MPT2SAS_ADAPTER *ioc)
         } else {
                 sas_device = device;
                 handle = sas_device->handle;
-                parent_handle = sas_device->parent_handle;
+                sas_address_parent = sas_device->sas_address_parent;
                 sas_address = sas_device->sas_address;
                 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 (!mpt2sas_transport_port_add(ioc, sas_device->handle,
-                    sas_device->parent_handle)) {
+                    sas_device->sas_address_parent)) {
                         _scsih_sas_device_remove(ioc, sas_device);
                 } else if (!sas_device->starget) {
                         mpt2sas_transport_port_remove(ioc, sas_address,
-                            parent_handle);
+                            sas_address_parent);
                         _scsih_sas_device_remove(ioc, sas_device);
                 }
         }
@@ -5849,8 +6342,6 @@ _scsih_probe_sas(struct MPT2SAS_ADAPTER *ioc)
 {
         struct _sas_device *sas_device, *next;
         unsigned long flags;
-        u16 handle, parent_handle;
-        u64 sas_address;
 
         /* SAS Device List */
         list_for_each_entry_safe(sas_device, next, &ioc->sas_device_init_list,
@@ -5859,14 +6350,13 @@ _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);
 
-                handle = sas_device->handle;
-                parent_handle = sas_device->parent_handle;
-                sas_address = sas_device->sas_address;
-                if (!mpt2sas_transport_port_add(ioc, handle, parent_handle)) {
+                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_address,
-                            parent_handle);
+                        mpt2sas_transport_port_remove(ioc,
+                            sas_device->sas_address,
+                            sas_device->sas_address_parent);
                         _scsih_sas_device_remove(ioc, sas_device);
                 }
         }
@@ -5935,6 +6425,7 @@ _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         ioc->ctl_cb_idx = ctl_cb_idx;
         ioc->base_cb_idx = base_cb_idx;
         ioc->transport_cb_idx = transport_cb_idx;
+        ioc->scsih_cb_idx = scsih_cb_idx;
         ioc->config_cb_idx = config_cb_idx;
         ioc->tm_tr_cb_idx = tm_tr_cb_idx;
         ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx;
@@ -6072,12 +6563,20 @@ static struct pci_driver scsih_driver = {
         .id_table       = scsih_pci_table,
         .probe          = _scsih_probe,
         .remove         = __devexit_p(_scsih_remove),
+        .shutdown       = _scsih_shutdown,
 #ifdef CONFIG_PM
         .suspend        = _scsih_suspend,
         .resume         = _scsih_resume,
 #endif
 };
 
+/* raid transport support */
+static struct raid_function_template mpt2sas_raid_functions = {
+        .cookie         = &scsih_driver_template,
+        .is_raid        = _scsih_is_raid,
+        .get_resync     = _scsih_get_resync,
+        .get_state      = _scsih_get_state,
+};
 
 /**
  * _scsih_init - main entry point for this driver.
@@ -6097,6 +6596,12 @@ _scsih_init(void)
             sas_attach_transport(&mpt2sas_transport_functions);
         if (!mpt2sas_transport_template)
                 return -ENODEV;
+        /* raid transport support */
+        mpt2sas_raid_template = raid_class_attach(&mpt2sas_raid_functions);
+        if (!mpt2sas_raid_template) {
+                sas_release_transport(mpt2sas_transport_template);
+                return -ENODEV;
+        }
 
         mpt2sas_base_initialize_callback_handler();
 
@@ -6113,6 +6618,9 @@ _scsih_init(void)
         transport_cb_idx = mpt2sas_base_register_callback_handler(
             mpt2sas_transport_done);
 
+        /* scsih internal commands callback handler */
+        scsih_cb_idx = mpt2sas_base_register_callback_handler(_scsih_done);
+
         /* configuration page API internal commands callback handler */
         config_cb_idx = mpt2sas_base_register_callback_handler(
             mpt2sas_config_done);
@@ -6128,8 +6636,11 @@ _scsih_init(void)
         mpt2sas_ctl_init();
 
         error = pci_register_driver(&scsih_driver);
-        if (error)
+        if (error) {
+                /* raid transport support */
+                raid_class_release(mpt2sas_raid_template);
                 sas_release_transport(mpt2sas_transport_template);
+        }
 
         return error;
 }
@@ -6147,18 +6658,23 @@ _scsih_exit(void)
 
         pci_unregister_driver(&scsih_driver);
 
-        sas_release_transport(mpt2sas_transport_template);
+        mpt2sas_ctl_exit();
+
         mpt2sas_base_release_callback_handler(scsi_io_cb_idx);
         mpt2sas_base_release_callback_handler(tm_cb_idx);
         mpt2sas_base_release_callback_handler(base_cb_idx);
         mpt2sas_base_release_callback_handler(transport_cb_idx);
+        mpt2sas_base_release_callback_handler(scsih_cb_idx);
         mpt2sas_base_release_callback_handler(config_cb_idx);
         mpt2sas_base_release_callback_handler(ctl_cb_idx);
 
         mpt2sas_base_release_callback_handler(tm_tr_cb_idx);
         mpt2sas_base_release_callback_handler(tm_sas_control_cb_idx);
 
-        mpt2sas_ctl_exit();
+        /* raid transport support */
+        raid_class_release(mpt2sas_raid_template);
+        sas_release_transport(mpt2sas_transport_template);
+
 }
 
 module_init(_scsih_init);
diff --git a/drivers/scsi/mpt2sas/mpt2sas_transport.c b/drivers/scsi/mpt2sas/mpt2sas_transport.c
index eb98188c7f3f..bd7ca2b49f81 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_transport.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_transport.c
@@ -49,6 +49,7 @@
 #include <linux/workqueue.h>
 #include <linux/delay.h>
 #include <linux/pci.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -59,24 +60,23 @@
 
 #include "mpt2sas_base.h"
 /**
- * _transport_sas_node_find_by_handle - sas node search
+ * _transport_sas_node_find_by_sas_address - sas node search
  * @ioc: per adapter object
- * @handle: expander or hba handle (assigned by firmware)
+ * @sas_address: sas address of expander or sas host
  * Context: Calling function should acquire ioc->sas_node_lock.
  *
  * Search for either hba phys or expander device based on handle, then returns
  * the sas_node object.
  */
 static struct _sas_node *
-_transport_sas_node_find_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
+_transport_sas_node_find_by_sas_address(struct MPT2SAS_ADAPTER *ioc,
+    u64 sas_address)
 {
-        int i;
-
-        for (i = 0; i < ioc->sas_hba.num_phys; i++)
-                if (ioc->sas_hba.phy[i].handle == handle)
-                        return &ioc->sas_hba;
-
-        return mpt2sas_scsih_expander_find_by_handle(ioc, handle);
+        if (ioc->sas_hba.sas_address == sas_address)
+                return &ioc->sas_hba;
+        else
+                return mpt2sas_scsih_expander_find_by_sas_address(ioc,
+                    sas_address);
 }
 
 /**
@@ -259,8 +259,7 @@ struct rep_manu_reply{
         u8 response_length;
         u16 expander_change_count;
         u8 reserved0[2];
-        u8 sas_format:1;
-        u8 reserved1:7;
+        u8 sas_format;
         u8 reserved2[3];
         u8 vendor_id[SAS_EXPANDER_VENDOR_ID_LEN];
         u8 product_id[SAS_EXPANDER_PRODUCT_ID_LEN];
@@ -375,7 +374,8 @@ _transport_expander_report_manufacture(struct MPT2SAS_ADAPTER *ioc,
         mpi_request->VP_ID = 0;
         sas_address_le = (u64 *)&mpi_request->SASAddress;
         *sas_address_le = cpu_to_le64(sas_address);
-        mpi_request->RequestDataLength = sizeof(struct rep_manu_request);
+        mpi_request->RequestDataLength =
+            cpu_to_le16(sizeof(struct rep_manu_request));
         psge = &mpi_request->SGL;
 
         /* WRITE sgel first */
@@ -438,8 +438,8 @@ _transport_expander_report_manufacture(struct MPT2SAS_ADAPTER *ioc,
                      SAS_EXPANDER_PRODUCT_ID_LEN);
                 strncpy(edev->product_rev, manufacture_reply->product_rev,
                      SAS_EXPANDER_PRODUCT_REV_LEN);
-                edev->level = manufacture_reply->sas_format;
-                if (manufacture_reply->sas_format) {
+                edev->level = manufacture_reply->sas_format & 1;
+                if (edev->level) {
                         strncpy(edev->component_vendor_id,
                             manufacture_reply->component_vendor_id,
                              SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN);
@@ -469,7 +469,7 @@ _transport_expander_report_manufacture(struct MPT2SAS_ADAPTER *ioc,
  * mpt2sas_transport_port_add - insert port to the list
  * @ioc: per adapter object
  * @handle: handle of attached device
- * @parent_handle: parent handle(either hba or expander)
+ * @sas_address: sas address of parent expander or sas host
  * Context: This function will acquire ioc->sas_node_lock.
  *
  * Adding new port object to the sas_node->sas_port_list.
@@ -478,7 +478,7 @@ _transport_expander_report_manufacture(struct MPT2SAS_ADAPTER *ioc,
  */
 struct _sas_port *
 mpt2sas_transport_port_add(struct MPT2SAS_ADAPTER *ioc, u16 handle,
-    u16 parent_handle)
+    u64 sas_address)
 {
         struct _sas_phy *mpt2sas_phy, *next;
         struct _sas_port *mpt2sas_port;
@@ -488,9 +488,6 @@ mpt2sas_transport_port_add(struct MPT2SAS_ADAPTER *ioc, u16 handle,
         int i;
         struct sas_port *port;
 
-        if (!parent_handle)
-                return NULL;
-
         mpt2sas_port = kzalloc(sizeof(struct _sas_port),
             GFP_KERNEL);
         if (!mpt2sas_port) {
@@ -502,17 +499,16 @@ mpt2sas_transport_port_add(struct MPT2SAS_ADAPTER *ioc, u16 handle,
         INIT_LIST_HEAD(&mpt2sas_port->port_list);
         INIT_LIST_HEAD(&mpt2sas_port->phy_list);
         spin_lock_irqsave(&ioc->sas_node_lock, flags);
-        sas_node = _transport_sas_node_find_by_handle(ioc, parent_handle);
+        sas_node = _transport_sas_node_find_by_sas_address(ioc, sas_address);
         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
 
         if (!sas_node) {
-                printk(MPT2SAS_ERR_FMT "%s: Could not find parent(0x%04x)!\n",
-                    ioc->name, __func__, parent_handle);
+                printk(MPT2SAS_ERR_FMT "%s: Could not find "
+                    "parent sas_address(0x%016llx)!\n", ioc->name,
+                    __func__, (unsigned long long)sas_address);
                 goto out_fail;
         }
 
-        mpt2sas_port->handle = parent_handle;
-        mpt2sas_port->sas_address = sas_node->sas_address;
         if ((_transport_set_identify(ioc, handle,
             &mpt2sas_port->remote_identify))) {
                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
@@ -604,7 +600,7 @@ mpt2sas_transport_port_add(struct MPT2SAS_ADAPTER *ioc, u16 handle,
  * mpt2sas_transport_port_remove - remove port from the list
  * @ioc: per adapter object
  * @sas_address: sas address of attached device
- * @parent_handle: handle to the upstream parent(either hba or expander)
+ * @sas_address_parent: sas address of parent expander or sas host
  * Context: This function will acquire ioc->sas_node_lock.
  *
  * Removing object and freeing associated memory from the
@@ -614,7 +610,7 @@ mpt2sas_transport_port_add(struct MPT2SAS_ADAPTER *ioc, u16 handle,
  */
 void
 mpt2sas_transport_port_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
-    u16 parent_handle)
+    u64 sas_address_parent)
 {
         int i;
         unsigned long flags;
@@ -624,7 +620,8 @@ mpt2sas_transport_port_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
         struct _sas_phy *mpt2sas_phy, *next_phy;
 
         spin_lock_irqsave(&ioc->sas_node_lock, flags);
-        sas_node = _transport_sas_node_find_by_handle(ioc, parent_handle);
+        sas_node = _transport_sas_node_find_by_sas_address(ioc,
+            sas_address_parent);
         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
         if (!sas_node)
                 return;
@@ -650,8 +647,7 @@ mpt2sas_transport_port_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
             &mpt2sas_port->phy_list, port_siblings) {
                 if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
                         dev_printk(KERN_INFO, &mpt2sas_port->port->dev,
-                            "remove: parent_handle(0x%04x), "
-                            "sas_addr(0x%016llx), phy(%d)\n", parent_handle,
+                            "remove: sas_addr(0x%016llx), phy(%d)\n",
                             (unsigned long long)
                             mpt2sas_port->remote_identify.sas_address,
                             mpt2sas_phy->phy_id);
@@ -799,8 +795,8 @@ mpt2sas_transport_add_expander_phy(struct MPT2SAS_ADAPTER *ioc, struct _sas_phy
 /**
  * mpt2sas_transport_update_links - refreshing phy link changes
  * @ioc: per adapter object
- * @handle: handle to sas_host or expander
- * @attached_handle: attached device handle
+ * @sas_address: sas address of parent expander or sas host
+ * @handle: attached device handle
  * @phy_numberv: phy number
  * @link_rate: new link rate
  *
@@ -808,28 +804,25 @@ mpt2sas_transport_add_expander_phy(struct MPT2SAS_ADAPTER *ioc, struct _sas_phy
  */
 void
 mpt2sas_transport_update_links(struct MPT2SAS_ADAPTER *ioc,
-    u16 handle, u16 attached_handle, u8 phy_number, u8 link_rate)
+     u64 sas_address, u16 handle, u8 phy_number, u8 link_rate)
 {
         unsigned long flags;
         struct _sas_node *sas_node;
         struct _sas_phy *mpt2sas_phy;
 
-        if (ioc->shost_recovery) {
-                printk(MPT2SAS_INFO_FMT "%s: host reset in progress!\n",
-                        __func__, ioc->name);
+        if (ioc->shost_recovery)
                 return;
-        }
 
         spin_lock_irqsave(&ioc->sas_node_lock, flags);
-        sas_node = _transport_sas_node_find_by_handle(ioc, handle);
+        sas_node = _transport_sas_node_find_by_sas_address(ioc, sas_address);
         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
         if (!sas_node)
                 return;
 
         mpt2sas_phy = &sas_node->phy[phy_number];
-        mpt2sas_phy->attached_handle = attached_handle;
-        if (attached_handle && (link_rate >= MPI2_SAS_NEG_LINK_RATE_1_5))
-                _transport_set_identify(ioc, mpt2sas_phy->attached_handle,
+        mpt2sas_phy->attached_handle = handle;
+        if (handle && (link_rate >= MPI2_SAS_NEG_LINK_RATE_1_5))
+                _transport_set_identify(ioc, handle,
                     &mpt2sas_phy->remote_identify);
         else
                 memset(&mpt2sas_phy->remote_identify, 0 , sizeof(struct
@@ -841,13 +834,11 @@ mpt2sas_transport_update_links(struct MPT2SAS_ADAPTER *ioc,
 
         if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
                 dev_printk(KERN_INFO, &mpt2sas_phy->phy->dev,
-                    "refresh: handle(0x%04x), sas_addr(0x%016llx),\n"
+                    "refresh: parent sas_addr(0x%016llx),\n"
                     "\tlink_rate(0x%02x), phy(%d)\n"
                     "\tattached_handle(0x%04x), sas_addr(0x%016llx)\n",
-                    handle, (unsigned long long)
-                    mpt2sas_phy->identify.sas_address, link_rate,
-                    phy_number, attached_handle,
-                    (unsigned long long)
+                    (unsigned long long)sas_address,
+                    link_rate, phy_number, handle, (unsigned long long)
                     mpt2sas_phy->remote_identify.sas_address);
 }
 
@@ -865,6 +856,17 @@ rphy_to_ioc(struct sas_rphy *rphy)
         return shost_priv(shost);
 }
 
+static struct _sas_phy *
+_transport_find_local_phy(struct MPT2SAS_ADAPTER *ioc, struct sas_phy *phy)
+{
+        int i;
+
+        for (i = 0; i < ioc->sas_hba.num_phys; i++)
+                if (ioc->sas_hba.phy[i].phy == phy)
+                        return(&ioc->sas_hba.phy[i]);
+        return NULL;
+}
+
 /**
  * _transport_get_linkerrors -
  * @phy: The sas phy object
@@ -880,14 +882,8 @@ _transport_get_linkerrors(struct sas_phy *phy)
         struct _sas_phy *mpt2sas_phy;
         Mpi2ConfigReply_t mpi_reply;
         Mpi2SasPhyPage1_t phy_pg1;
-        int i;
 
-        for (i = 0, mpt2sas_phy = NULL; i < ioc->sas_hba.num_phys &&
-            !mpt2sas_phy; i++) {
-                if (ioc->sas_hba.phy[i].phy != phy)
-                        continue;
-                mpt2sas_phy = &ioc->sas_hba.phy[i];
-        }
+        mpt2sas_phy = _transport_find_local_phy(ioc, phy);
 
         if (!mpt2sas_phy) /* this phy not on sas_host */
                 return -EINVAL;
@@ -981,14 +977,8 @@ _transport_phy_reset(struct sas_phy *phy, int hard_reset)
         struct _sas_phy *mpt2sas_phy;
         Mpi2SasIoUnitControlReply_t mpi_reply;
         Mpi2SasIoUnitControlRequest_t mpi_request;
-        int i;
 
-        for (i = 0, mpt2sas_phy = NULL; i < ioc->sas_hba.num_phys &&
-            !mpt2sas_phy; i++) {
-                if (ioc->sas_hba.phy[i].phy != phy)
-                        continue;
-                mpt2sas_phy = &ioc->sas_hba.phy[i];
-        }
+        mpt2sas_phy = _transport_find_local_phy(ioc, phy);
 
         if (!mpt2sas_phy) /* this phy not on sas_host */
                 return -EINVAL;
@@ -1016,6 +1006,173 @@ _transport_phy_reset(struct sas_phy *phy, int hard_reset)
 }
 
 /**
+ * _transport_phy_enable - enable/disable phys
+ * @phy: The sas phy object
+ * @enable: enable phy when true
+ *
+ * Only support sas_host direct attached phys.
+ * Returns 0 for success, non-zero for failure.
+ */
+static int
+_transport_phy_enable(struct sas_phy *phy, int enable)
+{
+        struct MPT2SAS_ADAPTER *ioc = phy_to_ioc(phy);
+        struct _sas_phy *mpt2sas_phy;
+        Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
+        Mpi2ConfigReply_t mpi_reply;
+        u16 ioc_status;
+        u16 sz;
+        int rc = 0;
+
+        mpt2sas_phy = _transport_find_local_phy(ioc, phy);
+
+        if (!mpt2sas_phy) /* this phy not on sas_host */
+                return -EINVAL;
+
+        /* sas_iounit page 1 */
+        sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
+            sizeof(Mpi2SasIOUnit1PhyData_t));
+        sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
+        if (!sas_iounit_pg1) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -ENOMEM;
+                goto out;
+        }
+        if ((mpt2sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
+            sas_iounit_pg1, sz))) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -ENXIO;
+                goto out;
+        }
+        ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
+            MPI2_IOCSTATUS_MASK;
+        if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -EIO;
+                goto out;
+        }
+
+        if (enable)
+                sas_iounit_pg1->PhyData[mpt2sas_phy->phy_id].PhyFlags
+                    &= ~MPI2_SASIOUNIT1_PHYFLAGS_PHY_DISABLE;
+        else
+                sas_iounit_pg1->PhyData[mpt2sas_phy->phy_id].PhyFlags
+                    |= MPI2_SASIOUNIT1_PHYFLAGS_PHY_DISABLE;
+
+        mpt2sas_config_set_sas_iounit_pg1(ioc, &mpi_reply, sas_iounit_pg1, sz);
+
+ out:
+        kfree(sas_iounit_pg1);
+        return rc;
+}
+
+/**
+ * _transport_phy_speed - set phy min/max link rates
+ * @phy: The sas phy object
+ * @rates: rates defined in sas_phy_linkrates
+ *
+ * Only support sas_host direct attached phys.
+ * Returns 0 for success, non-zero for failure.
+ */
+static int
+_transport_phy_speed(struct sas_phy *phy, struct sas_phy_linkrates *rates)
+{
+        struct MPT2SAS_ADAPTER *ioc = phy_to_ioc(phy);
+        struct _sas_phy *mpt2sas_phy;
+        Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
+        Mpi2SasPhyPage0_t phy_pg0;
+        Mpi2ConfigReply_t mpi_reply;
+        u16 ioc_status;
+        u16 sz;
+        int i;
+        int rc = 0;
+
+        mpt2sas_phy = _transport_find_local_phy(ioc, phy);
+
+        if (!mpt2sas_phy) /* this phy not on sas_host */
+                return -EINVAL;
+
+        if (!rates->minimum_linkrate)
+                rates->minimum_linkrate = phy->minimum_linkrate;
+        else if (rates->minimum_linkrate < phy->minimum_linkrate_hw)
+                rates->minimum_linkrate = phy->minimum_linkrate_hw;
+
+        if (!rates->maximum_linkrate)
+                rates->maximum_linkrate = phy->maximum_linkrate;
+        else if (rates->maximum_linkrate > phy->maximum_linkrate_hw)
+                rates->maximum_linkrate = phy->maximum_linkrate_hw;
+
+        /* sas_iounit page 1 */
+        sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
+            sizeof(Mpi2SasIOUnit1PhyData_t));
+        sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
+        if (!sas_iounit_pg1) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -ENOMEM;
+                goto out;
+        }
+        if ((mpt2sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
+            sas_iounit_pg1, sz))) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -ENXIO;
+                goto out;
+        }
+        ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
+            MPI2_IOCSTATUS_MASK;
+        if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -EIO;
+                goto out;
+        }
+
+        for (i = 0; i < ioc->sas_hba.num_phys; i++) {
+                if (mpt2sas_phy->phy_id != i) {
+                        sas_iounit_pg1->PhyData[i].MaxMinLinkRate =
+                            (ioc->sas_hba.phy[i].phy->minimum_linkrate +
+                            (ioc->sas_hba.phy[i].phy->maximum_linkrate << 4));
+                } else {
+                        sas_iounit_pg1->PhyData[i].MaxMinLinkRate =
+                            (rates->minimum_linkrate +
+                            (rates->maximum_linkrate << 4));
+                }
+        }
+
+        if (mpt2sas_config_set_sas_iounit_pg1(ioc, &mpi_reply, sas_iounit_pg1,
+            sz)) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -ENXIO;
+                goto out;
+        }
+
+        /* link reset */
+        _transport_phy_reset(phy, 0);
+
+        /* read phy page 0, then update the rates in the sas transport phy */
+        if (!mpt2sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
+            mpt2sas_phy->phy_id)) {
+                phy->minimum_linkrate = _transport_convert_phy_link_rate(
+                    phy_pg0.ProgrammedLinkRate & MPI2_SAS_PRATE_MIN_RATE_MASK);
+                phy->maximum_linkrate = _transport_convert_phy_link_rate(
+                    phy_pg0.ProgrammedLinkRate >> 4);
+                phy->negotiated_linkrate = _transport_convert_phy_link_rate(
+                    phy_pg0.NegotiatedLinkRate &
+                    MPI2_SAS_NEG_LINK_RATE_MASK_PHYSICAL);
+        }
+
+ out:
+        kfree(sas_iounit_pg1);
+        return rc;
+}
+
+
+/**
  * _transport_smp_handler - transport portal for smp passthru
  * @shost: shost object
  * @rphy: sas transport rphy object
@@ -1126,7 +1283,7 @@ _transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         dma_addr_out = pci_map_single(ioc->pdev, bio_data(req->bio),
                 blk_rq_bytes(req), PCI_DMA_BIDIRECTIONAL);
         if (!dma_addr_out) {
-                mpt2sas_base_free_smid(ioc, le16_to_cpu(smid));
+                mpt2sas_base_free_smid(ioc, smid);
                 goto unmap;
         }
 
@@ -1144,7 +1301,7 @@ _transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         dma_addr_in = pci_map_single(ioc->pdev, bio_data(rsp->bio),
                                      blk_rq_bytes(rsp), PCI_DMA_BIDIRECTIONAL);
         if (!dma_addr_in) {
-                mpt2sas_base_free_smid(ioc, le16_to_cpu(smid));
+                mpt2sas_base_free_smid(ioc, smid);
                 goto unmap;
         }
 
@@ -1217,6 +1374,8 @@ struct sas_function_template mpt2sas_transport_functions = {
         .get_enclosure_identifier = _transport_get_enclosure_identifier,
         .get_bay_identifier     = _transport_get_bay_identifier,
         .phy_reset              = _transport_phy_reset,
+        .phy_enable             = _transport_phy_enable,
+        .set_phy_speed          = _transport_phy_speed,
         .smp_handler            = _transport_smp_handler,
 };
 
diff --git a/drivers/scsi/mvme16x_scsi.c b/drivers/scsi/mvme16x_scsi.c
index b5fbfd6ce870..39f554f5f261 100644
--- a/drivers/scsi/mvme16x_scsi.c
+++ b/drivers/scsi/mvme16x_scsi.c
@@ -12,6 +12,7 @@
 #include <linux/platform_device.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
+#include <linux/slab.h>
 #include <asm/mvme16xhw.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
diff --git a/drivers/scsi/mvsas/mv_init.c b/drivers/scsi/mvsas/mv_init.c
index c790d45876c4..cae6b2cf492f 100644
--- a/drivers/scsi/mvsas/mv_init.c
+++ b/drivers/scsi/mvsas/mv_init.c
@@ -657,6 +657,7 @@ static struct pci_device_id __devinitdata mvs_pci_table[] = {
         { PCI_VDEVICE(MARVELL, 0x9180), chip_9180 },
         { PCI_VDEVICE(ARECA, PCI_DEVICE_ID_ARECA_1300), chip_1300 },
         { PCI_VDEVICE(ARECA, PCI_DEVICE_ID_ARECA_1320), chip_1320 },
+        { PCI_VDEVICE(ADAPTEC2, 0x0450), chip_6440 },
 
         { }     /* terminate list */
 };
diff --git a/drivers/scsi/mvsas/mv_sas.h b/drivers/scsi/mvsas/mv_sas.h
index aa2270af1bac..885858bcc403 100644
--- a/drivers/scsi/mvsas/mv_sas.h
+++ b/drivers/scsi/mvsas/mv_sas.h
@@ -36,6 +36,7 @@
 #include <linux/platform_device.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
+#include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <scsi/libsas.h>
 #include <scsi/scsi_tcq.h>
diff --git a/drivers/scsi/ncr53c8xx.c b/drivers/scsi/ncr53c8xx.c
index e3c482aa87b5..d013a2aa2fd5 100644
--- a/drivers/scsi/ncr53c8xx.c
+++ b/drivers/scsi/ncr53c8xx.c
@@ -98,6 +98,7 @@
 #include <linux/delay.h>
 #include <linux/dma-mapping.h>
 #include <linux/errno.h>
+#include <linux/gfp.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/ioport.h>
@@ -6495,7 +6496,7 @@ static void ncr_int_ma (struct ncb *np)
         **      we force a SIR_NEGO_PROTO interrupt (it is a hack that avoids 
         **      bloat for such a should_not_happen situation).
         **      In all other situation, we reset the BUS.
-        **      Are these assumptions reasonnable ? (Wait and see ...)
+        **      Are these assumptions reasonable ? (Wait and see ...)
         */
 unexpected_phase:
         dsp -= 8;
diff --git a/drivers/scsi/nsp32.c b/drivers/scsi/nsp32.c
index 2be7d5b018d2..4c1e54545200 100644
--- a/drivers/scsi/nsp32.c
+++ b/drivers/scsi/nsp32.c
@@ -26,7 +26,6 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
-#include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/timer.h>
 #include <linux/ioport.h>
@@ -1419,7 +1418,7 @@ static irqreturn_t do_nsp32_isr(int irq, void *dev_id)
                 nsp32_msg(KERN_ERR, "Received unexpected BMCNTERR IRQ! ");
                 /*
                  * TODO: To be implemented improving bus master
-                 * transfer reliablity when BMCNTERR is occurred in
+                 * transfer reliability when BMCNTERR is occurred in
                  * AutoSCSI phase described in specification.
                  */
         }
diff --git a/drivers/scsi/osd/osd_initiator.c b/drivers/scsi/osd/osd_initiator.c
index 7a117c18114c..ee4b6914667f 100644
--- a/drivers/scsi/osd/osd_initiator.c
+++ b/drivers/scsi/osd/osd_initiator.c
@@ -39,6 +39,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <linux/slab.h>
+
 #include <scsi/osd_initiator.h>
 #include <scsi/osd_sec.h>
 #include <scsi/osd_attributes.h>
@@ -73,7 +75,8 @@ static const char *_osd_ver_desc(struct osd_request *or)
 
 #define ATTR_DEF_RI(id, len) ATTR_DEF(OSD_APAGE_ROOT_INFORMATION, id, len)
 
-static int _osd_print_system_info(struct osd_dev *od, void *caps)
+static int _osd_get_print_system_info(struct osd_dev *od,
+        void *caps, struct osd_dev_info *odi)
 {
         struct osd_request *or;
         struct osd_attr get_attrs[] = {
@@ -137,8 +140,12 @@ static int _osd_print_system_info(struct osd_dev *od, void *caps)
         OSD_INFO("PRODUCT_SERIAL_NUMBER  [%s]\n",
                 (char *)pFirst);
 
-        pFirst = get_attrs[a].val_ptr;
-        OSD_INFO("OSD_NAME               [%s]\n", (char *)pFirst);
+        odi->osdname_len = get_attrs[a].len;
+        /* Avoid NULL for memcmp optimization 0-length is good enough */
+        odi->osdname = kzalloc(odi->osdname_len + 1, GFP_KERNEL);
+        if (odi->osdname_len)
+                memcpy(odi->osdname, get_attrs[a].val_ptr, odi->osdname_len);
+        OSD_INFO("OSD_NAME               [%s]\n", odi->osdname);
         a++;
 
         pFirst = get_attrs[a++].val_ptr;
@@ -171,6 +178,14 @@ static int _osd_print_system_info(struct osd_dev *od, void *caps)
                                    sid_dump, sizeof(sid_dump), true);
                 OSD_INFO("OSD_SYSTEM_ID(%d)\n"
                          "        [%s]\n", len, sid_dump);
+
+                if (unlikely(len > sizeof(odi->systemid))) {
+                        OSD_ERR("OSD Target error: OSD_SYSTEM_ID too long(%d). "
+                                "device idetification might not work\n", len);
+                        len = sizeof(odi->systemid);
+                }
+                odi->systemid_len = len;
+                memcpy(odi->systemid, get_attrs[a].val_ptr, len);
                 a++;
         }
 out:
@@ -178,16 +193,17 @@ out:
         return ret;
 }
 
-int osd_auto_detect_ver(struct osd_dev *od, void *caps)
+int osd_auto_detect_ver(struct osd_dev *od,
+        void *caps, struct osd_dev_info *odi)
 {
         int ret;
 
         /* Auto-detect the osd version */
-        ret = _osd_print_system_info(od, caps);
+        ret = _osd_get_print_system_info(od, caps, odi);
         if (ret) {
                 osd_dev_set_ver(od, OSD_VER1);
                 OSD_DEBUG("converting to OSD1\n");
-                ret = _osd_print_system_info(od, caps);
+                ret = _osd_get_print_system_info(od, caps, odi);
         }
 
         return ret;
@@ -418,30 +434,23 @@ static void _osd_free_seg(struct osd_request *or __unused,
         seg->alloc_size = 0;
 }
 
-static void _put_request(struct request *rq , bool is_async)
+static void _put_request(struct request *rq)
 {
-        if (is_async) {
-                WARN_ON(rq->bio);
-                __blk_put_request(rq->q, rq);
-        } else {
-                /*
-                 * If osd_finalize_request() was called but the request was not
-                 * executed through the block layer, then we must release BIOs.
-                 * TODO: Keep error code in or->async_error. Need to audit all
-                 *       code paths.
-                 */
-                if (unlikely(rq->bio))
-                        blk_end_request(rq, -ENOMEM, blk_rq_bytes(rq));
-                else
-                        blk_put_request(rq);
-        }
+        /*
+         * If osd_finalize_request() was called but the request was not
+         * executed through the block layer, then we must release BIOs.
+         * TODO: Keep error code in or->async_error. Need to audit all
+         *       code paths.
+         */
+        if (unlikely(rq->bio))
+                blk_end_request(rq, -ENOMEM, blk_rq_bytes(rq));
+        else
+                blk_put_request(rq);
 }
 
 void osd_end_request(struct osd_request *or)
 {
         struct request *rq = or->request;
-        /* IMPORTANT: make sure this agrees with osd_execute_request_async */
-        bool is_async = (or->request->end_io_data == or);
 
         _osd_free_seg(or, &or->set_attr);
         _osd_free_seg(or, &or->enc_get_attr);
@@ -449,19 +458,34 @@ void osd_end_request(struct osd_request *or)
 
         if (rq) {
                 if (rq->next_rq) {
-                        _put_request(rq->next_rq, is_async);
+                        _put_request(rq->next_rq);
                         rq->next_rq = NULL;
                 }
 
-                _put_request(rq, is_async);
+                _put_request(rq);
         }
         _osd_request_free(or);
 }
 EXPORT_SYMBOL(osd_end_request);
 
+static void _set_error_resid(struct osd_request *or, struct request *req,
+                             int error)
+{
+        or->async_error = error;
+        or->req_errors = req->errors ? : error;
+        or->sense_len = req->sense_len;
+        if (or->out.req)
+                or->out.residual = or->out.req->resid_len;
+        if (or->in.req)
+                or->in.residual = or->in.req->resid_len;
+}
+
 int osd_execute_request(struct osd_request *or)
 {
-        return blk_execute_rq(or->request->q, NULL, or->request, 0);
+        int error = blk_execute_rq(or->request->q, NULL, or->request, 0);
+
+        _set_error_resid(or, or->request, error);
+        return error;
 }
 EXPORT_SYMBOL(osd_execute_request);
 
@@ -469,10 +493,16 @@ static void osd_request_async_done(struct request *req, int error)
 {
         struct osd_request *or = req->end_io_data;
 
-        or->async_error = error;
+        _set_error_resid(or, req, error);
+        if (req->next_rq) {
+                __blk_put_request(req->q, req->next_rq);
+                req->next_rq = NULL;
+        }
 
-        if (error)
-                OSD_DEBUG("osd_request_async_done error recieved %d\n", error);
+        __blk_put_request(req->q, req);
+        or->request = NULL;
+        or->in.req = NULL;
+        or->out.req = NULL;
 
         if (or->async_done)
                 or->async_done(or, or->async_private);
@@ -1153,6 +1183,7 @@ int osd_req_decode_get_attr_list(struct osd_request *or,
                                 "c=%d r=%d n=%d\n",
                                 cur_bytes, returned_bytes, n);
                         oa->val_ptr = NULL;
+                        cur_bytes = returned_bytes; /* break the caller loop */
                         break;
                 }
 
@@ -1404,6 +1435,10 @@ int osd_finalize_request(struct osd_request *or,
         cdbh->command_specific_options |= or->attributes_mode;
         if (or->attributes_mode == OSD_CDB_GET_ATTR_PAGE_SET_ONE) {
                 ret = _osd_req_finalize_attr_page(or);
+                if (ret) {
+                        OSD_DEBUG("_osd_req_finalize_attr_page failed\n");
+                        return ret;
+                }
         } else {
                 /* TODO: I think that for the GET_ATTR command these 2 should
                  * be reversed to keep them in execution order (for embeded
@@ -1436,6 +1471,15 @@ int osd_finalize_request(struct osd_request *or,
 }
 EXPORT_SYMBOL(osd_finalize_request);
 
+static bool _is_osd_security_code(int code)
+{
+        return  (code == osd_security_audit_value_frozen) ||
+                (code == osd_security_working_key_frozen) ||
+                (code == osd_nonce_not_unique) ||
+                (code == osd_nonce_timestamp_out_of_range) ||
+                (code == osd_invalid_dataout_buffer_integrity_check_value);
+}
+
 #define OSD_SENSE_PRINT1(fmt, a...) \
         do { \
                 if (__cur_sense_need_output) \
@@ -1458,27 +1502,29 @@ int osd_req_decode_sense_full(struct osd_request *or,
 #else
         bool __cur_sense_need_output = !silent;
 #endif
+        int ret;
 
-        if (!or->request->errors)
+        if (likely(!or->req_errors))
                 return 0;
 
-        ssdb = or->request->sense;
-        sense_len = or->request->sense_len;
+        osi = osi ? : &local_osi;
+        memset(osi, 0, sizeof(*osi));
+
+        ssdb = (typeof(ssdb))or->sense;
+        sense_len = or->sense_len;
         if ((sense_len < (int)sizeof(*ssdb) || !ssdb->sense_key)) {
                 OSD_ERR("Block-layer returned error(0x%x) but "
                         "sense_len(%u) || key(%d) is empty\n",
-                        or->request->errors, sense_len, ssdb->sense_key);
-                return -EIO;
+                        or->req_errors, sense_len, ssdb->sense_key);
+                goto analyze;
         }
 
         if ((ssdb->response_code != 0x72) && (ssdb->response_code != 0x73)) {
                 OSD_ERR("Unrecognized scsi sense: rcode=%x length=%d\n",
                         ssdb->response_code, sense_len);
-                return -EIO;
+                goto analyze;
         }
 
-        osi = osi ? : &local_osi;
-        memset(osi, 0, sizeof(*osi));
         osi->key = ssdb->sense_key;
         osi->additional_code = be16_to_cpu(ssdb->additional_sense_code);
         original_sense_len = ssdb->additional_sense_length + 8;
@@ -1488,9 +1534,10 @@ int osd_req_decode_sense_full(struct osd_request *or,
                 __cur_sense_need_output = (osi->key > scsi_sk_recovered_error);
 #endif
         OSD_SENSE_PRINT1("Main Sense information key=0x%x length(%d, %d) "
-                        "additional_code=0x%x\n",
+                        "additional_code=0x%x async_error=%d errors=0x%x\n",
                         osi->key, original_sense_len, sense_len,
-                        osi->additional_code);
+                        osi->additional_code, or->async_error,
+                        or->req_errors);
 
         if (original_sense_len < sense_len)
                 sense_len = original_sense_len;
@@ -1569,15 +1616,14 @@ int osd_req_decode_sense_full(struct osd_request *or,
                 {
                         struct osd_sense_attributes_data_descriptor
                                 *osadd = cur_descriptor;
-                        int len = min(cur_len, sense_len);
-                        int i = 0;
+                        unsigned len = min(cur_len, sense_len);
                         struct osd_sense_attr *pattr = osadd->sense_attrs;
 
-                        while (len < 0) {
+                        while (len >= sizeof(*pattr)) {
                                 u32 attr_page = be32_to_cpu(pattr->attr_page);
                                 u32 attr_id = be32_to_cpu(pattr->attr_id);
 
-                                if (i++ == 0) {
+                                if (!osi->attr.attr_page) {
                                         osi->attr.attr_page = attr_page;
                                         osi->attr.attr_id = attr_id;
                                 }
@@ -1588,6 +1634,8 @@ int osd_req_decode_sense_full(struct osd_request *or,
                                         bad_attr_list++;
                                         max_attr--;
                                 }
+
+                                len -= sizeof(*pattr);
                                 OSD_SENSE_PRINT2(
                                         "osd_sense_attribute_identification"
                                         "attr_page=0x%x attr_id=0x%x\n",
@@ -1621,7 +1669,50 @@ int osd_req_decode_sense_full(struct osd_request *or,
                 cur_descriptor += cur_len;
         }
 
-        return (osi->key > scsi_sk_recovered_error) ? -EIO : 0;
+analyze:
+        if (!osi->key) {
+                /* scsi sense is Empty, the request was never issued to target
+                 * linux return code might tell us what happened.
+                 */
+                if (or->async_error == -ENOMEM)
+                        osi->osd_err_pri = OSD_ERR_PRI_RESOURCE;
+                else
+                        osi->osd_err_pri = OSD_ERR_PRI_UNREACHABLE;
+                ret = or->async_error;
+        } else if (osi->key <= scsi_sk_recovered_error) {
+                osi->osd_err_pri = 0;
+                ret = 0;
+        } else if (osi->additional_code == scsi_invalid_field_in_cdb) {
+                if (osi->cdb_field_offset == OSD_CFO_STARTING_BYTE) {
+                        osi->osd_err_pri = OSD_ERR_PRI_CLEAR_PAGES;
+                        ret = -EFAULT; /* caller should recover from this */
+                } else if (osi->cdb_field_offset == OSD_CFO_OBJECT_ID) {
+                        osi->osd_err_pri = OSD_ERR_PRI_NOT_FOUND;
+                        ret = -ENOENT;
+                } else if (osi->cdb_field_offset == OSD_CFO_PERMISSIONS) {
+                        osi->osd_err_pri = OSD_ERR_PRI_NO_ACCESS;
+                        ret = -EACCES;
+                } else {
+                        osi->osd_err_pri = OSD_ERR_PRI_BAD_CRED;
+                        ret = -EINVAL;
+                }
+        } else if (osi->additional_code == osd_quota_error) {
+                osi->osd_err_pri = OSD_ERR_PRI_NO_SPACE;
+                ret = -ENOSPC;
+        } else if (_is_osd_security_code(osi->additional_code)) {
+                osi->osd_err_pri = OSD_ERR_PRI_BAD_CRED;
+                ret = -EINVAL;
+        } else {
+                osi->osd_err_pri = OSD_ERR_PRI_EIO;
+                ret = -EIO;
+        }
+
+        if (!or->out.residual)
+                or->out.residual = or->out.total_bytes;
+        if (!or->in.residual)
+                or->in.residual = or->in.total_bytes;
+
+        return ret;
 }
 EXPORT_SYMBOL(osd_req_decode_sense_full);
 
diff --git a/drivers/scsi/osd/osd_uld.c b/drivers/scsi/osd/osd_uld.c
index 0bdef3390902..ffdd9fdb9995 100644
--- a/drivers/scsi/osd/osd_uld.c
+++ b/drivers/scsi/osd/osd_uld.c
@@ -50,6 +50,7 @@
 #include <linux/idr.h>
 #include <linux/major.h>
 #include <linux/file.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_driver.h>
@@ -71,8 +72,7 @@
 #define SCSI_OSD_MAX_MINOR 64
 
 static const char osd_name[] = "osd";
-static const char *osd_version_string = "open-osd 0.1.0";
-const char osd_symlink[] = "scsi_osd";
+static const char *osd_version_string = "open-osd 0.2.0";
 
 MODULE_AUTHOR("Boaz Harrosh <bharrosh@panasas.com>");
 MODULE_DESCRIPTION("open-osd Upper-Layer-Driver osd.ko");
@@ -82,15 +82,25 @@ MODULE_ALIAS_SCSI_DEVICE(TYPE_OSD);
 
 struct osd_uld_device {
         int minor;
-        struct kref kref;
+        struct device class_dev;
         struct cdev cdev;
         struct osd_dev od;
+        struct osd_dev_info odi;
         struct gendisk *disk;
-        struct device *class_member;
 };
 
-static void __uld_get(struct osd_uld_device *oud);
-static void __uld_put(struct osd_uld_device *oud);
+struct osd_dev_handle {
+        struct osd_dev od;
+        struct file *file;
+        struct osd_uld_device *oud;
+} ;
+
+static DEFINE_IDA(osd_minor_ida);
+
+static struct class osd_uld_class = {
+        .owner          = THIS_MODULE,
+        .name           = "scsi_osd",
+};
 
 /*
  * Char Device operations
@@ -101,7 +111,7 @@ static int osd_uld_open(struct inode *inode, struct file *file)
         struct osd_uld_device *oud = container_of(inode->i_cdev,
                                         struct osd_uld_device, cdev);
 
-        __uld_get(oud);
+        get_device(&oud->class_dev);
         /* cache osd_uld_device on file handle */
         file->private_data = oud;
         OSD_DEBUG("osd_uld_open %p\n", oud);
@@ -114,7 +124,7 @@ static int osd_uld_release(struct inode *inode, struct file *file)
 
         OSD_DEBUG("osd_uld_release %p\n", file->private_data);
         file->private_data = NULL;
-        __uld_put(oud);
+        put_device(&oud->class_dev);
         return 0;
 }
 
@@ -177,7 +187,7 @@ static const struct file_operations osd_fops = {
 struct osd_dev *osduld_path_lookup(const char *name)
 {
         struct osd_uld_device *oud;
-        struct osd_dev *od;
+        struct osd_dev_handle *odh;
         struct file *file;
         int error;
 
@@ -186,8 +196,8 @@ struct osd_dev *osduld_path_lookup(const char *name)
                 return ERR_PTR(-EINVAL);
         }
 
-        od = kzalloc(sizeof(*od), GFP_KERNEL);
-        if (!od)
+        odh = kzalloc(sizeof(*odh), GFP_KERNEL);
+        if (unlikely(!odh))
                 return ERR_PTR(-ENOMEM);
 
         file = filp_open(name, O_RDWR, 0);
@@ -203,33 +213,134 @@ struct osd_dev *osduld_path_lookup(const char *name)
 
         oud = file->private_data;
 
-        *od = oud->od;
-        od->file = file;
+        odh->od = oud->od;
+        odh->file = file;
+        odh->oud = oud;
 
-        return od;
+        return &odh->od;
 
 close_file:
         fput(file);
 free_od:
-        kfree(od);
+        kfree(odh);
         return ERR_PTR(error);
 }
 EXPORT_SYMBOL(osduld_path_lookup);
 
-void osduld_put_device(struct osd_dev *od)
+static inline bool _the_same_or_null(const u8 *a1, unsigned a1_len,
+                                     const u8 *a2, unsigned a2_len)
 {
+        if (!a2_len) /* User string is Empty means don't care */
+                return true;
+
+        if (a1_len != a2_len)
+                return false;
+
+        return 0 == memcmp(a1, a2, a1_len);
+}
+
+struct find_oud_t {
+        const struct osd_dev_info *odi;
+        struct device *dev;
+        struct osd_uld_device *oud;
+} ;
+
+int _mach_odi(struct device *dev, void *find_data)
+{
+        struct osd_uld_device *oud = container_of(dev, struct osd_uld_device,
+                                                  class_dev);
+        struct find_oud_t *fot = find_data;
+        const struct osd_dev_info *odi = fot->odi;
+
+        if (_the_same_or_null(oud->odi.systemid, oud->odi.systemid_len,
+                              odi->systemid, odi->systemid_len) &&
+            _the_same_or_null(oud->odi.osdname, oud->odi.osdname_len,
+                              odi->osdname, odi->osdname_len)) {
+                OSD_DEBUG("found device sysid_len=%d osdname=%d\n",
+                          odi->systemid_len, odi->osdname_len);
+                fot->oud = oud;
+                return 1;
+        } else {
+                return 0;
+        }
+}
+
+/* osduld_info_lookup - Loop through all devices, return the requested osd_dev.
+ *
+ * if @odi->systemid_len and/or @odi->osdname_len are zero, they act as a don't
+ * care. .e.g if they're both zero /dev/osd0 is returned.
+ */
+struct osd_dev *osduld_info_lookup(const struct osd_dev_info *odi)
+{
+        struct find_oud_t find = {.odi = odi};
+
+        find.dev = class_find_device(&osd_uld_class, NULL, &find, _mach_odi);
+        if (likely(find.dev)) {
+                struct osd_dev_handle *odh = kzalloc(sizeof(*odh), GFP_KERNEL);
+
+                if (unlikely(!odh)) {
+                        put_device(find.dev);
+                        return ERR_PTR(-ENOMEM);
+                }
 
+                odh->od = find.oud->od;
+                odh->oud = find.oud;
+
+                return &odh->od;
+        }
+
+        return ERR_PTR(-ENODEV);
+}
+EXPORT_SYMBOL(osduld_info_lookup);
+
+void osduld_put_device(struct osd_dev *od)
+{
         if (od && !IS_ERR(od)) {
-                struct osd_uld_device *oud = od->file->private_data;
+                struct osd_dev_handle *odh =
+                                container_of(od, struct osd_dev_handle, od);
+                struct osd_uld_device *oud = odh->oud;
 
                 BUG_ON(od->scsi_device != oud->od.scsi_device);
 
-                fput(od->file);
-                kfree(od);
+                /* If scsi has released the device (logout), and exofs has last
+                 * reference on oud it will be freed by above osd_uld_release
+                 * within fput below. But this will oops in cdev_release which
+                 * is called after the fops->release. A get_/put_ pair makes
+                 * sure we have a cdev for the duration of fput
+                 */
+                if (odh->file) {
+                        get_device(&oud->class_dev);
+                        fput(odh->file);
+                }
+                put_device(&oud->class_dev);
+                kfree(odh);
         }
 }
 EXPORT_SYMBOL(osduld_put_device);
 
+const struct osd_dev_info *osduld_device_info(struct osd_dev *od)
+{
+        struct osd_dev_handle *odh =
+                                container_of(od, struct osd_dev_handle, od);
+        return &odh->oud->odi;
+}
+EXPORT_SYMBOL(osduld_device_info);
+
+bool osduld_device_same(struct osd_dev *od, const struct osd_dev_info *odi)
+{
+        struct osd_dev_handle *odh =
+                                container_of(od, struct osd_dev_handle, od);
+        struct osd_uld_device *oud = odh->oud;
+
+        return (oud->odi.systemid_len == odi->systemid_len) &&
+                _the_same_or_null(oud->odi.systemid, oud->odi.systemid_len,
+                                 odi->systemid, odi->systemid_len) &&
+                (oud->odi.osdname_len == odi->osdname_len) &&
+                _the_same_or_null(oud->odi.osdname, oud->odi.osdname_len,
+                                  odi->osdname, odi->osdname_len);
+}
+EXPORT_SYMBOL(osduld_device_same);
+
 /*
  * Scsi Device operations
  */
@@ -250,14 +361,35 @@ static int __detect_osd(struct osd_uld_device *oud)
                 OSD_ERR("warning: scsi_test_unit_ready failed\n");
 
         osd_sec_init_nosec_doall_caps(caps, &osd_root_object, false, true);
-        if (osd_auto_detect_ver(&oud->od, caps))
+        if (osd_auto_detect_ver(&oud->od, caps, &oud->odi))
                 return -ENODEV;
 
         return 0;
 }
 
-static struct class *osd_sysfs_class;
-static DEFINE_IDA(osd_minor_ida);
+static void __remove(struct device *dev)
+{
+        struct osd_uld_device *oud = container_of(dev, struct osd_uld_device,
+                                                  class_dev);
+        struct scsi_device *scsi_device = oud->od.scsi_device;
+
+        kfree(oud->odi.osdname);
+
+        if (oud->cdev.owner)
+                cdev_del(&oud->cdev);
+
+        osd_dev_fini(&oud->od);
+        scsi_device_put(scsi_device);
+
+        OSD_INFO("osd_remove %s\n",
+                 oud->disk ? oud->disk->disk_name : NULL);
+
+        if (oud->disk)
+                put_disk(oud->disk);
+        ida_remove(&osd_minor_ida, oud->minor);
+
+        kfree(oud);
+}
 
 static int osd_probe(struct device *dev)
 {
@@ -289,7 +421,6 @@ static int osd_probe(struct device *dev)
         if (NULL == oud)
                 goto err_retract_minor;
 
-        kref_init(&oud->kref);
         dev_set_drvdata(dev, oud);
         oud->minor = minor;
 
@@ -327,18 +458,25 @@ static int osd_probe(struct device *dev)
                 OSD_ERR("cdev_add failed\n");
                 goto err_put_disk;
         }
-        kobject_get(&oud->cdev.kobj); /* 2nd ref see osd_remove() */
-
-        /* class_member */
-        oud->class_member = device_create(osd_sysfs_class, dev,
-                MKDEV(SCSI_OSD_MAJOR, oud->minor), "%s", disk->disk_name);
-        if (IS_ERR(oud->class_member)) {
-                OSD_ERR("class_device_create failed\n");
-                error = PTR_ERR(oud->class_member);
+
+        /* class device member */
+        oud->class_dev.devt = oud->cdev.dev;
+        oud->class_dev.class = &osd_uld_class;
+        oud->class_dev.parent = dev;
+        oud->class_dev.release = __remove;
+        error = dev_set_name(&oud->class_dev, disk->disk_name);
+        if (error) {
+                OSD_ERR("dev_set_name failed => %d\n", error);
+                goto err_put_cdev;
+        }
+
+        error = device_register(&oud->class_dev);
+        if (error) {
+                OSD_ERR("device_register failed => %d\n", error);
                 goto err_put_cdev;
         }
 
-        dev_set_drvdata(oud->class_member, oud);
+        get_device(&oud->class_dev);
 
         OSD_INFO("osd_probe %s\n", disk->disk_name);
         return 0;
@@ -367,54 +505,12 @@ static int osd_remove(struct device *dev)
                         scsi_device);
         }
 
-        if (oud->class_member)
-                device_destroy(osd_sysfs_class,
-                               MKDEV(SCSI_OSD_MAJOR, oud->minor));
+        device_unregister(&oud->class_dev);
 
-        /* We have 2 references to the cdev. One is released here
-         * and also takes down the /dev/osdX mapping. The second
-         * Will be released in __remove() after all users have released
-         * the osd_uld_device.
-         */
-        if (oud->cdev.owner)
-                cdev_del(&oud->cdev);
-
-        __uld_put(oud);
+        put_device(&oud->class_dev);
         return 0;
 }
 
-static void __remove(struct kref *kref)
-{
-        struct osd_uld_device *oud = container_of(kref,
-                                        struct osd_uld_device, kref);
-        struct scsi_device *scsi_device = oud->od.scsi_device;
-
-        /* now let delete the char_dev */
-        kobject_put(&oud->cdev.kobj);
-
-        osd_dev_fini(&oud->od);
-        scsi_device_put(scsi_device);
-
-        OSD_INFO("osd_remove %s\n",
-                 oud->disk ? oud->disk->disk_name : NULL);
-
-        if (oud->disk)
-                put_disk(oud->disk);
-
-        ida_remove(&osd_minor_ida, oud->minor);
-        kfree(oud);
-}
-
-static void __uld_get(struct osd_uld_device *oud)
-{
-        kref_get(&oud->kref);
-}
-
-static void __uld_put(struct osd_uld_device *oud)
-{
-        kref_put(&oud->kref, __remove);
-}
-
 /*
  * Global driver and scsi registration
  */
@@ -432,11 +528,10 @@ static int __init osd_uld_init(void)
 {
         int err;
 
-        osd_sysfs_class = class_create(THIS_MODULE, osd_symlink);
-        if (IS_ERR(osd_sysfs_class)) {
-                OSD_ERR("Unable to register sysfs class => %ld\n",
-                        PTR_ERR(osd_sysfs_class));
-                return PTR_ERR(osd_sysfs_class);
+        err = class_register(&osd_uld_class);
+        if (err) {
+                OSD_ERR("Unable to register sysfs class => %d\n", err);
+                return err;
         }
 
         err = register_chrdev_region(MKDEV(SCSI_OSD_MAJOR, 0),
@@ -459,7 +554,7 @@ static int __init osd_uld_init(void)
 err_out_chrdev:
         unregister_chrdev_region(MKDEV(SCSI_OSD_MAJOR, 0), SCSI_OSD_MAX_MINOR);
 err_out:
-        class_destroy(osd_sysfs_class);
+        class_unregister(&osd_uld_class);
         return err;
 }
 
@@ -467,7 +562,7 @@ static void __exit osd_uld_exit(void)
 {
         scsi_unregister_driver(&osd_driver.gendrv);
         unregister_chrdev_region(MKDEV(SCSI_OSD_MAJOR, 0), SCSI_OSD_MAX_MINOR);
-        class_destroy(osd_sysfs_class);
+        class_unregister(&osd_uld_class);
         OSD_INFO("UNLOADED %s\n", osd_version_string);
 }
 
diff --git a/drivers/scsi/osst.c b/drivers/scsi/osst.c
index acb835837eec..b219118f8bd6 100644
--- a/drivers/scsi/osst.c
+++ b/drivers/scsi/osst.c
@@ -38,6 +38,7 @@ static const char * osst_version = "0.99.4";
 #include <linux/sched.h>
 #include <linux/proc_fs.h>
 #include <linux/mm.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/string.h>
 #include <linux/errno.h>
diff --git a/drivers/scsi/pcmcia/aha152x_stub.c b/drivers/scsi/pcmcia/aha152x_stub.c
index 67cde0138061..528733b4a392 100644
--- a/drivers/scsi/pcmcia/aha152x_stub.c
+++ b/drivers/scsi/pcmcia/aha152x_stub.c
@@ -54,15 +54,6 @@
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
-#ifdef PCMCIA_DEBUG
-static int pc_debug = PCMCIA_DEBUG;
-module_param(pc_debug, int, 0644);
-#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
-static char *version =
-"aha152x_cs.c 1.54 2000/06/12 21:27:25 (David Hinds)";
-#else
-#define DEBUG(n, args...)
-#endif
 
 /*====================================================================*/
 
@@ -103,7 +94,7 @@ static int aha152x_probe(struct pcmcia_device *link)
 {
     scsi_info_t *info;
 
-    DEBUG(0, "aha152x_attach()\n");
+    dev_dbg(&link->dev, "aha152x_attach()\n");
 
     /* Create new SCSI device */
     info = kzalloc(sizeof(*info), GFP_KERNEL);
@@ -115,7 +106,6 @@ static int aha152x_probe(struct pcmcia_device *link)
     link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
     link->io.IOAddrLines = 10;
     link->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
-    link->irq.IRQInfo1 = IRQ_LEVEL_ID;
     link->conf.Attributes = CONF_ENABLE_IRQ;
     link->conf.IntType = INT_MEMORY_AND_IO;
     link->conf.Present = PRESENT_OPTION;
@@ -127,7 +117,7 @@ static int aha152x_probe(struct pcmcia_device *link)
 
 static void aha152x_detach(struct pcmcia_device *link)
 {
-    DEBUG(0, "aha152x_detach(0x%p)\n", link);
+    dev_dbg(&link->dev, "aha152x_detach\n");
 
     aha152x_release_cs(link);
 
@@ -137,9 +127,6 @@ static void aha152x_detach(struct pcmcia_device *link)
 
 /*====================================================================*/
 
-#define CS_CHECK(fn, ret) \
-do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
-
 static int aha152x_config_check(struct pcmcia_device *p_dev,
                                 cistpl_cftable_entry_t *cfg,
                                 cistpl_cftable_entry_t *dflt,
@@ -164,19 +151,22 @@ static int aha152x_config_cs(struct pcmcia_device *link)
 {
     scsi_info_t *info = link->priv;
     struct aha152x_setup s;
-    int last_ret, last_fn;
+    int ret;
     struct Scsi_Host *host;
 
-    DEBUG(0, "aha152x_config(0x%p)\n", link);
+    dev_dbg(&link->dev, "aha152x_config\n");
 
-    last_ret = pcmcia_loop_config(link, aha152x_config_check, NULL);
-    if (last_ret) {
-        cs_error(link, RequestIO, last_ret);
-        goto failed;
-    }
+    ret = pcmcia_loop_config(link, aha152x_config_check, NULL);
+    if (ret)
+            goto failed;
 
-    CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
-    CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
+    ret = pcmcia_request_irq(link, &link->irq);
+    if (ret)
+            goto failed;
+
+    ret = pcmcia_request_configuration(link, &link->conf);
+    if (ret)
+            goto failed;
     
     /* Set configuration options for the aha152x driver */
     memset(&s, 0, sizeof(s));
@@ -194,7 +184,7 @@ static int aha152x_config_cs(struct pcmcia_device *link)
     host = aha152x_probe_one(&s);
     if (host == NULL) {
         printk(KERN_INFO "aha152x_cs: no SCSI devices found\n");
-        goto cs_failed;
+        goto failed;
     }
 
     sprintf(info->node.dev_name, "scsi%d", host->host_no);
@@ -203,8 +193,6 @@ static int aha152x_config_cs(struct pcmcia_device *link)
 
     return 0;
 
-cs_failed:
-    cs_error(link, last_fn, last_ret);
 failed:
     aha152x_release_cs(link);
     return -ENODEV;
diff --git a/drivers/scsi/pcmcia/fdomain_stub.c b/drivers/scsi/pcmcia/fdomain_stub.c
index 06254f46a0dd..914040684079 100644
--- a/drivers/scsi/pcmcia/fdomain_stub.c
+++ b/drivers/scsi/pcmcia/fdomain_stub.c
@@ -59,16 +59,6 @@ MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
 MODULE_DESCRIPTION("Future Domain PCMCIA SCSI driver");
 MODULE_LICENSE("Dual MPL/GPL");
 
-#ifdef PCMCIA_DEBUG
-static int pc_debug = PCMCIA_DEBUG;
-module_param(pc_debug, int, 0);
-#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
-static char *version =
-"fdomain_cs.c 1.47 2001/10/13 00:08:52 (David Hinds)";
-#else
-#define DEBUG(n, args...)
-#endif
-
 /*====================================================================*/
 
 typedef struct scsi_info_t {
@@ -86,7 +76,7 @@ static int fdomain_probe(struct pcmcia_device *link)
 {
         scsi_info_t *info;
 
-        DEBUG(0, "fdomain_attach()\n");
+        dev_dbg(&link->dev, "fdomain_attach()\n");
 
         /* Create new SCSI device */
         info = kzalloc(sizeof(*info), GFP_KERNEL);
@@ -99,7 +89,6 @@ static int fdomain_probe(struct pcmcia_device *link)
         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
         link->io.IOAddrLines = 10;
         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
-        link->irq.IRQInfo1 = IRQ_LEVEL_ID;
         link->conf.Attributes = CONF_ENABLE_IRQ;
         link->conf.IntType = INT_MEMORY_AND_IO;
         link->conf.Present = PRESENT_OPTION;
@@ -111,7 +100,7 @@ static int fdomain_probe(struct pcmcia_device *link)
 
 static void fdomain_detach(struct pcmcia_device *link)
 {
-        DEBUG(0, "fdomain_detach(0x%p)\n", link);
+        dev_dbg(&link->dev, "fdomain_detach\n");
 
         fdomain_release(link);
 
@@ -120,9 +109,6 @@ static void fdomain_detach(struct pcmcia_device *link)
 
 /*====================================================================*/
 
-#define CS_CHECK(fn, ret) \
-do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
-
 static int fdomain_config_check(struct pcmcia_device *p_dev,
                                 cistpl_cftable_entry_t *cfg,
                                 cistpl_cftable_entry_t *dflt,
@@ -137,20 +123,22 @@ static int fdomain_config_check(struct pcmcia_device *p_dev,
 static int fdomain_config(struct pcmcia_device *link)
 {
     scsi_info_t *info = link->priv;
-    int last_ret, last_fn;
+    int ret;
     char str[22];
     struct Scsi_Host *host;
 
-    DEBUG(0, "fdomain_config(0x%p)\n", link);
+    dev_dbg(&link->dev, "fdomain_config\n");
 
-    last_ret = pcmcia_loop_config(link, fdomain_config_check, NULL);
-    if (last_ret) {
-            cs_error(link, RequestIO, last_ret);
+    ret = pcmcia_loop_config(link, fdomain_config_check, NULL);
+    if (ret)
             goto failed;
-    }
 
-    CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
-    CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
+    ret = pcmcia_request_irq(link, &link->irq);
+    if (ret)
+            goto failed;
+    ret = pcmcia_request_configuration(link, &link->conf);
+    if (ret)
+            goto failed;
 
     /* A bad hack... */
     release_region(link->io.BasePort1, link->io.NumPorts1);
@@ -162,11 +150,11 @@ static int fdomain_config(struct pcmcia_device *link)
     host = __fdomain_16x0_detect(&fdomain_driver_template);
     if (!host) {
         printk(KERN_INFO "fdomain_cs: no SCSI devices found\n");
-        goto cs_failed;
+        goto failed;
     }
 
     if (scsi_add_host(host, NULL))
-            goto cs_failed;
+            goto failed;
     scsi_scan_host(host);
 
     sprintf(info->node.dev_name, "scsi%d", host->host_no);
@@ -175,8 +163,6 @@ static int fdomain_config(struct pcmcia_device *link)
 
     return 0;
 
-cs_failed:
-    cs_error(link, last_fn, last_ret);
 failed:
     fdomain_release(link);
     return -ENODEV;
@@ -188,7 +174,7 @@ static void fdomain_release(struct pcmcia_device *link)
 {
         scsi_info_t *info = link->priv;
 
-        DEBUG(0, "fdomain_release(0x%p)\n", link);
+        dev_dbg(&link->dev, "fdomain_release\n");
 
         scsi_remove_host(info->host);
         pcmcia_disable_device(link);
diff --git a/drivers/scsi/pcmcia/nsp_cs.c b/drivers/scsi/pcmcia/nsp_cs.c
index e32c344d7ad8..021246454872 100644
--- a/drivers/scsi/pcmcia/nsp_cs.c
+++ b/drivers/scsi/pcmcia/nsp_cs.c
@@ -1564,12 +1564,10 @@ static int nsp_cs_probe(struct pcmcia_device *link)
         link->io.IOAddrLines     = 10;  /* not used */
 
         /* Interrupt setup */
-        link->irq.Attributes     = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
-        link->irq.IRQInfo1       = IRQ_LEVEL_ID;
+        link->irq.Attributes     = IRQ_TYPE_EXCLUSIVE;
 
         /* Interrupt handler */
         link->irq.Handler        = &nspintr;
-        link->irq.Instance       = info;
         link->irq.Attributes     |= IRQF_SHARED;
 
         /* General socket configuration */
@@ -1684,10 +1682,10 @@ static int nsp_cs_config_check(struct pcmcia_device *p_dev,
                         if (cfg_mem->req.Size < 0x1000)
                                 cfg_mem->req.Size = 0x1000;
                         cfg_mem->req.AccessSpeed = 0;
-                        if (pcmcia_request_window(&p_dev, &cfg_mem->req, &p_dev->win) != 0)
+                        if (pcmcia_request_window(p_dev, &cfg_mem->req, &p_dev->win) != 0)
                                 goto next_entry;
                         map.Page = 0; map.CardOffset = mem->win[0].card_addr;
-                        if (pcmcia_map_mem_page(p_dev->win, &map) != 0)
+                        if (pcmcia_map_mem_page(p_dev, p_dev->win, &map) != 0)
                                 goto next_entry;
 
                         cfg_mem->data->MmioAddress = (unsigned long) ioremap_nocache(cfg_mem->req.Base, cfg_mem->req.Size);
@@ -1719,6 +1717,7 @@ static int nsp_cs_config(struct pcmcia_device *link)
         cfg_mem->data = data;
 
         ret = pcmcia_loop_config(link, nsp_cs_config_check, cfg_mem);
+        if (ret)
                 goto cs_failed;
 
         if (link->conf.Attributes & CONF_ENABLE_IRQ) {
diff --git a/drivers/scsi/pcmcia/nsp_cs.h b/drivers/scsi/pcmcia/nsp_cs.h
index 7db28cd49446..8c61a4fe1db9 100644
--- a/drivers/scsi/pcmcia/nsp_cs.h
+++ b/drivers/scsi/pcmcia/nsp_cs.h
@@ -187,7 +187,7 @@
 #define S_IO            BIT(1)    /* Input/Output line from SCSI bus */
 #define S_CD            BIT(2)    /* Command/Data line from SCSI bus */
 #define S_BUSY          BIT(3)    /* Busy line from SCSI bus         */
-#define S_ACK           BIT(4)    /* Acknowlege line from SCSI bus   */
+#define S_ACK           BIT(4)    /* Acknowledge line from SCSI bus  */
 #define S_REQUEST       BIT(5)    /* Request line from SCSI bus      */
 #define S_SELECT        BIT(6)    /*                                 */
 #define S_ATN           BIT(7)    /*                                 */
diff --git a/drivers/scsi/pcmcia/qlogic_stub.c b/drivers/scsi/pcmcia/qlogic_stub.c
index 20c3e5e6d88a..f85f094870b4 100644
--- a/drivers/scsi/pcmcia/qlogic_stub.c
+++ b/drivers/scsi/pcmcia/qlogic_stub.c
@@ -62,15 +62,6 @@
 
 static char qlogic_name[] = "qlogic_cs";
 
-#ifdef PCMCIA_DEBUG
-static int pc_debug = PCMCIA_DEBUG;
-module_param(pc_debug, int, 0644);
-#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
-static char *version = "qlogic_cs.c 1.79-ac 2002/10/26 (David Hinds)";
-#else
-#define DEBUG(n, args...)
-#endif
-
 static struct scsi_host_template qlogicfas_driver_template = {
         .module                 = THIS_MODULE,
         .name                   = qlogic_name,
@@ -159,7 +150,7 @@ static int qlogic_probe(struct pcmcia_device *link)
 {
         scsi_info_t *info;
 
-        DEBUG(0, "qlogic_attach()\n");
+        dev_dbg(&link->dev, "qlogic_attach()\n");
 
         /* Create new SCSI device */
         info = kzalloc(sizeof(*info), GFP_KERNEL);
@@ -171,7 +162,6 @@ static int qlogic_probe(struct pcmcia_device *link)
         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
         link->io.IOAddrLines = 10;
         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
-        link->irq.IRQInfo1 = IRQ_LEVEL_ID;
         link->conf.Attributes = CONF_ENABLE_IRQ;
         link->conf.IntType = INT_MEMORY_AND_IO;
         link->conf.Present = PRESENT_OPTION;
@@ -183,7 +173,7 @@ static int qlogic_probe(struct pcmcia_device *link)
 
 static void qlogic_detach(struct pcmcia_device *link)
 {
-        DEBUG(0, "qlogic_detach(0x%p)\n", link);
+        dev_dbg(&link->dev, "qlogic_detach\n");
 
         qlogic_release(link);
         kfree(link->priv);
@@ -192,9 +182,6 @@ static void qlogic_detach(struct pcmcia_device *link)
 
 /*====================================================================*/
 
-#define CS_CHECK(fn, ret) \
-do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
-
 static int qlogic_config_check(struct pcmcia_device *p_dev,
                                cistpl_cftable_entry_t *cfg,
                                cistpl_cftable_entry_t *dflt,
@@ -213,19 +200,22 @@ static int qlogic_config_check(struct pcmcia_device *p_dev,
 static int qlogic_config(struct pcmcia_device * link)
 {
         scsi_info_t *info = link->priv;
-        int last_ret, last_fn;
+        int ret;
         struct Scsi_Host *host;
 
-        DEBUG(0, "qlogic_config(0x%p)\n", link);
+        dev_dbg(&link->dev, "qlogic_config\n");
 
-        last_ret = pcmcia_loop_config(link, qlogic_config_check, NULL);
-        if (last_ret) {
-                cs_error(link, RequestIO, last_ret);
+        ret = pcmcia_loop_config(link, qlogic_config_check, NULL);
+        if (ret)
+                goto failed;
+
+        ret = pcmcia_request_irq(link, &link->irq);
+        if (ret)
                 goto failed;
-        }
 
-        CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
-        CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
+        ret = pcmcia_request_configuration(link, &link->conf);
+        if (ret)
+                goto failed;
 
         if ((info->manf_id == MANFID_MACNICA) || (info->manf_id == MANFID_PIONEER) || (info->manf_id == 0x0098)) {
                 /* set ATAcmd */
@@ -244,7 +234,7 @@ static int qlogic_config(struct pcmcia_device * link)
         
         if (!host) {
                 printk(KERN_INFO "%s: no SCSI devices found\n", qlogic_name);
-                goto cs_failed;
+                goto failed;
         }
 
         sprintf(info->node.dev_name, "scsi%d", host->host_no);
@@ -253,12 +243,9 @@ static int qlogic_config(struct pcmcia_device * link)
 
         return 0;
 
-cs_failed:
-        cs_error(link, last_fn, last_ret);
-        pcmcia_disable_device(link);
 failed:
+        pcmcia_disable_device(link);
         return -ENODEV;
-
 }                               /* qlogic_config */
 
 /*====================================================================*/
@@ -267,7 +254,7 @@ static void qlogic_release(struct pcmcia_device *link)
 {
         scsi_info_t *info = link->priv;
 
-        DEBUG(0, "qlogic_release(0x%p)\n", link);
+        dev_dbg(&link->dev, "qlogic_release\n");
 
         scsi_remove_host(info->host);
 
diff --git a/drivers/scsi/pcmcia/sym53c500_cs.c b/drivers/scsi/pcmcia/sym53c500_cs.c
index b330c11a1752..e7564d8f0cbf 100644
--- a/drivers/scsi/pcmcia/sym53c500_cs.c
+++ b/drivers/scsi/pcmcia/sym53c500_cs.c
@@ -77,17 +77,6 @@
 #include <pcmcia/ds.h>
 #include <pcmcia/ciscode.h>
 
-/* ================================================================== */
-
-#ifdef PCMCIA_DEBUG
-static int pc_debug = PCMCIA_DEBUG;
-module_param(pc_debug, int, 0);
-#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
-static char *version =
-"sym53c500_cs.c 0.9c 2004/10/27 (Bob Tracy)";
-#else
-#define DEBUG(n, args...)
-#endif
 
 /* ================================================================== */
 
@@ -525,7 +514,7 @@ SYM53C500_release(struct pcmcia_device *link)
         struct scsi_info_t *info = link->priv;
         struct Scsi_Host *shost = info->host;
 
-        DEBUG(0, "SYM53C500_release(0x%p)\n", link);
+        dev_dbg(&link->dev, "SYM53C500_release\n");
 
         /*
         *  Do this before releasing/freeing resources.
@@ -697,9 +686,6 @@ static struct scsi_host_template sym53c500_driver_template = {
      .shost_attrs               = SYM53C500_shost_attrs
 };
 
-#define CS_CHECK(fn, ret) \
-do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
-
 static int SYM53C500_config_check(struct pcmcia_device *p_dev,
                                   cistpl_cftable_entry_t *cfg,
                                   cistpl_cftable_entry_t *dflt,
@@ -719,24 +705,27 @@ static int
 SYM53C500_config(struct pcmcia_device *link)
 {
         struct scsi_info_t *info = link->priv;
-        int last_ret, last_fn;
+        int ret;
         int irq_level, port_base;
         struct Scsi_Host *host;
         struct scsi_host_template *tpnt = &sym53c500_driver_template;
         struct sym53c500_data *data;
 
-        DEBUG(0, "SYM53C500_config(0x%p)\n", link);
+        dev_dbg(&link->dev, "SYM53C500_config\n");
 
         info->manf_id = link->manf_id;
 
-        last_ret = pcmcia_loop_config(link, SYM53C500_config_check, NULL);
-        if (last_ret) {
-                cs_error(link, RequestIO, last_ret);
+        ret = pcmcia_loop_config(link, SYM53C500_config_check, NULL);
+        if (ret)
+                goto failed;
+
+        ret = pcmcia_request_irq(link, &link->irq);
+        if (ret)
                 goto failed;
-        }
 
-        CS_CHECK(RequestIRQ, pcmcia_request_irq(link, &link->irq));
-        CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link, &link->conf));
+        ret = pcmcia_request_configuration(link, &link->conf);
+        if (ret)
+                goto failed;
 
         /*
         *  That's the trouble with copying liberally from another driver.
@@ -824,8 +813,6 @@ err_release:
         printk(KERN_INFO "sym53c500_cs: no SCSI devices found\n");
         return -ENODEV;
 
-cs_failed:
-        cs_error(link, last_fn, last_ret);
 failed:
         SYM53C500_release(link);
         return -ENODEV;
@@ -855,7 +842,7 @@ static int sym53c500_resume(struct pcmcia_device *link)
 static void
 SYM53C500_detach(struct pcmcia_device *link)
 {
-        DEBUG(0, "SYM53C500_detach(0x%p)\n", link);
+        dev_dbg(&link->dev, "SYM53C500_detach\n");
 
         SYM53C500_release(link);
 
@@ -868,7 +855,7 @@ SYM53C500_probe(struct pcmcia_device *link)
 {
         struct scsi_info_t *info;
 
-        DEBUG(0, "SYM53C500_attach()\n");
+        dev_dbg(&link->dev, "SYM53C500_attach()\n");
 
         /* Create new SCSI device */
         info = kzalloc(sizeof(*info), GFP_KERNEL);
@@ -880,7 +867,6 @@ SYM53C500_probe(struct pcmcia_device *link)
         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
         link->io.IOAddrLines = 10;
         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
-        link->irq.IRQInfo1 = IRQ_LEVEL_ID;
         link->conf.Attributes = CONF_ENABLE_IRQ;
         link->conf.IntType = INT_MEMORY_AND_IO;
 
diff --git a/drivers/scsi/pm8001/Makefile b/drivers/scsi/pm8001/Makefile
new file mode 100644
index 000000000000..52f04296171c
--- /dev/null
+++ b/drivers/scsi/pm8001/Makefile
@@ -0,0 +1,12 @@
+#
+# Kernel configuration file for the PM8001 SAS/SATA 8x6G based HBA driver
+#
+# Copyright (C) 2008-2009  USI Co., Ltd.
+
+
+obj-$(CONFIG_SCSI_PM8001) += pm8001.o
+pm8001-y += pm8001_init.o \
+                pm8001_sas.o  \
+                pm8001_ctl.o  \
+                pm8001_hwi.o
+
diff --git a/drivers/scsi/pm8001/pm8001_chips.h b/drivers/scsi/pm8001/pm8001_chips.h
new file mode 100644
index 000000000000..4efa4d0950e5
--- /dev/null
+++ b/drivers/scsi/pm8001/pm8001_chips.h
@@ -0,0 +1,89 @@
+/*
+ * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
+ *
+ * Copyright (c) 2008-2009 USI Co., Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ */
+
+#ifndef _PM8001_CHIPS_H_
+#define _PM8001_CHIPS_H_
+
+static inline u32 pm8001_read_32(void *virt_addr)
+{
+        return *((u32 *)virt_addr);
+}
+
+static inline void pm8001_write_32(void *addr, u32 offset, u32 val)
+{
+        *((u32 *)(addr + offset)) = val;
+}
+
+static inline u32 pm8001_cr32(struct pm8001_hba_info *pm8001_ha, u32 bar,
+                u32 offset)
+{
+        return readl(pm8001_ha->io_mem[bar].memvirtaddr + offset);
+}
+
+static inline void pm8001_cw32(struct pm8001_hba_info *pm8001_ha, u32 bar,
+                u32 addr, u32 val)
+{
+        writel(val, pm8001_ha->io_mem[bar].memvirtaddr + addr);
+}
+static inline u32 pm8001_mr32(void __iomem *addr, u32 offset)
+{
+        return readl(addr + offset);
+}
+static inline void pm8001_mw32(void __iomem *addr, u32 offset, u32 val)
+{
+        writel(val, addr + offset);
+}
+static inline u32 get_pci_bar_index(u32 pcibar)
+{
+                switch (pcibar) {
+                case 0x18:
+                case 0x1C:
+                        return 1;
+                case 0x20:
+                        return 2;
+                case 0x24:
+                        return 3;
+                default:
+                        return 0;
+        }
+}
+
+#endif  /* _PM8001_CHIPS_H_ */
+
diff --git a/drivers/scsi/pm8001/pm8001_ctl.c b/drivers/scsi/pm8001/pm8001_ctl.c
new file mode 100644
index 000000000000..45bc197bc22f
--- /dev/null
+++ b/drivers/scsi/pm8001/pm8001_ctl.c
@@ -0,0 +1,574 @@
+/*
+ * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
+ *
+ * Copyright (c) 2008-2009 USI Co., Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ */
+#include <linux/firmware.h>
+#include <linux/slab.h>
+#include "pm8001_sas.h"
+#include "pm8001_ctl.h"
+
+/* scsi host attributes */
+
+/**
+ * pm8001_ctl_mpi_interface_rev_show - MPI interface revision number
+ * @cdev: pointer to embedded class device
+ * @buf: the buffer returned
+ *
+ * A sysfs 'read-only' shost attribute.
+ */
+static ssize_t pm8001_ctl_mpi_interface_rev_show(struct device *cdev,
+        struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
+
+        return snprintf(buf, PAGE_SIZE, "%d\n",
+                pm8001_ha->main_cfg_tbl.interface_rev);
+}
+static
+DEVICE_ATTR(interface_rev, S_IRUGO, pm8001_ctl_mpi_interface_rev_show, NULL);
+
+/**
+ * pm8001_ctl_fw_version_show - firmware version
+ * @cdev: pointer to embedded class device
+ * @buf: the buffer returned
+ *
+ * A sysfs 'read-only' shost attribute.
+ */
+static ssize_t pm8001_ctl_fw_version_show(struct device *cdev,
+        struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
+
+        return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x.%02x\n",
+                       (u8)(pm8001_ha->main_cfg_tbl.firmware_rev >> 24),
+                       (u8)(pm8001_ha->main_cfg_tbl.firmware_rev >> 16),
+                       (u8)(pm8001_ha->main_cfg_tbl.firmware_rev >> 8),
+                       (u8)(pm8001_ha->main_cfg_tbl.firmware_rev));
+}
+static DEVICE_ATTR(fw_version, S_IRUGO, pm8001_ctl_fw_version_show, NULL);
+/**
+ * pm8001_ctl_max_out_io_show - max outstanding io supported
+ * @cdev: pointer to embedded class device
+ * @buf: the buffer returned
+ *
+ * A sysfs 'read-only' shost attribute.
+ */
+static ssize_t pm8001_ctl_max_out_io_show(struct device *cdev,
+        struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
+
+        return snprintf(buf, PAGE_SIZE, "%d\n",
+                        pm8001_ha->main_cfg_tbl.max_out_io);
+}
+static DEVICE_ATTR(max_out_io, S_IRUGO, pm8001_ctl_max_out_io_show, NULL);
+/**
+ * pm8001_ctl_max_devices_show - max devices support
+ * @cdev: pointer to embedded class device
+ * @buf: the buffer returned
+ *
+ * A sysfs 'read-only' shost attribute.
+ */
+static ssize_t pm8001_ctl_max_devices_show(struct device *cdev,
+        struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
+
+        return snprintf(buf, PAGE_SIZE, "%04d\n",
+                        (u16)(pm8001_ha->main_cfg_tbl.max_sgl >> 16));
+}
+static DEVICE_ATTR(max_devices, S_IRUGO, pm8001_ctl_max_devices_show, NULL);
+/**
+ * pm8001_ctl_max_sg_list_show - max sg list supported iff not 0.0 for no
+ * hardware limitation
+ * @cdev: pointer to embedded class device
+ * @buf: the buffer returned
+ *
+ * A sysfs 'read-only' shost attribute.
+ */
+static ssize_t pm8001_ctl_max_sg_list_show(struct device *cdev,
+        struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
+
+        return snprintf(buf, PAGE_SIZE, "%04d\n",
+                        pm8001_ha->main_cfg_tbl.max_sgl & 0x0000FFFF);
+}
+static DEVICE_ATTR(max_sg_list, S_IRUGO, pm8001_ctl_max_sg_list_show, NULL);
+
+#define SAS_1_0 0x1
+#define SAS_1_1 0x2
+#define SAS_2_0 0x4
+
+static ssize_t
+show_sas_spec_support_status(unsigned int mode, char *buf)
+{
+        ssize_t len = 0;
+
+        if (mode & SAS_1_1)
+                len = sprintf(buf, "%s", "SAS1.1");
+        if (mode & SAS_2_0)
+                len += sprintf(buf + len, "%s%s", len ? ", " : "", "SAS2.0");
+        len += sprintf(buf + len, "\n");
+
+        return len;
+}
+
+/**
+ * pm8001_ctl_sas_spec_support_show - sas spec supported
+ * @cdev: pointer to embedded class device
+ * @buf: the buffer returned
+ *
+ * A sysfs 'read-only' shost attribute.
+ */
+static ssize_t pm8001_ctl_sas_spec_support_show(struct device *cdev,
+        struct device_attribute *attr, char *buf)
+{
+        unsigned int mode;
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
+        mode = (pm8001_ha->main_cfg_tbl.ctrl_cap_flag & 0xfe000000)>>25;
+        return show_sas_spec_support_status(mode, buf);
+}
+static DEVICE_ATTR(sas_spec_support, S_IRUGO,
+                   pm8001_ctl_sas_spec_support_show, NULL);
+
+/**
+ * pm8001_ctl_sas_address_show - sas address
+ * @cdev: pointer to embedded class device
+ * @buf: the buffer returned
+ *
+ * This is the controller sas address
+ *
+ * A sysfs 'read-only' shost attribute.
+ */
+static ssize_t pm8001_ctl_host_sas_address_show(struct device *cdev,
+        struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
+        return snprintf(buf, PAGE_SIZE, "0x%016llx\n",
+                        be64_to_cpu(*(__be64 *)pm8001_ha->sas_addr));
+}
+static DEVICE_ATTR(host_sas_address, S_IRUGO,
+                   pm8001_ctl_host_sas_address_show, NULL);
+
+/**
+ * pm8001_ctl_logging_level_show - logging level
+ * @cdev: pointer to embedded class device
+ * @buf: the buffer returned
+ *
+ * A sysfs 'read/write' shost attribute.
+ */
+static ssize_t pm8001_ctl_logging_level_show(struct device *cdev,
+        struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
+
+        return snprintf(buf, PAGE_SIZE, "%08xh\n", pm8001_ha->logging_level);
+}
+static ssize_t pm8001_ctl_logging_level_store(struct device *cdev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
+        int val = 0;
+
+        if (sscanf(buf, "%x", &val) != 1)
+                return -EINVAL;
+
+        pm8001_ha->logging_level = val;
+        return strlen(buf);
+}
+
+static DEVICE_ATTR(logging_level, S_IRUGO | S_IWUSR,
+        pm8001_ctl_logging_level_show, pm8001_ctl_logging_level_store);
+/**
+ * pm8001_ctl_aap_log_show - aap1 event log
+ * @cdev: pointer to embedded class device
+ * @buf: the buffer returned
+ *
+ * A sysfs 'read-only' shost attribute.
+ */
+static ssize_t pm8001_ctl_aap_log_show(struct device *cdev,
+        struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
+        int i;
+#define AAP1_MEMMAP(r, c) \
+        (*(u32 *)((u8*)pm8001_ha->memoryMap.region[AAP1].virt_ptr + (r) * 32 \
+        + (c)))
+
+        char *str = buf;
+        int max = 2;
+        for (i = 0; i < max; i++) {
+                str += sprintf(str, "0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x"
+                               "0x%08x 0x%08x\n",
+                               AAP1_MEMMAP(i, 0),
+                               AAP1_MEMMAP(i, 4),
+                               AAP1_MEMMAP(i, 8),
+                               AAP1_MEMMAP(i, 12),
+                               AAP1_MEMMAP(i, 16),
+                               AAP1_MEMMAP(i, 20),
+                               AAP1_MEMMAP(i, 24),
+                               AAP1_MEMMAP(i, 28));
+        }
+
+        return str - buf;
+}
+static DEVICE_ATTR(aap_log, S_IRUGO, pm8001_ctl_aap_log_show, NULL);
+/**
+ * pm8001_ctl_aap_log_show - IOP event log
+ * @cdev: pointer to embedded class device
+ * @buf: the buffer returned
+ *
+ * A sysfs 'read-only' shost attribute.
+ */
+static ssize_t pm8001_ctl_iop_log_show(struct device *cdev,
+        struct device_attribute *attr, char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
+#define IOP_MEMMAP(r, c) \
+        (*(u32 *)((u8*)pm8001_ha->memoryMap.region[IOP].virt_ptr + (r) * 32 \
+        + (c)))
+        int i;
+        char *str = buf;
+        int max = 2;
+        for (i = 0; i < max; i++) {
+                str += sprintf(str, "0x%08x 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x"
+                               "0x%08x 0x%08x\n",
+                               IOP_MEMMAP(i, 0),
+                               IOP_MEMMAP(i, 4),
+                               IOP_MEMMAP(i, 8),
+                               IOP_MEMMAP(i, 12),
+                               IOP_MEMMAP(i, 16),
+                               IOP_MEMMAP(i, 20),
+                               IOP_MEMMAP(i, 24),
+                               IOP_MEMMAP(i, 28));
+        }
+
+        return str - buf;
+}
+static DEVICE_ATTR(iop_log, S_IRUGO, pm8001_ctl_iop_log_show, NULL);
+
+#define FLASH_CMD_NONE      0x00
+#define FLASH_CMD_UPDATE    0x01
+#define FLASH_CMD_SET_NVMD    0x02
+
+struct flash_command {
+     u8      command[8];
+     int     code;
+};
+
+static struct flash_command flash_command_table[] =
+{
+     {"set_nvmd",    FLASH_CMD_SET_NVMD},
+     {"update",      FLASH_CMD_UPDATE},
+     {"",            FLASH_CMD_NONE} /* Last entry should be NULL. */
+};
+
+struct error_fw {
+     char    *reason;
+     int     err_code;
+};
+
+static struct error_fw flash_error_table[] =
+{
+     {"Failed to open fw image file",   FAIL_OPEN_BIOS_FILE},
+     {"image header mismatch",          FLASH_UPDATE_HDR_ERR},
+     {"image offset mismatch",          FLASH_UPDATE_OFFSET_ERR},
+     {"image CRC Error",                FLASH_UPDATE_CRC_ERR},
+     {"image length Error.",            FLASH_UPDATE_LENGTH_ERR},
+     {"Failed to program flash chip",   FLASH_UPDATE_HW_ERR},
+     {"Flash chip not supported.",      FLASH_UPDATE_DNLD_NOT_SUPPORTED},
+     {"Flash update disabled.",         FLASH_UPDATE_DISABLED},
+     {"Flash in progress",              FLASH_IN_PROGRESS},
+     {"Image file size Error",          FAIL_FILE_SIZE},
+     {"Input parameter error",          FAIL_PARAMETERS},
+     {"Out of memory",                  FAIL_OUT_MEMORY},
+     {"OK", 0}  /* Last entry err_code = 0. */
+};
+
+static int pm8001_set_nvmd(struct pm8001_hba_info *pm8001_ha)
+{
+        struct pm8001_ioctl_payload     *payload;
+        DECLARE_COMPLETION_ONSTACK(completion);
+        u8              *ioctlbuffer = NULL;
+        u32             length = 0;
+        u32             ret = 0;
+
+        length = 1024 * 5 + sizeof(*payload) - 1;
+        ioctlbuffer = kzalloc(length, GFP_KERNEL);
+        if (!ioctlbuffer)
+                return -ENOMEM;
+        if ((pm8001_ha->fw_image->size <= 0) ||
+            (pm8001_ha->fw_image->size > 4096)) {
+                ret = FAIL_FILE_SIZE;
+                goto out;
+        }
+        payload = (struct pm8001_ioctl_payload *)ioctlbuffer;
+        memcpy((u8 *)payload->func_specific, (u8 *)pm8001_ha->fw_image->data,
+                                pm8001_ha->fw_image->size);
+        payload->length = pm8001_ha->fw_image->size;
+        payload->id = 0;
+        pm8001_ha->nvmd_completion = &completion;
+        ret = PM8001_CHIP_DISP->set_nvmd_req(pm8001_ha, payload);
+        wait_for_completion(&completion);
+out:
+        kfree(ioctlbuffer);
+        return ret;
+}
+
+static int pm8001_update_flash(struct pm8001_hba_info *pm8001_ha)
+{
+        struct pm8001_ioctl_payload     *payload;
+        DECLARE_COMPLETION_ONSTACK(completion);
+        u8              *ioctlbuffer = NULL;
+        u32             length = 0;
+        struct fw_control_info  *fwControl;
+        u32             loopNumber, loopcount = 0;
+        u32             sizeRead = 0;
+        u32             partitionSize, partitionSizeTmp;
+        u32             ret = 0;
+        u32             partitionNumber = 0;
+        struct pm8001_fw_image_header *image_hdr;
+
+        length = 1024 * 16 + sizeof(*payload) - 1;
+        ioctlbuffer = kzalloc(length, GFP_KERNEL);
+        image_hdr = (struct pm8001_fw_image_header *)pm8001_ha->fw_image->data;
+        if (!ioctlbuffer)
+                return -ENOMEM;
+        if (pm8001_ha->fw_image->size < 28) {
+                ret = FAIL_FILE_SIZE;
+                goto out;
+        }
+
+        while (sizeRead < pm8001_ha->fw_image->size) {
+                partitionSizeTmp =
+                        *(u32 *)((u8 *)&image_hdr->image_length + sizeRead);
+                partitionSize = be32_to_cpu(partitionSizeTmp);
+                loopcount = (partitionSize + HEADER_LEN)/IOCTL_BUF_SIZE;
+                if (loopcount % IOCTL_BUF_SIZE)
+                        loopcount++;
+                if (loopcount == 0)
+                        loopcount++;
+                for (loopNumber = 0; loopNumber < loopcount; loopNumber++) {
+                        payload = (struct pm8001_ioctl_payload *)ioctlbuffer;
+                        payload->length = 1024*16;
+                        payload->id = 0;
+                        fwControl =
+                              (struct fw_control_info *)payload->func_specific;
+                        fwControl->len = IOCTL_BUF_SIZE;   /* IN */
+                        fwControl->size = partitionSize + HEADER_LEN;/* IN */
+                        fwControl->retcode = 0;/* OUT */
+                        fwControl->offset = loopNumber * IOCTL_BUF_SIZE;/*OUT */
+
+                /* for the last chunk of data in case file size is not even with
+                4k, load only the rest*/
+                if (((loopcount-loopNumber) == 1) &&
+                        ((partitionSize + HEADER_LEN) % IOCTL_BUF_SIZE)) {
+                        fwControl->len =
+                                (partitionSize + HEADER_LEN) % IOCTL_BUF_SIZE;
+                        memcpy((u8 *)fwControl->buffer,
+                                (u8 *)pm8001_ha->fw_image->data + sizeRead,
+                                (partitionSize + HEADER_LEN) % IOCTL_BUF_SIZE);
+                        sizeRead +=
+                                (partitionSize + HEADER_LEN) % IOCTL_BUF_SIZE;
+                } else {
+                        memcpy((u8 *)fwControl->buffer,
+                                (u8 *)pm8001_ha->fw_image->data + sizeRead,
+                                IOCTL_BUF_SIZE);
+                        sizeRead += IOCTL_BUF_SIZE;
+                }
+
+                pm8001_ha->nvmd_completion = &completion;
+                ret = PM8001_CHIP_DISP->fw_flash_update_req(pm8001_ha, payload);
+                wait_for_completion(&completion);
+                if (ret || (fwControl->retcode > FLASH_UPDATE_IN_PROGRESS)) {
+                        ret = fwControl->retcode;
+                        kfree(ioctlbuffer);
+                        ioctlbuffer = NULL;
+                        break;
+                }
+        }
+        if (ret)
+                break;
+        partitionNumber++;
+}
+out:
+        kfree(ioctlbuffer);
+        return ret;
+}
+static ssize_t pm8001_store_update_fw(struct device *cdev,
+                                      struct device_attribute *attr,
+                                      const char *buf, size_t count)
+{
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
+        char *cmd_ptr, *filename_ptr;
+        int res, i;
+        int flash_command = FLASH_CMD_NONE;
+        int err = 0;
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+
+        cmd_ptr = kzalloc(count*2, GFP_KERNEL);
+
+        if (!cmd_ptr) {
+                err = FAIL_OUT_MEMORY;
+                goto out;
+        }
+
+        filename_ptr = cmd_ptr + count;
+        res = sscanf(buf, "%s %s", cmd_ptr, filename_ptr);
+        if (res != 2) {
+                err = FAIL_PARAMETERS;
+                goto out1;
+        }
+
+        for (i = 0; flash_command_table[i].code != FLASH_CMD_NONE; i++) {
+                if (!memcmp(flash_command_table[i].command,
+                                 cmd_ptr, strlen(cmd_ptr))) {
+                        flash_command = flash_command_table[i].code;
+                        break;
+                }
+        }
+        if (flash_command == FLASH_CMD_NONE) {
+                err = FAIL_PARAMETERS;
+                goto out1;
+        }
+
+        if (pm8001_ha->fw_status == FLASH_IN_PROGRESS) {
+                err = FLASH_IN_PROGRESS;
+                goto out1;
+        }
+        err = request_firmware(&pm8001_ha->fw_image,
+                               filename_ptr,
+                               pm8001_ha->dev);
+
+        if (err) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("Failed to load firmware image file %s,"
+                        " error %d\n", filename_ptr, err));
+                err = FAIL_OPEN_BIOS_FILE;
+                goto out1;
+        }
+
+        switch (flash_command) {
+        case FLASH_CMD_UPDATE:
+                pm8001_ha->fw_status = FLASH_IN_PROGRESS;
+                err = pm8001_update_flash(pm8001_ha);
+                break;
+        case FLASH_CMD_SET_NVMD:
+                pm8001_ha->fw_status = FLASH_IN_PROGRESS;
+                err = pm8001_set_nvmd(pm8001_ha);
+                break;
+        default:
+                pm8001_ha->fw_status = FAIL_PARAMETERS;
+                err = FAIL_PARAMETERS;
+                break;
+        }
+        release_firmware(pm8001_ha->fw_image);
+out1:
+        kfree(cmd_ptr);
+out:
+        pm8001_ha->fw_status = err;
+
+        if (!err)
+                return count;
+        else
+                return -err;
+}
+
+static ssize_t pm8001_show_update_fw(struct device *cdev,
+                                     struct device_attribute *attr, char *buf)
+{
+        int i;
+        struct Scsi_Host *shost = class_to_shost(cdev);
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
+
+        for (i = 0; flash_error_table[i].err_code != 0; i++) {
+                if (flash_error_table[i].err_code == pm8001_ha->fw_status)
+                        break;
+        }
+        if (pm8001_ha->fw_status != FLASH_IN_PROGRESS)
+                pm8001_ha->fw_status = FLASH_OK;
+
+        return snprintf(buf, PAGE_SIZE, "status=%x %s\n",
+                        flash_error_table[i].err_code,
+                        flash_error_table[i].reason);
+}
+
+static DEVICE_ATTR(update_fw, S_IRUGO|S_IWUGO,
+        pm8001_show_update_fw, pm8001_store_update_fw);
+struct device_attribute *pm8001_host_attrs[] = {
+        &dev_attr_interface_rev,
+        &dev_attr_fw_version,
+        &dev_attr_update_fw,
+        &dev_attr_aap_log,
+        &dev_attr_iop_log,
+        &dev_attr_max_out_io,
+        &dev_attr_max_devices,
+        &dev_attr_max_sg_list,
+        &dev_attr_sas_spec_support,
+        &dev_attr_logging_level,
+        &dev_attr_host_sas_address,
+        NULL,
+};
+
diff --git a/drivers/scsi/pm8001/pm8001_ctl.h b/drivers/scsi/pm8001/pm8001_ctl.h
new file mode 100644
index 000000000000..63ad4aa0c422
--- /dev/null
+++ b/drivers/scsi/pm8001/pm8001_ctl.h
@@ -0,0 +1,57 @@
+ /*
+  * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
+  *
+  * Copyright (c) 2008-2009 USI Co., Ltd.
+  * All rights reserved.
+  *
+  * Redistribution and use in source and binary forms, with or without
+  * modification, are permitted provided that the following conditions
+  * are met:
+  * 1. Redistributions of source code must retain the above copyright
+  *    notice, this list of conditions, and the following disclaimer,
+  *    without modification.
+  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+  *    substantially similar to the "NO WARRANTY" disclaimer below
+  *    ("Disclaimer") and any redistribution must be conditioned upon
+  *    including a substantially similar Disclaimer requirement for further
+  *    binary redistribution.
+  * 3. Neither the names of the above-listed copyright holders nor the names
+  *    of any contributors may be used to endorse or promote products derived
+  *    from this software without specific prior written permission.
+  *
+  * Alternatively, this software may be distributed under the terms of the
+  * GNU General Public License ("GPL") version 2 as published by the Free
+  * Software Foundation.
+  *
+  * NO WARRANTY
+  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+  * POSSIBILITY OF SUCH DAMAGES.
+  *
+  */
+
+#ifndef PM8001_CTL_H_INCLUDED
+#define PM8001_CTL_H_INCLUDED
+
+#define IOCTL_BUF_SIZE          4096
+#define HEADER_LEN                      28
+#define SIZE_OFFSET                     16
+
+
+#define FLASH_OK                        0x000000
+#define FAIL_OPEN_BIOS_FILE             0x000100
+#define FAIL_FILE_SIZE                  0x000a00
+#define FAIL_PARAMETERS                 0x000b00
+#define FAIL_OUT_MEMORY                 0x000c00
+#define FLASH_IN_PROGRESS               0x001000
+
+#endif /* PM8001_CTL_H_INCLUDED */
+
diff --git a/drivers/scsi/pm8001/pm8001_defs.h b/drivers/scsi/pm8001/pm8001_defs.h
new file mode 100644
index 000000000000..944afada61ee
--- /dev/null
+++ b/drivers/scsi/pm8001/pm8001_defs.h
@@ -0,0 +1,112 @@
+/*
+ * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
+ *
+ * Copyright (c) 2008-2009 USI Co., Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ */
+
+#ifndef _PM8001_DEFS_H_
+#define _PM8001_DEFS_H_
+
+enum chip_flavors {
+        chip_8001,
+};
+#define USI_MAX_MEMCNT                  9
+#define PM8001_MAX_DMA_SG               SG_ALL
+enum phy_speed {
+        PHY_SPEED_15 = 0x01,
+        PHY_SPEED_30 = 0x02,
+        PHY_SPEED_60 = 0x04,
+};
+
+enum data_direction {
+        DATA_DIR_NONE = 0x0,    /* NO TRANSFER */
+        DATA_DIR_IN = 0x01,     /* INBOUND */
+        DATA_DIR_OUT = 0x02,    /* OUTBOUND */
+        DATA_DIR_BYRECIPIENT = 0x04, /* UNSPECIFIED */
+};
+
+enum port_type {
+        PORT_TYPE_SAS = (1L << 1),
+        PORT_TYPE_SATA = (1L << 0),
+};
+
+/* driver compile-time configuration */
+#define PM8001_MAX_CCB           512    /* max ccbs supported */
+#define PM8001_MAX_INB_NUM       1
+#define PM8001_MAX_OUTB_NUM      1
+#define PM8001_CAN_QUEUE         128    /* SCSI Queue depth */
+
+/* unchangeable hardware details */
+#define PM8001_MAX_PHYS          8      /* max. possible phys */
+#define PM8001_MAX_PORTS         8      /* max. possible ports */
+#define PM8001_MAX_DEVICES       1024   /* max supported device */
+
+enum memory_region_num {
+        AAP1 = 0x0, /* application acceleration processor */
+        IOP,        /* IO processor */
+        CI,         /* consumer index */
+        PI,         /* producer index */
+        IB,         /* inbound queue */
+        OB,         /* outbound queue */
+        NVMD,       /* NVM device */
+        DEV_MEM,    /* memory for devices */
+        CCB_MEM,    /* memory for command control block */
+};
+#define PM8001_EVENT_LOG_SIZE    (128 * 1024)
+
+/*error code*/
+enum mpi_err {
+        MPI_IO_STATUS_SUCCESS = 0x0,
+        MPI_IO_STATUS_BUSY = 0x01,
+        MPI_IO_STATUS_FAIL = 0x02,
+};
+
+/**
+ * Phy Control constants
+ */
+enum phy_control_type {
+        PHY_LINK_RESET = 0x01,
+        PHY_HARD_RESET = 0x02,
+        PHY_NOTIFY_ENABLE_SPINUP = 0x10,
+};
+
+enum pm8001_hba_info_flags {
+        PM8001F_INIT_TIME       = (1U << 0),
+        PM8001F_RUN_TIME        = (1U << 1),
+};
+
+#endif
diff --git a/drivers/scsi/pm8001/pm8001_hwi.c b/drivers/scsi/pm8001/pm8001_hwi.c
new file mode 100644
index 000000000000..909c00ec044f
--- /dev/null
+++ b/drivers/scsi/pm8001/pm8001_hwi.c
@@ -0,0 +1,4494 @@
+/*
+ * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
+ *
+ * Copyright (c) 2008-2009 USI Co., Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ */
+ #include <linux/slab.h>
+ #include "pm8001_sas.h"
+ #include "pm8001_hwi.h"
+ #include "pm8001_chips.h"
+ #include "pm8001_ctl.h"
+
+/**
+ * read_main_config_table - read the configure table and save it.
+ * @pm8001_ha: our hba card information
+ */
+static void __devinit read_main_config_table(struct pm8001_hba_info *pm8001_ha)
+{
+        void __iomem *address = pm8001_ha->main_cfg_tbl_addr;
+        pm8001_ha->main_cfg_tbl.signature       = pm8001_mr32(address, 0x00);
+        pm8001_ha->main_cfg_tbl.interface_rev   = pm8001_mr32(address, 0x04);
+        pm8001_ha->main_cfg_tbl.firmware_rev    = pm8001_mr32(address, 0x08);
+        pm8001_ha->main_cfg_tbl.max_out_io      = pm8001_mr32(address, 0x0C);
+        pm8001_ha->main_cfg_tbl.max_sgl         = pm8001_mr32(address, 0x10);
+        pm8001_ha->main_cfg_tbl.ctrl_cap_flag   = pm8001_mr32(address, 0x14);
+        pm8001_ha->main_cfg_tbl.gst_offset      = pm8001_mr32(address, 0x18);
+        pm8001_ha->main_cfg_tbl.inbound_queue_offset =
+                pm8001_mr32(address, MAIN_IBQ_OFFSET);
+        pm8001_ha->main_cfg_tbl.outbound_queue_offset =
+                pm8001_mr32(address, MAIN_OBQ_OFFSET);
+        pm8001_ha->main_cfg_tbl.hda_mode_flag   =
+                pm8001_mr32(address, MAIN_HDA_FLAGS_OFFSET);
+
+        /* read analog Setting offset from the configuration table */
+        pm8001_ha->main_cfg_tbl.anolog_setup_table_offset =
+                pm8001_mr32(address, MAIN_ANALOG_SETUP_OFFSET);
+
+        /* read Error Dump Offset and Length */
+        pm8001_ha->main_cfg_tbl.fatal_err_dump_offset0 =
+                pm8001_mr32(address, MAIN_FATAL_ERROR_RDUMP0_OFFSET);
+        pm8001_ha->main_cfg_tbl.fatal_err_dump_length0 =
+                pm8001_mr32(address, MAIN_FATAL_ERROR_RDUMP0_LENGTH);
+        pm8001_ha->main_cfg_tbl.fatal_err_dump_offset1 =
+                pm8001_mr32(address, MAIN_FATAL_ERROR_RDUMP1_OFFSET);
+        pm8001_ha->main_cfg_tbl.fatal_err_dump_length1 =
+                pm8001_mr32(address, MAIN_FATAL_ERROR_RDUMP1_LENGTH);
+}
+
+/**
+ * read_general_status_table - read the general status table and save it.
+ * @pm8001_ha: our hba card information
+ */
+static void __devinit
+read_general_status_table(struct pm8001_hba_info *pm8001_ha)
+{
+        void __iomem *address = pm8001_ha->general_stat_tbl_addr;
+        pm8001_ha->gs_tbl.gst_len_mpistate      = pm8001_mr32(address, 0x00);
+        pm8001_ha->gs_tbl.iq_freeze_state0      = pm8001_mr32(address, 0x04);
+        pm8001_ha->gs_tbl.iq_freeze_state1      = pm8001_mr32(address, 0x08);
+        pm8001_ha->gs_tbl.msgu_tcnt             = pm8001_mr32(address, 0x0C);
+        pm8001_ha->gs_tbl.iop_tcnt              = pm8001_mr32(address, 0x10);
+        pm8001_ha->gs_tbl.reserved              = pm8001_mr32(address, 0x14);
+        pm8001_ha->gs_tbl.phy_state[0]  = pm8001_mr32(address, 0x18);
+        pm8001_ha->gs_tbl.phy_state[1]  = pm8001_mr32(address, 0x1C);
+        pm8001_ha->gs_tbl.phy_state[2]  = pm8001_mr32(address, 0x20);
+        pm8001_ha->gs_tbl.phy_state[3]  = pm8001_mr32(address, 0x24);
+        pm8001_ha->gs_tbl.phy_state[4]  = pm8001_mr32(address, 0x28);
+        pm8001_ha->gs_tbl.phy_state[5]  = pm8001_mr32(address, 0x2C);
+        pm8001_ha->gs_tbl.phy_state[6]  = pm8001_mr32(address, 0x30);
+        pm8001_ha->gs_tbl.phy_state[7]  = pm8001_mr32(address, 0x34);
+        pm8001_ha->gs_tbl.reserved1             = pm8001_mr32(address, 0x38);
+        pm8001_ha->gs_tbl.reserved2             = pm8001_mr32(address, 0x3C);
+        pm8001_ha->gs_tbl.reserved3             = pm8001_mr32(address, 0x40);
+        pm8001_ha->gs_tbl.recover_err_info[0]   = pm8001_mr32(address, 0x44);
+        pm8001_ha->gs_tbl.recover_err_info[1]   = pm8001_mr32(address, 0x48);
+        pm8001_ha->gs_tbl.recover_err_info[2]   = pm8001_mr32(address, 0x4C);
+        pm8001_ha->gs_tbl.recover_err_info[3]   = pm8001_mr32(address, 0x50);
+        pm8001_ha->gs_tbl.recover_err_info[4]   = pm8001_mr32(address, 0x54);
+        pm8001_ha->gs_tbl.recover_err_info[5]   = pm8001_mr32(address, 0x58);
+        pm8001_ha->gs_tbl.recover_err_info[6]   = pm8001_mr32(address, 0x5C);
+        pm8001_ha->gs_tbl.recover_err_info[7]   = pm8001_mr32(address, 0x60);
+}
+
+/**
+ * read_inbnd_queue_table - read the inbound queue table and save it.
+ * @pm8001_ha: our hba card information
+ */
+static void __devinit
+read_inbnd_queue_table(struct pm8001_hba_info *pm8001_ha)
+{
+        int inbQ_num = 1;
+        int i;
+        void __iomem *address = pm8001_ha->inbnd_q_tbl_addr;
+        for (i = 0; i < inbQ_num; i++) {
+                u32 offset = i * 0x20;
+                pm8001_ha->inbnd_q_tbl[i].pi_pci_bar =
+                      get_pci_bar_index(pm8001_mr32(address, (offset + 0x14)));
+                pm8001_ha->inbnd_q_tbl[i].pi_offset =
+                        pm8001_mr32(address, (offset + 0x18));
+        }
+}
+
+/**
+ * read_outbnd_queue_table - read the outbound queue table and save it.
+ * @pm8001_ha: our hba card information
+ */
+static void __devinit
+read_outbnd_queue_table(struct pm8001_hba_info *pm8001_ha)
+{
+        int outbQ_num = 1;
+        int i;
+        void __iomem *address = pm8001_ha->outbnd_q_tbl_addr;
+        for (i = 0; i < outbQ_num; i++) {
+                u32 offset = i * 0x24;
+                pm8001_ha->outbnd_q_tbl[i].ci_pci_bar =
+                      get_pci_bar_index(pm8001_mr32(address, (offset + 0x14)));
+                pm8001_ha->outbnd_q_tbl[i].ci_offset =
+                        pm8001_mr32(address, (offset + 0x18));
+        }
+}
+
+/**
+ * init_default_table_values - init the default table.
+ * @pm8001_ha: our hba card information
+ */
+static void __devinit
+init_default_table_values(struct pm8001_hba_info *pm8001_ha)
+{
+        int qn = 1;
+        int i;
+        u32 offsetib, offsetob;
+        void __iomem *addressib = pm8001_ha->inbnd_q_tbl_addr;
+        void __iomem *addressob = pm8001_ha->outbnd_q_tbl_addr;
+
+        pm8001_ha->main_cfg_tbl.inbound_q_nppd_hppd                     = 0;
+        pm8001_ha->main_cfg_tbl.outbound_hw_event_pid0_3                = 0;
+        pm8001_ha->main_cfg_tbl.outbound_hw_event_pid4_7                = 0;
+        pm8001_ha->main_cfg_tbl.outbound_ncq_event_pid0_3               = 0;
+        pm8001_ha->main_cfg_tbl.outbound_ncq_event_pid4_7               = 0;
+        pm8001_ha->main_cfg_tbl.outbound_tgt_ITNexus_event_pid0_3       = 0;
+        pm8001_ha->main_cfg_tbl.outbound_tgt_ITNexus_event_pid4_7       = 0;
+        pm8001_ha->main_cfg_tbl.outbound_tgt_ssp_event_pid0_3   = 0;
+        pm8001_ha->main_cfg_tbl.outbound_tgt_ssp_event_pid4_7   = 0;
+        pm8001_ha->main_cfg_tbl.outbound_tgt_smp_event_pid0_3   = 0;
+        pm8001_ha->main_cfg_tbl.outbound_tgt_smp_event_pid4_7   = 0;
+
+        pm8001_ha->main_cfg_tbl.upper_event_log_addr            =
+                pm8001_ha->memoryMap.region[AAP1].phys_addr_hi;
+        pm8001_ha->main_cfg_tbl.lower_event_log_addr            =
+                pm8001_ha->memoryMap.region[AAP1].phys_addr_lo;
+        pm8001_ha->main_cfg_tbl.event_log_size  = PM8001_EVENT_LOG_SIZE;
+        pm8001_ha->main_cfg_tbl.event_log_option                = 0x01;
+        pm8001_ha->main_cfg_tbl.upper_iop_event_log_addr        =
+                pm8001_ha->memoryMap.region[IOP].phys_addr_hi;
+        pm8001_ha->main_cfg_tbl.lower_iop_event_log_addr        =
+                pm8001_ha->memoryMap.region[IOP].phys_addr_lo;
+        pm8001_ha->main_cfg_tbl.iop_event_log_size      = PM8001_EVENT_LOG_SIZE;
+        pm8001_ha->main_cfg_tbl.iop_event_log_option            = 0x01;
+        pm8001_ha->main_cfg_tbl.fatal_err_interrupt             = 0x01;
+        for (i = 0; i < qn; i++) {
+                pm8001_ha->inbnd_q_tbl[i].element_pri_size_cnt  =
+                        0x00000100 | (0x00000040 << 16) | (0x00<<30);
+                pm8001_ha->inbnd_q_tbl[i].upper_base_addr       =
+                        pm8001_ha->memoryMap.region[IB].phys_addr_hi;
+                pm8001_ha->inbnd_q_tbl[i].lower_base_addr       =
+                pm8001_ha->memoryMap.region[IB].phys_addr_lo;
+                pm8001_ha->inbnd_q_tbl[i].base_virt             =
+                        (u8 *)pm8001_ha->memoryMap.region[IB].virt_ptr;
+                pm8001_ha->inbnd_q_tbl[i].total_length          =
+                        pm8001_ha->memoryMap.region[IB].total_len;
+                pm8001_ha->inbnd_q_tbl[i].ci_upper_base_addr    =
+                        pm8001_ha->memoryMap.region[CI].phys_addr_hi;
+                pm8001_ha->inbnd_q_tbl[i].ci_lower_base_addr    =
+                        pm8001_ha->memoryMap.region[CI].phys_addr_lo;
+                pm8001_ha->inbnd_q_tbl[i].ci_virt               =
+                        pm8001_ha->memoryMap.region[CI].virt_ptr;
+                offsetib = i * 0x20;
+                pm8001_ha->inbnd_q_tbl[i].pi_pci_bar            =
+                        get_pci_bar_index(pm8001_mr32(addressib,
+                                (offsetib + 0x14)));
+                pm8001_ha->inbnd_q_tbl[i].pi_offset             =
+                        pm8001_mr32(addressib, (offsetib + 0x18));
+                pm8001_ha->inbnd_q_tbl[i].producer_idx          = 0;
+                pm8001_ha->inbnd_q_tbl[i].consumer_index        = 0;
+        }
+        for (i = 0; i < qn; i++) {
+                pm8001_ha->outbnd_q_tbl[i].element_size_cnt     =
+                        256 | (64 << 16) | (1<<30);
+                pm8001_ha->outbnd_q_tbl[i].upper_base_addr      =
+                        pm8001_ha->memoryMap.region[OB].phys_addr_hi;
+                pm8001_ha->outbnd_q_tbl[i].lower_base_addr      =
+                        pm8001_ha->memoryMap.region[OB].phys_addr_lo;
+                pm8001_ha->outbnd_q_tbl[i].base_virt            =
+                        (u8 *)pm8001_ha->memoryMap.region[OB].virt_ptr;
+                pm8001_ha->outbnd_q_tbl[i].total_length         =
+                        pm8001_ha->memoryMap.region[OB].total_len;
+                pm8001_ha->outbnd_q_tbl[i].pi_upper_base_addr   =
+                        pm8001_ha->memoryMap.region[PI].phys_addr_hi;
+                pm8001_ha->outbnd_q_tbl[i].pi_lower_base_addr   =
+                        pm8001_ha->memoryMap.region[PI].phys_addr_lo;
+                pm8001_ha->outbnd_q_tbl[i].interrup_vec_cnt_delay       =
+                        0 | (10 << 16) | (0 << 24);
+                pm8001_ha->outbnd_q_tbl[i].pi_virt              =
+                        pm8001_ha->memoryMap.region[PI].virt_ptr;
+                offsetob = i * 0x24;
+                pm8001_ha->outbnd_q_tbl[i].ci_pci_bar           =
+                        get_pci_bar_index(pm8001_mr32(addressob,
+                        offsetob + 0x14));
+                pm8001_ha->outbnd_q_tbl[i].ci_offset            =
+                        pm8001_mr32(addressob, (offsetob + 0x18));
+                pm8001_ha->outbnd_q_tbl[i].consumer_idx         = 0;
+                pm8001_ha->outbnd_q_tbl[i].producer_index       = 0;
+        }
+}
+
+/**
+ * update_main_config_table - update the main default table to the HBA.
+ * @pm8001_ha: our hba card information
+ */
+static void __devinit
+update_main_config_table(struct pm8001_hba_info *pm8001_ha)
+{
+        void __iomem *address = pm8001_ha->main_cfg_tbl_addr;
+        pm8001_mw32(address, 0x24,
+                pm8001_ha->main_cfg_tbl.inbound_q_nppd_hppd);
+        pm8001_mw32(address, 0x28,
+                pm8001_ha->main_cfg_tbl.outbound_hw_event_pid0_3);
+        pm8001_mw32(address, 0x2C,
+                pm8001_ha->main_cfg_tbl.outbound_hw_event_pid4_7);
+        pm8001_mw32(address, 0x30,
+                pm8001_ha->main_cfg_tbl.outbound_ncq_event_pid0_3);
+        pm8001_mw32(address, 0x34,
+                pm8001_ha->main_cfg_tbl.outbound_ncq_event_pid4_7);
+        pm8001_mw32(address, 0x38,
+                pm8001_ha->main_cfg_tbl.outbound_tgt_ITNexus_event_pid0_3);
+        pm8001_mw32(address, 0x3C,
+                pm8001_ha->main_cfg_tbl.outbound_tgt_ITNexus_event_pid4_7);
+        pm8001_mw32(address, 0x40,
+                pm8001_ha->main_cfg_tbl.outbound_tgt_ssp_event_pid0_3);
+        pm8001_mw32(address, 0x44,
+                pm8001_ha->main_cfg_tbl.outbound_tgt_ssp_event_pid4_7);
+        pm8001_mw32(address, 0x48,
+                pm8001_ha->main_cfg_tbl.outbound_tgt_smp_event_pid0_3);
+        pm8001_mw32(address, 0x4C,
+                pm8001_ha->main_cfg_tbl.outbound_tgt_smp_event_pid4_7);
+        pm8001_mw32(address, 0x50,
+                pm8001_ha->main_cfg_tbl.upper_event_log_addr);
+        pm8001_mw32(address, 0x54,
+                pm8001_ha->main_cfg_tbl.lower_event_log_addr);
+        pm8001_mw32(address, 0x58, pm8001_ha->main_cfg_tbl.event_log_size);
+        pm8001_mw32(address, 0x5C, pm8001_ha->main_cfg_tbl.event_log_option);
+        pm8001_mw32(address, 0x60,
+                pm8001_ha->main_cfg_tbl.upper_iop_event_log_addr);
+        pm8001_mw32(address, 0x64,
+                pm8001_ha->main_cfg_tbl.lower_iop_event_log_addr);
+        pm8001_mw32(address, 0x68, pm8001_ha->main_cfg_tbl.iop_event_log_size);
+        pm8001_mw32(address, 0x6C,
+                pm8001_ha->main_cfg_tbl.iop_event_log_option);
+        pm8001_mw32(address, 0x70,
+                pm8001_ha->main_cfg_tbl.fatal_err_interrupt);
+}
+
+/**
+ * update_inbnd_queue_table - update the inbound queue table to the HBA.
+ * @pm8001_ha: our hba card information
+ */
+static void __devinit
+update_inbnd_queue_table(struct pm8001_hba_info *pm8001_ha, int number)
+{
+        void __iomem *address = pm8001_ha->inbnd_q_tbl_addr;
+        u16 offset = number * 0x20;
+        pm8001_mw32(address, offset + 0x00,
+                pm8001_ha->inbnd_q_tbl[number].element_pri_size_cnt);
+        pm8001_mw32(address, offset + 0x04,
+                pm8001_ha->inbnd_q_tbl[number].upper_base_addr);
+        pm8001_mw32(address, offset + 0x08,
+                pm8001_ha->inbnd_q_tbl[number].lower_base_addr);
+        pm8001_mw32(address, offset + 0x0C,
+                pm8001_ha->inbnd_q_tbl[number].ci_upper_base_addr);
+        pm8001_mw32(address, offset + 0x10,
+                pm8001_ha->inbnd_q_tbl[number].ci_lower_base_addr);
+}
+
+/**
+ * update_outbnd_queue_table - update the outbound queue table to the HBA.
+ * @pm8001_ha: our hba card information
+ */
+static void __devinit
+update_outbnd_queue_table(struct pm8001_hba_info *pm8001_ha, int number)
+{
+        void __iomem *address = pm8001_ha->outbnd_q_tbl_addr;
+        u16 offset = number * 0x24;
+        pm8001_mw32(address, offset + 0x00,
+                pm8001_ha->outbnd_q_tbl[number].element_size_cnt);
+        pm8001_mw32(address, offset + 0x04,
+                pm8001_ha->outbnd_q_tbl[number].upper_base_addr);
+        pm8001_mw32(address, offset + 0x08,
+                pm8001_ha->outbnd_q_tbl[number].lower_base_addr);
+        pm8001_mw32(address, offset + 0x0C,
+                pm8001_ha->outbnd_q_tbl[number].pi_upper_base_addr);
+        pm8001_mw32(address, offset + 0x10,
+                pm8001_ha->outbnd_q_tbl[number].pi_lower_base_addr);
+        pm8001_mw32(address, offset + 0x1C,
+                pm8001_ha->outbnd_q_tbl[number].interrup_vec_cnt_delay);
+}
+
+/**
+ * bar4_shift - function is called to shift BAR base address
+ * @pm8001_ha : our hba card infomation
+ * @shiftValue : shifting value in memory bar.
+ */
+static int bar4_shift(struct pm8001_hba_info *pm8001_ha, u32 shiftValue)
+{
+        u32 regVal;
+        u32 max_wait_count;
+
+        /* program the inbound AXI translation Lower Address */
+        pm8001_cw32(pm8001_ha, 1, SPC_IBW_AXI_TRANSLATION_LOW, shiftValue);
+
+        /* confirm the setting is written */
+        max_wait_count = 1 * 1000 * 1000;  /* 1 sec */
+        do {
+                udelay(1);
+                regVal = pm8001_cr32(pm8001_ha, 1, SPC_IBW_AXI_TRANSLATION_LOW);
+        } while ((regVal != shiftValue) && (--max_wait_count));
+
+        if (!max_wait_count) {
+                PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("TIMEOUT:SPC_IBW_AXI_TRANSLATION_LOW"
+                        " = 0x%x\n", regVal));
+                return -1;
+        }
+        return 0;
+}
+
+/**
+ * mpi_set_phys_g3_with_ssc
+ * @pm8001_ha: our hba card information
+ * @SSCbit: set SSCbit to 0 to disable all phys ssc; 1 to enable all phys ssc.
+ */
+static void __devinit
+mpi_set_phys_g3_with_ssc(struct pm8001_hba_info *pm8001_ha, u32 SSCbit)
+{
+        u32 value, offset, i;
+
+#define SAS2_SETTINGS_LOCAL_PHY_0_3_SHIFT_ADDR 0x00030000
+#define SAS2_SETTINGS_LOCAL_PHY_4_7_SHIFT_ADDR 0x00040000
+#define SAS2_SETTINGS_LOCAL_PHY_0_3_OFFSET 0x1074
+#define SAS2_SETTINGS_LOCAL_PHY_4_7_OFFSET 0x1074
+#define PHY_G3_WITHOUT_SSC_BIT_SHIFT 12
+#define PHY_G3_WITH_SSC_BIT_SHIFT 13
+#define SNW3_PHY_CAPABILITIES_PARITY 31
+
+   /*
+    * Using shifted destination address 0x3_0000:0x1074 + 0x4000*N (N=0:3)
+    * Using shifted destination address 0x4_0000:0x1074 + 0x4000*(N-4) (N=4:7)
+    */
+        if (-1 == bar4_shift(pm8001_ha, SAS2_SETTINGS_LOCAL_PHY_0_3_SHIFT_ADDR))
+                return;
+
+        for (i = 0; i < 4; i++) {
+                offset = SAS2_SETTINGS_LOCAL_PHY_0_3_OFFSET + 0x4000 * i;
+                pm8001_cw32(pm8001_ha, 2, offset, 0x80001501);
+        }
+        /* shift membase 3 for SAS2_SETTINGS_LOCAL_PHY 4 - 7 */
+        if (-1 == bar4_shift(pm8001_ha, SAS2_SETTINGS_LOCAL_PHY_4_7_SHIFT_ADDR))
+                return;
+        for (i = 4; i < 8; i++) {
+                offset = SAS2_SETTINGS_LOCAL_PHY_4_7_OFFSET + 0x4000 * (i-4);
+                pm8001_cw32(pm8001_ha, 2, offset, 0x80001501);
+        }
+        /*************************************************************
+        Change the SSC upspreading value to 0x0 so that upspreading is disabled.
+        Device MABC SMOD0 Controls
+        Address: (via MEMBASE-III):
+        Using shifted destination address 0x0_0000: with Offset 0xD8
+
+        31:28 R/W Reserved Do not change
+        27:24 R/W SAS_SMOD_SPRDUP 0000
+        23:20 R/W SAS_SMOD_SPRDDN 0000
+        19:0  R/W  Reserved Do not change
+        Upon power-up this register will read as 0x8990c016,
+        and I would like you to change the SAS_SMOD_SPRDUP bits to 0b0000
+        so that the written value will be 0x8090c016.
+        This will ensure only down-spreading SSC is enabled on the SPC.
+        *************************************************************/
+        value = pm8001_cr32(pm8001_ha, 2, 0xd8);
+        pm8001_cw32(pm8001_ha, 2, 0xd8, 0x8000C016);
+
+        /*set the shifted destination address to 0x0 to avoid error operation */
+        bar4_shift(pm8001_ha, 0x0);
+        return;
+}
+
+/**
+ * mpi_set_open_retry_interval_reg
+ * @pm8001_ha: our hba card information
+ * @interval - interval time for each OPEN_REJECT (RETRY). The units are in 1us.
+ */
+static void __devinit
+mpi_set_open_retry_interval_reg(struct pm8001_hba_info *pm8001_ha,
+                                u32 interval)
+{
+        u32 offset;
+        u32 value;
+        u32 i;
+
+#define OPEN_RETRY_INTERVAL_PHY_0_3_SHIFT_ADDR 0x00030000
+#define OPEN_RETRY_INTERVAL_PHY_4_7_SHIFT_ADDR 0x00040000
+#define OPEN_RETRY_INTERVAL_PHY_0_3_OFFSET 0x30B4
+#define OPEN_RETRY_INTERVAL_PHY_4_7_OFFSET 0x30B4
+#define OPEN_RETRY_INTERVAL_REG_MASK 0x0000FFFF
+
+        value = interval & OPEN_RETRY_INTERVAL_REG_MASK;
+        /* shift bar and set the OPEN_REJECT(RETRY) interval time of PHY 0 -3.*/
+        if (-1 == bar4_shift(pm8001_ha,
+                             OPEN_RETRY_INTERVAL_PHY_0_3_SHIFT_ADDR))
+                return;
+        for (i = 0; i < 4; i++) {
+                offset = OPEN_RETRY_INTERVAL_PHY_0_3_OFFSET + 0x4000 * i;
+                pm8001_cw32(pm8001_ha, 2, offset, value);
+        }
+
+        if (-1 == bar4_shift(pm8001_ha,
+                             OPEN_RETRY_INTERVAL_PHY_4_7_SHIFT_ADDR))
+                return;
+        for (i = 4; i < 8; i++) {
+                offset = OPEN_RETRY_INTERVAL_PHY_4_7_OFFSET + 0x4000 * (i-4);
+                pm8001_cw32(pm8001_ha, 2, offset, value);
+        }
+        /*set the shifted destination address to 0x0 to avoid error operation */
+        bar4_shift(pm8001_ha, 0x0);
+        return;
+}
+
+/**
+ * mpi_init_check - check firmware initialization status.
+ * @pm8001_ha: our hba card information
+ */
+static int mpi_init_check(struct pm8001_hba_info *pm8001_ha)
+{
+        u32 max_wait_count;
+        u32 value;
+        u32 gst_len_mpistate;
+        /* Write bit0=1 to Inbound DoorBell Register to tell the SPC FW the
+        table is updated */
+        pm8001_cw32(pm8001_ha, 0, MSGU_IBDB_SET, SPC_MSGU_CFG_TABLE_UPDATE);
+        /* wait until Inbound DoorBell Clear Register toggled */
+        max_wait_count = 1 * 1000 * 1000;/* 1 sec */
+        do {
+                udelay(1);
+                value = pm8001_cr32(pm8001_ha, 0, MSGU_IBDB_SET);
+                value &= SPC_MSGU_CFG_TABLE_UPDATE;
+        } while ((value != 0) && (--max_wait_count));
+
+        if (!max_wait_count)
+                return -1;
+        /* check the MPI-State for initialization */
+        gst_len_mpistate =
+                pm8001_mr32(pm8001_ha->general_stat_tbl_addr,
+                GST_GSTLEN_MPIS_OFFSET);
+        if (GST_MPI_STATE_INIT != (gst_len_mpistate & GST_MPI_STATE_MASK))
+                return -1;
+        /* check MPI Initialization error */
+        gst_len_mpistate = gst_len_mpistate >> 16;
+        if (0x0000 != gst_len_mpistate)
+                return -1;
+        return 0;
+}
+
+/**
+ * check_fw_ready - The LLDD check if the FW is ready, if not, return error.
+ * @pm8001_ha: our hba card information
+ */
+static int check_fw_ready(struct pm8001_hba_info *pm8001_ha)
+{
+        u32 value, value1;
+        u32 max_wait_count;
+        /* check error state */
+        value = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1);
+        value1 = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_2);
+        /* check AAP error */
+        if (SCRATCH_PAD1_ERR == (value & SCRATCH_PAD_STATE_MASK)) {
+                /* error state */
+                value = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_0);
+                return -1;
+        }
+
+        /* check IOP error */
+        if (SCRATCH_PAD2_ERR == (value1 & SCRATCH_PAD_STATE_MASK)) {
+                /* error state */
+                value1 = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_3);
+                return -1;
+        }
+
+        /* bit 4-31 of scratch pad1 should be zeros if it is not
+        in error state*/
+        if (value & SCRATCH_PAD1_STATE_MASK) {
+                /* error case */
+                pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_0);
+                return -1;
+        }
+
+        /* bit 2, 4-31 of scratch pad2 should be zeros if it is not
+        in error state */
+        if (value1 & SCRATCH_PAD2_STATE_MASK) {
+                /* error case */
+                return -1;
+        }
+
+        max_wait_count = 1 * 1000 * 1000;/* 1 sec timeout */
+
+        /* wait until scratch pad 1 and 2 registers in ready state  */
+        do {
+                udelay(1);
+                value = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1)
+                        & SCRATCH_PAD1_RDY;
+                value1 = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_2)
+                        & SCRATCH_PAD2_RDY;
+                if ((--max_wait_count) == 0)
+                        return -1;
+        } while ((value != SCRATCH_PAD1_RDY) || (value1 != SCRATCH_PAD2_RDY));
+        return 0;
+}
+
+static void init_pci_device_addresses(struct pm8001_hba_info *pm8001_ha)
+{
+        void __iomem *base_addr;
+        u32     value;
+        u32     offset;
+        u32     pcibar;
+        u32     pcilogic;
+
+        value = pm8001_cr32(pm8001_ha, 0, 0x44);
+        offset = value & 0x03FFFFFF;
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("Scratchpad 0 Offset: %x \n", offset));
+        pcilogic = (value & 0xFC000000) >> 26;
+        pcibar = get_pci_bar_index(pcilogic);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("Scratchpad 0 PCI BAR: %d \n", pcibar));
+        pm8001_ha->main_cfg_tbl_addr = base_addr =
+                pm8001_ha->io_mem[pcibar].memvirtaddr + offset;
+        pm8001_ha->general_stat_tbl_addr =
+                base_addr + pm8001_cr32(pm8001_ha, pcibar, offset + 0x18);
+        pm8001_ha->inbnd_q_tbl_addr =
+                base_addr + pm8001_cr32(pm8001_ha, pcibar, offset + 0x1C);
+        pm8001_ha->outbnd_q_tbl_addr =
+                base_addr + pm8001_cr32(pm8001_ha, pcibar, offset + 0x20);
+}
+
+/**
+ * pm8001_chip_init - the main init function that initialize whole PM8001 chip.
+ * @pm8001_ha: our hba card information
+ */
+static int __devinit pm8001_chip_init(struct pm8001_hba_info *pm8001_ha)
+{
+        /* check the firmware status */
+        if (-1 == check_fw_ready(pm8001_ha)) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("Firmware is not ready!\n"));
+                return -EBUSY;
+        }
+
+        /* Initialize pci space address eg: mpi offset */
+        init_pci_device_addresses(pm8001_ha);
+        init_default_table_values(pm8001_ha);
+        read_main_config_table(pm8001_ha);
+        read_general_status_table(pm8001_ha);
+        read_inbnd_queue_table(pm8001_ha);
+        read_outbnd_queue_table(pm8001_ha);
+        /* update main config table ,inbound table and outbound table */
+        update_main_config_table(pm8001_ha);
+        update_inbnd_queue_table(pm8001_ha, 0);
+        update_outbnd_queue_table(pm8001_ha, 0);
+        mpi_set_phys_g3_with_ssc(pm8001_ha, 0);
+        mpi_set_open_retry_interval_reg(pm8001_ha, 7);
+        /* notify firmware update finished and check initialization status */
+        if (0 == mpi_init_check(pm8001_ha)) {
+                PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("MPI initialize successful!\n"));
+        } else
+                return -EBUSY;
+        /*This register is a 16-bit timer with a resolution of 1us. This is the
+        timer used for interrupt delay/coalescing in the PCIe Application Layer.
+        Zero is not a valid value. A value of 1 in the register will cause the
+        interrupts to be normal. A value greater than 1 will cause coalescing
+        delays.*/
+        pm8001_cw32(pm8001_ha, 1, 0x0033c0, 0x1);
+        pm8001_cw32(pm8001_ha, 1, 0x0033c4, 0x0);
+        return 0;
+}
+
+static int mpi_uninit_check(struct pm8001_hba_info *pm8001_ha)
+{
+        u32 max_wait_count;
+        u32 value;
+        u32 gst_len_mpistate;
+        init_pci_device_addresses(pm8001_ha);
+        /* Write bit1=1 to Inbound DoorBell Register to tell the SPC FW the
+        table is stop */
+        pm8001_cw32(pm8001_ha, 0, MSGU_IBDB_SET, SPC_MSGU_CFG_TABLE_RESET);
+
+        /* wait until Inbound DoorBell Clear Register toggled */
+        max_wait_count = 1 * 1000 * 1000;/* 1 sec */
+        do {
+                udelay(1);
+                value = pm8001_cr32(pm8001_ha, 0, MSGU_IBDB_SET);
+                value &= SPC_MSGU_CFG_TABLE_RESET;
+        } while ((value != 0) && (--max_wait_count));
+
+        if (!max_wait_count) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("TIMEOUT:IBDB value/=0x%x\n", value));
+                return -1;
+        }
+
+        /* check the MPI-State for termination in progress */
+        /* wait until Inbound DoorBell Clear Register toggled */
+        max_wait_count = 1 * 1000 * 1000;  /* 1 sec */
+        do {
+                udelay(1);
+                gst_len_mpistate =
+                        pm8001_mr32(pm8001_ha->general_stat_tbl_addr,
+                        GST_GSTLEN_MPIS_OFFSET);
+                if (GST_MPI_STATE_UNINIT ==
+                        (gst_len_mpistate & GST_MPI_STATE_MASK))
+                        break;
+        } while (--max_wait_count);
+        if (!max_wait_count) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk(" TIME OUT MPI State = 0x%x\n",
+                                gst_len_mpistate & GST_MPI_STATE_MASK));
+                return -1;
+        }
+        return 0;
+}
+
+/**
+ * soft_reset_ready_check - Function to check FW is ready for soft reset.
+ * @pm8001_ha: our hba card information
+ */
+static u32 soft_reset_ready_check(struct pm8001_hba_info *pm8001_ha)
+{
+        u32 regVal, regVal1, regVal2;
+        if (mpi_uninit_check(pm8001_ha) != 0) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("MPI state is not ready\n"));
+                return -1;
+        }
+        /* read the scratch pad 2 register bit 2 */
+        regVal = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_2)
+                & SCRATCH_PAD2_FWRDY_RST;
+        if (regVal == SCRATCH_PAD2_FWRDY_RST) {
+                PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("Firmware is ready for reset .\n"));
+        } else {
+        /* Trigger NMI twice via RB6 */
+                if (-1 == bar4_shift(pm8001_ha, RB6_ACCESS_REG)) {
+                        PM8001_FAIL_DBG(pm8001_ha,
+                                pm8001_printk("Shift Bar4 to 0x%x failed\n",
+                                        RB6_ACCESS_REG));
+                        return -1;
+                }
+                pm8001_cw32(pm8001_ha, 2, SPC_RB6_OFFSET,
+                        RB6_MAGIC_NUMBER_RST);
+                pm8001_cw32(pm8001_ha, 2, SPC_RB6_OFFSET, RB6_MAGIC_NUMBER_RST);
+                /* wait for 100 ms */
+                mdelay(100);
+                regVal = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_2) &
+                        SCRATCH_PAD2_FWRDY_RST;
+                if (regVal != SCRATCH_PAD2_FWRDY_RST) {
+                        regVal1 = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1);
+                        regVal2 = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_2);
+                        PM8001_FAIL_DBG(pm8001_ha,
+                                pm8001_printk("TIMEOUT:MSGU_SCRATCH_PAD1"
+                                "=0x%x, MSGU_SCRATCH_PAD2=0x%x\n",
+                                regVal1, regVal2));
+                        PM8001_FAIL_DBG(pm8001_ha,
+                                pm8001_printk("SCRATCH_PAD0 value = 0x%x\n",
+                                pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_0)));
+                        PM8001_FAIL_DBG(pm8001_ha,
+                                pm8001_printk("SCRATCH_PAD3 value = 0x%x\n",
+                                pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_3)));
+                        return -1;
+                }
+        }
+        return 0;
+}
+
+/**
+ * pm8001_chip_soft_rst - soft reset the PM8001 chip, so that the clear all
+ * the FW register status to the originated status.
+ * @pm8001_ha: our hba card information
+ * @signature: signature in host scratch pad0 register.
+ */
+static int
+pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha, u32 signature)
+{
+        u32     regVal, toggleVal;
+        u32     max_wait_count;
+        u32     regVal1, regVal2, regVal3;
+
+        /* step1: Check FW is ready for soft reset */
+        if (soft_reset_ready_check(pm8001_ha) != 0) {
+                PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("FW is not ready\n"));
+                return -1;
+        }
+
+        /* step 2: clear NMI status register on AAP1 and IOP, write the same
+        value to clear */
+        /* map 0x60000 to BAR4(0x20), BAR2(win) */
+        if (-1 == bar4_shift(pm8001_ha, MBIC_AAP1_ADDR_BASE)) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("Shift Bar4 to 0x%x failed\n",
+                        MBIC_AAP1_ADDR_BASE));
+                return -1;
+        }
+        regVal = pm8001_cr32(pm8001_ha, 2, MBIC_NMI_ENABLE_VPE0_IOP);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("MBIC - NMI Enable VPE0 (IOP)= 0x%x\n", regVal));
+        pm8001_cw32(pm8001_ha, 2, MBIC_NMI_ENABLE_VPE0_IOP, 0x0);
+        /* map 0x70000 to BAR4(0x20), BAR2(win) */
+        if (-1 == bar4_shift(pm8001_ha, MBIC_IOP_ADDR_BASE)) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("Shift Bar4 to 0x%x failed\n",
+                        MBIC_IOP_ADDR_BASE));
+                return -1;
+        }
+        regVal = pm8001_cr32(pm8001_ha, 2, MBIC_NMI_ENABLE_VPE0_AAP1);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("MBIC - NMI Enable VPE0 (AAP1)= 0x%x\n", regVal));
+        pm8001_cw32(pm8001_ha, 2, MBIC_NMI_ENABLE_VPE0_AAP1, 0x0);
+
+        regVal = pm8001_cr32(pm8001_ha, 1, PCIE_EVENT_INTERRUPT_ENABLE);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("PCIE -Event Interrupt Enable = 0x%x\n", regVal));
+        pm8001_cw32(pm8001_ha, 1, PCIE_EVENT_INTERRUPT_ENABLE, 0x0);
+
+        regVal = pm8001_cr32(pm8001_ha, 1, PCIE_EVENT_INTERRUPT);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("PCIE - Event Interrupt  = 0x%x\n", regVal));
+        pm8001_cw32(pm8001_ha, 1, PCIE_EVENT_INTERRUPT, regVal);
+
+        regVal = pm8001_cr32(pm8001_ha, 1, PCIE_ERROR_INTERRUPT_ENABLE);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("PCIE -Error Interrupt Enable = 0x%x\n", regVal));
+        pm8001_cw32(pm8001_ha, 1, PCIE_ERROR_INTERRUPT_ENABLE, 0x0);
+
+        regVal = pm8001_cr32(pm8001_ha, 1, PCIE_ERROR_INTERRUPT);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("PCIE - Error Interrupt = 0x%x\n", regVal));
+        pm8001_cw32(pm8001_ha, 1, PCIE_ERROR_INTERRUPT, regVal);
+
+        /* read the scratch pad 1 register bit 2 */
+        regVal = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1)
+                & SCRATCH_PAD1_RST;
+        toggleVal = regVal ^ SCRATCH_PAD1_RST;
+
+        /* set signature in host scratch pad0 register to tell SPC that the
+        host performs the soft reset */
+        pm8001_cw32(pm8001_ha, 0, MSGU_HOST_SCRATCH_PAD_0, signature);
+
+        /* read required registers for confirmming */
+        /* map 0x0700000 to BAR4(0x20), BAR2(win) */
+        if (-1 == bar4_shift(pm8001_ha, GSM_ADDR_BASE)) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("Shift Bar4 to 0x%x failed\n",
+                        GSM_ADDR_BASE));
+                return -1;
+        }
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("GSM 0x0(0x00007b88)-GSM Configuration and"
+                " Reset = 0x%x\n",
+                pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET)));
+
+        /* step 3: host read GSM Configuration and Reset register */
+        regVal = pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET);
+        /* Put those bits to low */
+        /* GSM XCBI offset = 0x70 0000
+        0x00 Bit 13 COM_SLV_SW_RSTB 1
+        0x00 Bit 12 QSSP_SW_RSTB 1
+        0x00 Bit 11 RAAE_SW_RSTB 1
+        0x00 Bit 9 RB_1_SW_RSTB 1
+        0x00 Bit 8 SM_SW_RSTB 1
+        */
+        regVal &= ~(0x00003b00);
+        /* host write GSM Configuration and Reset register */
+        pm8001_cw32(pm8001_ha, 2, GSM_CONFIG_RESET, regVal);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("GSM 0x0 (0x00007b88 ==> 0x00004088) - GSM "
+                "Configuration and Reset is set to = 0x%x\n",
+                pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET)));
+
+        /* step 4: */
+        /* disable GSM - Read Address Parity Check */
+        regVal1 = pm8001_cr32(pm8001_ha, 2, GSM_READ_ADDR_PARITY_CHECK);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("GSM 0x700038 - Read Address Parity Check "
+                "Enable = 0x%x\n", regVal1));
+        pm8001_cw32(pm8001_ha, 2, GSM_READ_ADDR_PARITY_CHECK, 0x0);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("GSM 0x700038 - Read Address Parity Check Enable"
+                "is set to = 0x%x\n",
+                pm8001_cr32(pm8001_ha, 2, GSM_READ_ADDR_PARITY_CHECK)));
+
+        /* disable GSM - Write Address Parity Check */
+        regVal2 = pm8001_cr32(pm8001_ha, 2, GSM_WRITE_ADDR_PARITY_CHECK);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("GSM 0x700040 - Write Address Parity Check"
+                " Enable = 0x%x\n", regVal2));
+        pm8001_cw32(pm8001_ha, 2, GSM_WRITE_ADDR_PARITY_CHECK, 0x0);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("GSM 0x700040 - Write Address Parity Check "
+                "Enable is set to = 0x%x\n",
+                pm8001_cr32(pm8001_ha, 2, GSM_WRITE_ADDR_PARITY_CHECK)));
+
+        /* disable GSM - Write Data Parity Check */
+        regVal3 = pm8001_cr32(pm8001_ha, 2, GSM_WRITE_DATA_PARITY_CHECK);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("GSM 0x300048 - Write Data Parity Check"
+                " Enable = 0x%x\n", regVal3));
+        pm8001_cw32(pm8001_ha, 2, GSM_WRITE_DATA_PARITY_CHECK, 0x0);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("GSM 0x300048 - Write Data Parity Check Enable"
+                "is set to = 0x%x\n",
+        pm8001_cr32(pm8001_ha, 2, GSM_WRITE_DATA_PARITY_CHECK)));
+
+        /* step 5: delay 10 usec */
+        udelay(10);
+        /* step 5-b: set GPIO-0 output control to tristate anyway */
+        if (-1 == bar4_shift(pm8001_ha, GPIO_ADDR_BASE)) {
+                PM8001_INIT_DBG(pm8001_ha,
+                                pm8001_printk("Shift Bar4 to 0x%x failed\n",
+                                GPIO_ADDR_BASE));
+                return -1;
+        }
+        regVal = pm8001_cr32(pm8001_ha, 2, GPIO_GPIO_0_0UTPUT_CTL_OFFSET);
+                PM8001_INIT_DBG(pm8001_ha,
+                                pm8001_printk("GPIO Output Control Register:"
+                                " = 0x%x\n", regVal));
+        /* set GPIO-0 output control to tri-state */
+        regVal &= 0xFFFFFFFC;
+        pm8001_cw32(pm8001_ha, 2, GPIO_GPIO_0_0UTPUT_CTL_OFFSET, regVal);
+
+        /* Step 6: Reset the IOP and AAP1 */
+        /* map 0x00000 to BAR4(0x20), BAR2(win) */
+        if (-1 == bar4_shift(pm8001_ha, SPC_TOP_LEVEL_ADDR_BASE)) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("SPC Shift Bar4 to 0x%x failed\n",
+                        SPC_TOP_LEVEL_ADDR_BASE));
+                return -1;
+        }
+        regVal = pm8001_cr32(pm8001_ha, 2, SPC_REG_RESET);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("Top Register before resetting IOP/AAP1"
+                ":= 0x%x\n", regVal));
+        regVal &= ~(SPC_REG_RESET_PCS_IOP_SS | SPC_REG_RESET_PCS_AAP1_SS);
+        pm8001_cw32(pm8001_ha, 2, SPC_REG_RESET, regVal);
+
+        /* step 7: Reset the BDMA/OSSP */
+        regVal = pm8001_cr32(pm8001_ha, 2, SPC_REG_RESET);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("Top Register before resetting BDMA/OSSP"
+                ": = 0x%x\n", regVal));
+        regVal &= ~(SPC_REG_RESET_BDMA_CORE | SPC_REG_RESET_OSSP);
+        pm8001_cw32(pm8001_ha, 2, SPC_REG_RESET, regVal);
+
+        /* step 8: delay 10 usec */
+        udelay(10);
+
+        /* step 9: bring the BDMA and OSSP out of reset */
+        regVal = pm8001_cr32(pm8001_ha, 2, SPC_REG_RESET);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("Top Register before bringing up BDMA/OSSP"
+                ":= 0x%x\n", regVal));
+        regVal |= (SPC_REG_RESET_BDMA_CORE | SPC_REG_RESET_OSSP);
+        pm8001_cw32(pm8001_ha, 2, SPC_REG_RESET, regVal);
+
+        /* step 10: delay 10 usec */
+        udelay(10);
+
+        /* step 11: reads and sets the GSM Configuration and Reset Register */
+        /* map 0x0700000 to BAR4(0x20), BAR2(win) */
+        if (-1 == bar4_shift(pm8001_ha, GSM_ADDR_BASE)) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("SPC Shift Bar4 to 0x%x failed\n",
+                        GSM_ADDR_BASE));
+                return -1;
+        }
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("GSM 0x0 (0x00007b88)-GSM Configuration and "
+                "Reset = 0x%x\n", pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET)));
+        regVal = pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET);
+        /* Put those bits to high */
+        /* GSM XCBI offset = 0x70 0000
+        0x00 Bit 13 COM_SLV_SW_RSTB 1
+        0x00 Bit 12 QSSP_SW_RSTB 1
+        0x00 Bit 11 RAAE_SW_RSTB 1
+        0x00 Bit 9   RB_1_SW_RSTB 1
+        0x00 Bit 8   SM_SW_RSTB 1
+        */
+        regVal |= (GSM_CONFIG_RESET_VALUE);
+        pm8001_cw32(pm8001_ha, 2, GSM_CONFIG_RESET, regVal);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("GSM (0x00004088 ==> 0x00007b88) - GSM"
+                " Configuration and Reset is set to = 0x%x\n",
+                pm8001_cr32(pm8001_ha, 2, GSM_CONFIG_RESET)));
+
+        /* step 12: Restore GSM - Read Address Parity Check */
+        regVal = pm8001_cr32(pm8001_ha, 2, GSM_READ_ADDR_PARITY_CHECK);
+        /* just for debugging */
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("GSM 0x700038 - Read Address Parity Check Enable"
+                " = 0x%x\n", regVal));
+        pm8001_cw32(pm8001_ha, 2, GSM_READ_ADDR_PARITY_CHECK, regVal1);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("GSM 0x700038 - Read Address Parity"
+                " Check Enable is set to = 0x%x\n",
+                pm8001_cr32(pm8001_ha, 2, GSM_READ_ADDR_PARITY_CHECK)));
+        /* Restore GSM - Write Address Parity Check */
+        regVal = pm8001_cr32(pm8001_ha, 2, GSM_WRITE_ADDR_PARITY_CHECK);
+        pm8001_cw32(pm8001_ha, 2, GSM_WRITE_ADDR_PARITY_CHECK, regVal2);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("GSM 0x700040 - Write Address Parity Check"
+                " Enable is set to = 0x%x\n",
+                pm8001_cr32(pm8001_ha, 2, GSM_WRITE_ADDR_PARITY_CHECK)));
+        /* Restore GSM - Write Data Parity Check */
+        regVal = pm8001_cr32(pm8001_ha, 2, GSM_WRITE_DATA_PARITY_CHECK);
+        pm8001_cw32(pm8001_ha, 2, GSM_WRITE_DATA_PARITY_CHECK, regVal3);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("GSM 0x700048 - Write Data Parity Check Enable"
+                "is set to = 0x%x\n",
+                pm8001_cr32(pm8001_ha, 2, GSM_WRITE_DATA_PARITY_CHECK)));
+
+        /* step 13: bring the IOP and AAP1 out of reset */
+        /* map 0x00000 to BAR4(0x20), BAR2(win) */
+        if (-1 == bar4_shift(pm8001_ha, SPC_TOP_LEVEL_ADDR_BASE)) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("Shift Bar4 to 0x%x failed\n",
+                        SPC_TOP_LEVEL_ADDR_BASE));
+                return -1;
+        }
+        regVal = pm8001_cr32(pm8001_ha, 2, SPC_REG_RESET);
+        regVal |= (SPC_REG_RESET_PCS_IOP_SS | SPC_REG_RESET_PCS_AAP1_SS);
+        pm8001_cw32(pm8001_ha, 2, SPC_REG_RESET, regVal);
+
+        /* step 14: delay 10 usec - Normal Mode */
+        udelay(10);
+        /* check Soft Reset Normal mode or Soft Reset HDA mode */
+        if (signature == SPC_SOFT_RESET_SIGNATURE) {
+                /* step 15 (Normal Mode): wait until scratch pad1 register
+                bit 2 toggled */
+                max_wait_count = 2 * 1000 * 1000;/* 2 sec */
+                do {
+                        udelay(1);
+                        regVal = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1) &
+                                SCRATCH_PAD1_RST;
+                } while ((regVal != toggleVal) && (--max_wait_count));
+
+                if (!max_wait_count) {
+                        regVal = pm8001_cr32(pm8001_ha, 0,
+                                MSGU_SCRATCH_PAD_1);
+                        PM8001_FAIL_DBG(pm8001_ha,
+                                pm8001_printk("TIMEOUT : ToggleVal 0x%x,"
+                                "MSGU_SCRATCH_PAD1 = 0x%x\n",
+                                toggleVal, regVal));
+                        PM8001_FAIL_DBG(pm8001_ha,
+                                pm8001_printk("SCRATCH_PAD0 value = 0x%x\n",
+                                pm8001_cr32(pm8001_ha, 0,
+                                MSGU_SCRATCH_PAD_0)));
+                        PM8001_FAIL_DBG(pm8001_ha,
+                                pm8001_printk("SCRATCH_PAD2 value = 0x%x\n",
+                                pm8001_cr32(pm8001_ha, 0,
+                                MSGU_SCRATCH_PAD_2)));
+                        PM8001_FAIL_DBG(pm8001_ha,
+                                pm8001_printk("SCRATCH_PAD3 value = 0x%x\n",
+                                pm8001_cr32(pm8001_ha, 0,
+                                MSGU_SCRATCH_PAD_3)));
+                        return -1;
+                }
+
+                /* step 16 (Normal) - Clear ODMR and ODCR */
+                pm8001_cw32(pm8001_ha, 0, MSGU_ODCR, ODCR_CLEAR_ALL);
+                pm8001_cw32(pm8001_ha, 0, MSGU_ODMR, ODMR_CLEAR_ALL);
+
+                /* step 17 (Normal Mode): wait for the FW and IOP to get
+                ready - 1 sec timeout */
+                /* Wait for the SPC Configuration Table to be ready */
+                if (check_fw_ready(pm8001_ha) == -1) {
+                        regVal = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1);
+                        /* return error if MPI Configuration Table not ready */
+                        PM8001_INIT_DBG(pm8001_ha,
+                                pm8001_printk("FW not ready SCRATCH_PAD1"
+                                " = 0x%x\n", regVal));
+                        regVal = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_2);
+                        /* return error if MPI Configuration Table not ready */
+                        PM8001_INIT_DBG(pm8001_ha,
+                                pm8001_printk("FW not ready SCRATCH_PAD2"
+                                " = 0x%x\n", regVal));
+                        PM8001_INIT_DBG(pm8001_ha,
+                                pm8001_printk("SCRATCH_PAD0 value = 0x%x\n",
+                                pm8001_cr32(pm8001_ha, 0,
+                                MSGU_SCRATCH_PAD_0)));
+                        PM8001_INIT_DBG(pm8001_ha,
+                                pm8001_printk("SCRATCH_PAD3 value = 0x%x\n",
+                                pm8001_cr32(pm8001_ha, 0,
+                                MSGU_SCRATCH_PAD_3)));
+                        return -1;
+                }
+        }
+
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("SPC soft reset Complete\n"));
+        return 0;
+}
+
+static void pm8001_hw_chip_rst(struct pm8001_hba_info *pm8001_ha)
+{
+        u32 i;
+        u32 regVal;
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("chip reset start\n"));
+
+        /* do SPC chip reset. */
+        regVal = pm8001_cr32(pm8001_ha, 1, SPC_REG_RESET);
+        regVal &= ~(SPC_REG_RESET_DEVICE);
+        pm8001_cw32(pm8001_ha, 1, SPC_REG_RESET, regVal);
+
+        /* delay 10 usec */
+        udelay(10);
+
+        /* bring chip reset out of reset */
+        regVal = pm8001_cr32(pm8001_ha, 1, SPC_REG_RESET);
+        regVal |= SPC_REG_RESET_DEVICE;
+        pm8001_cw32(pm8001_ha, 1, SPC_REG_RESET, regVal);
+
+        /* delay 10 usec */
+        udelay(10);
+
+        /* wait for 20 msec until the firmware gets reloaded */
+        i = 20;
+        do {
+                mdelay(1);
+        } while ((--i) != 0);
+
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("chip reset finished\n"));
+}
+
+/**
+ * pm8001_chip_iounmap - which maped when initilized.
+ * @pm8001_ha: our hba card information
+ */
+static void pm8001_chip_iounmap(struct pm8001_hba_info *pm8001_ha)
+{
+        s8 bar, logical = 0;
+        for (bar = 0; bar < 6; bar++) {
+                /*
+                ** logical BARs for SPC:
+                ** bar 0 and 1 - logical BAR0
+                ** bar 2 and 3 - logical BAR1
+                ** bar4 - logical BAR2
+                ** bar5 - logical BAR3
+                ** Skip the appropriate assignments:
+                */
+                if ((bar == 1) || (bar == 3))
+                        continue;
+                if (pm8001_ha->io_mem[logical].memvirtaddr) {
+                        iounmap(pm8001_ha->io_mem[logical].memvirtaddr);
+                        logical++;
+                }
+        }
+}
+
+/**
+ * pm8001_chip_interrupt_enable - enable PM8001 chip interrupt
+ * @pm8001_ha: our hba card information
+ */
+static void
+pm8001_chip_intx_interrupt_enable(struct pm8001_hba_info *pm8001_ha)
+{
+        pm8001_cw32(pm8001_ha, 0, MSGU_ODMR, ODMR_CLEAR_ALL);
+        pm8001_cw32(pm8001_ha, 0, MSGU_ODCR, ODCR_CLEAR_ALL);
+}
+
+ /**
+  * pm8001_chip_intx_interrupt_disable- disable PM8001 chip interrupt
+  * @pm8001_ha: our hba card information
+  */
+static void
+pm8001_chip_intx_interrupt_disable(struct pm8001_hba_info *pm8001_ha)
+{
+        pm8001_cw32(pm8001_ha, 0, MSGU_ODMR, ODMR_MASK_ALL);
+}
+
+/**
+ * pm8001_chip_msix_interrupt_enable - enable PM8001 chip interrupt
+ * @pm8001_ha: our hba card information
+ */
+static void
+pm8001_chip_msix_interrupt_enable(struct pm8001_hba_info *pm8001_ha,
+        u32 int_vec_idx)
+{
+        u32 msi_index;
+        u32 value;
+        msi_index = int_vec_idx * MSIX_TABLE_ELEMENT_SIZE;
+        msi_index += MSIX_TABLE_BASE;
+        pm8001_cw32(pm8001_ha, 0, msi_index, MSIX_INTERRUPT_ENABLE);
+        value = (1 << int_vec_idx);
+        pm8001_cw32(pm8001_ha, 0,  MSGU_ODCR, value);
+
+}
+
+/**
+ * pm8001_chip_msix_interrupt_disable - disable PM8001 chip interrupt
+ * @pm8001_ha: our hba card information
+ */
+static void
+pm8001_chip_msix_interrupt_disable(struct pm8001_hba_info *pm8001_ha,
+        u32 int_vec_idx)
+{
+        u32 msi_index;
+        msi_index = int_vec_idx * MSIX_TABLE_ELEMENT_SIZE;
+        msi_index += MSIX_TABLE_BASE;
+        pm8001_cw32(pm8001_ha, 0,  msi_index, MSIX_INTERRUPT_DISABLE);
+
+}
+/**
+ * pm8001_chip_interrupt_enable - enable PM8001 chip interrupt
+ * @pm8001_ha: our hba card information
+ */
+static void
+pm8001_chip_interrupt_enable(struct pm8001_hba_info *pm8001_ha)
+{
+#ifdef PM8001_USE_MSIX
+        pm8001_chip_msix_interrupt_enable(pm8001_ha, 0);
+        return;
+#endif
+        pm8001_chip_intx_interrupt_enable(pm8001_ha);
+
+}
+
+/**
+ * pm8001_chip_intx_interrupt_disable- disable PM8001 chip interrupt
+ * @pm8001_ha: our hba card information
+ */
+static void
+pm8001_chip_interrupt_disable(struct pm8001_hba_info *pm8001_ha)
+{
+#ifdef PM8001_USE_MSIX
+        pm8001_chip_msix_interrupt_disable(pm8001_ha, 0);
+        return;
+#endif
+        pm8001_chip_intx_interrupt_disable(pm8001_ha);
+
+}
+
+/**
+ * mpi_msg_free_get- get the free message buffer for transfer inbound queue.
+ * @circularQ: the inbound queue  we want to transfer to HBA.
+ * @messageSize: the message size of this transfer, normally it is 64 bytes
+ * @messagePtr: the pointer to message.
+ */
+static int mpi_msg_free_get(struct inbound_queue_table *circularQ,
+                            u16 messageSize, void **messagePtr)
+{
+        u32 offset, consumer_index;
+        struct mpi_msg_hdr *msgHeader;
+        u8 bcCount = 1; /* only support single buffer */
+
+        /* Checks is the requested message size can be allocated in this queue*/
+        if (messageSize > 64) {
+                *messagePtr = NULL;
+                return -1;
+        }
+
+        /* Stores the new consumer index */
+        consumer_index = pm8001_read_32(circularQ->ci_virt);
+        circularQ->consumer_index = cpu_to_le32(consumer_index);
+        if (((circularQ->producer_idx + bcCount) % 256) ==
+                circularQ->consumer_index) {
+                *messagePtr = NULL;
+                return -1;
+        }
+        /* get memory IOMB buffer address */
+        offset = circularQ->producer_idx * 64;
+        /* increment to next bcCount element */
+        circularQ->producer_idx = (circularQ->producer_idx + bcCount) % 256;
+        /* Adds that distance to the base of the region virtual address plus
+        the message header size*/
+        msgHeader = (struct mpi_msg_hdr *)(circularQ->base_virt + offset);
+        *messagePtr = ((void *)msgHeader) + sizeof(struct mpi_msg_hdr);
+        return 0;
+}
+
+/**
+ * mpi_build_cmd- build the message queue for transfer, update the PI to FW
+ * to tell the fw to get this message from IOMB.
+ * @pm8001_ha: our hba card information
+ * @circularQ: the inbound queue we want to transfer to HBA.
+ * @opCode: the operation code represents commands which LLDD and fw recognized.
+ * @payload: the command payload of each operation command.
+ */
+static int mpi_build_cmd(struct pm8001_hba_info *pm8001_ha,
+                         struct inbound_queue_table *circularQ,
+                         u32 opCode, void *payload)
+{
+        u32 Header = 0, hpriority = 0, bc = 1, category = 0x02;
+        u32 responseQueue = 0;
+        void *pMessage;
+
+        if (mpi_msg_free_get(circularQ, 64, &pMessage) < 0) {
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("No free mpi buffer \n"));
+                return -1;
+        }
+        BUG_ON(!payload);
+        /*Copy to the payload*/
+        memcpy(pMessage, payload, (64 - sizeof(struct mpi_msg_hdr)));
+
+        /*Build the header*/
+        Header = ((1 << 31) | (hpriority << 30) | ((bc & 0x1f) << 24)
+                | ((responseQueue & 0x3F) << 16)
+                | ((category & 0xF) << 12) | (opCode & 0xFFF));
+
+        pm8001_write_32((pMessage - 4), 0, cpu_to_le32(Header));
+        /*Update the PI to the firmware*/
+        pm8001_cw32(pm8001_ha, circularQ->pi_pci_bar,
+                circularQ->pi_offset, circularQ->producer_idx);
+        PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("after PI= %d CI= %d \n", circularQ->producer_idx,
+                circularQ->consumer_index));
+        return 0;
+}
+
+static u32 mpi_msg_free_set(struct pm8001_hba_info *pm8001_ha, void *pMsg,
+                            struct outbound_queue_table *circularQ, u8 bc)
+{
+        u32 producer_index;
+        struct mpi_msg_hdr *msgHeader;
+        struct mpi_msg_hdr *pOutBoundMsgHeader;
+
+        msgHeader = (struct mpi_msg_hdr *)(pMsg - sizeof(struct mpi_msg_hdr));
+        pOutBoundMsgHeader = (struct mpi_msg_hdr *)(circularQ->base_virt +
+                                circularQ->consumer_idx * 64);
+        if (pOutBoundMsgHeader != msgHeader) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("consumer_idx = %d msgHeader = %p\n",
+                        circularQ->consumer_idx, msgHeader));
+
+                /* Update the producer index from SPC */
+                producer_index = pm8001_read_32(circularQ->pi_virt);
+                circularQ->producer_index = cpu_to_le32(producer_index);
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("consumer_idx = %d producer_index = %d"
+                        "msgHeader = %p\n", circularQ->consumer_idx,
+                        circularQ->producer_index, msgHeader));
+                return 0;
+        }
+        /* free the circular queue buffer elements associated with the message*/
+        circularQ->consumer_idx = (circularQ->consumer_idx + bc) % 256;
+        /* update the CI of outbound queue */
+        pm8001_cw32(pm8001_ha, circularQ->ci_pci_bar, circularQ->ci_offset,
+                circularQ->consumer_idx);
+        /* Update the producer index from SPC*/
+        producer_index = pm8001_read_32(circularQ->pi_virt);
+        circularQ->producer_index = cpu_to_le32(producer_index);
+        PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk(" CI=%d PI=%d\n", circularQ->consumer_idx,
+                circularQ->producer_index));
+        return 0;
+}
+
+/**
+ * mpi_msg_consume- get the MPI message from  outbound queue message table.
+ * @pm8001_ha: our hba card information
+ * @circularQ: the outbound queue  table.
+ * @messagePtr1: the message contents of this outbound message.
+ * @pBC: the message size.
+ */
+static u32 mpi_msg_consume(struct pm8001_hba_info *pm8001_ha,
+                           struct outbound_queue_table *circularQ,
+                           void **messagePtr1, u8 *pBC)
+{
+        struct mpi_msg_hdr      *msgHeader;
+        __le32  msgHeader_tmp;
+        u32 header_tmp;
+        do {
+                /* If there are not-yet-delivered messages ... */
+                if (circularQ->producer_index != circularQ->consumer_idx) {
+                        /*Get the pointer to the circular queue buffer element*/
+                        msgHeader = (struct mpi_msg_hdr *)
+                                (circularQ->base_virt +
+                                circularQ->consumer_idx * 64);
+                        /* read header */
+                        header_tmp = pm8001_read_32(msgHeader);
+                        msgHeader_tmp = cpu_to_le32(header_tmp);
+                        if (0 != (msgHeader_tmp & 0x80000000)) {
+                                if (OPC_OUB_SKIP_ENTRY !=
+                                        (msgHeader_tmp & 0xfff)) {
+                                        *messagePtr1 =
+                                                ((u8 *)msgHeader) +
+                                                sizeof(struct mpi_msg_hdr);
+                                        *pBC = (u8)((msgHeader_tmp >> 24) &
+                                                0x1f);
+                                        PM8001_IO_DBG(pm8001_ha,
+                                                pm8001_printk(": CI=%d PI=%d "
+                                                "msgHeader=%x\n",
+                                                circularQ->consumer_idx,
+                                                circularQ->producer_index,
+                                                msgHeader_tmp));
+                                        return MPI_IO_STATUS_SUCCESS;
+                                } else {
+                                        circularQ->consumer_idx =
+                                                (circularQ->consumer_idx +
+                                                ((msgHeader_tmp >> 24) & 0x1f))
+                                                % 256;
+                                        msgHeader_tmp = 0;
+                                        pm8001_write_32(msgHeader, 0, 0);
+                                        /* update the CI of outbound queue */
+                                        pm8001_cw32(pm8001_ha,
+                                                circularQ->ci_pci_bar,
+                                                circularQ->ci_offset,
+                                                circularQ->consumer_idx);
+                                }
+                        } else {
+                                circularQ->consumer_idx =
+                                        (circularQ->consumer_idx +
+                                        ((msgHeader_tmp >> 24) & 0x1f)) % 256;
+                                msgHeader_tmp = 0;
+                                pm8001_write_32(msgHeader, 0, 0);
+                                /* update the CI of outbound queue */
+                                pm8001_cw32(pm8001_ha, circularQ->ci_pci_bar,
+                                        circularQ->ci_offset,
+                                        circularQ->consumer_idx);
+                                return MPI_IO_STATUS_FAIL;
+                        }
+                } else {
+                        u32 producer_index;
+                        void *pi_virt = circularQ->pi_virt;
+                        /* Update the producer index from SPC */
+                        producer_index = pm8001_read_32(pi_virt);
+                        circularQ->producer_index = cpu_to_le32(producer_index);
+                }
+        } while (circularQ->producer_index != circularQ->consumer_idx);
+        /* while we don't have any more not-yet-delivered message */
+        /* report empty */
+        return MPI_IO_STATUS_BUSY;
+}
+
+static void pm8001_work_queue(struct work_struct *work)
+{
+        struct delayed_work *dw = container_of(work, struct delayed_work, work);
+        struct pm8001_wq *wq = container_of(dw, struct pm8001_wq, work_q);
+        struct pm8001_device *pm8001_dev;
+        struct domain_device    *dev;
+
+        switch (wq->handler) {
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+                pm8001_dev = wq->data;
+                dev = pm8001_dev->sas_device;
+                pm8001_I_T_nexus_reset(dev);
+                break;
+        case IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY:
+                pm8001_dev = wq->data;
+                dev = pm8001_dev->sas_device;
+                pm8001_I_T_nexus_reset(dev);
+                break;
+        case IO_DS_IN_ERROR:
+                pm8001_dev = wq->data;
+                dev = pm8001_dev->sas_device;
+                pm8001_I_T_nexus_reset(dev);
+                break;
+        case IO_DS_NON_OPERATIONAL:
+                pm8001_dev = wq->data;
+                dev = pm8001_dev->sas_device;
+                pm8001_I_T_nexus_reset(dev);
+                break;
+        }
+        list_del(&wq->entry);
+        kfree(wq);
+}
+
+static int pm8001_handle_event(struct pm8001_hba_info *pm8001_ha, void *data,
+                               int handler)
+{
+        struct pm8001_wq *wq;
+        int ret = 0;
+
+        wq = kmalloc(sizeof(struct pm8001_wq), GFP_ATOMIC);
+        if (wq) {
+                wq->pm8001_ha = pm8001_ha;
+                wq->data = data;
+                wq->handler = handler;
+                INIT_DELAYED_WORK(&wq->work_q, pm8001_work_queue);
+                list_add_tail(&wq->entry, &pm8001_ha->wq_list);
+                schedule_delayed_work(&wq->work_q, 0);
+        } else
+                ret = -ENOMEM;
+
+        return ret;
+}
+
+/**
+ * mpi_ssp_completion- process the event that FW response to the SSP request.
+ * @pm8001_ha: our hba card information
+ * @piomb: the message contents of this outbound message.
+ *
+ * When FW has completed a ssp request for example a IO request, after it has
+ * filled the SG data with the data, it will trigger this event represent
+ * that he has finished the job,please check the coresponding buffer.
+ * So we will tell the caller who maybe waiting the result to tell upper layer
+ * that the task has been finished.
+ */
+static void
+mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+{
+        struct sas_task *t;
+        struct pm8001_ccb_info *ccb;
+        unsigned long flags;
+        u32 status;
+        u32 param;
+        u32 tag;
+        struct ssp_completion_resp *psspPayload;
+        struct task_status_struct *ts;
+        struct ssp_response_iu *iu;
+        struct pm8001_device *pm8001_dev;
+        psspPayload = (struct ssp_completion_resp *)(piomb + 4);
+        status = le32_to_cpu(psspPayload->status);
+        tag = le32_to_cpu(psspPayload->tag);
+        ccb = &pm8001_ha->ccb_info[tag];
+        pm8001_dev = ccb->device;
+        param = le32_to_cpu(psspPayload->param);
+
+        t = ccb->task;
+
+        if (status && status != IO_UNDERFLOW)
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("sas IO status 0x%x\n", status));
+        if (unlikely(!t || !t->lldd_task || !t->dev))
+                return;
+        ts = &t->task_status;
+        switch (status) {
+        case IO_SUCCESS:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_SUCCESS"
+                        ",param = %d \n", param));
+                if (param == 0) {
+                        ts->resp = SAS_TASK_COMPLETE;
+                        ts->stat = SAM_GOOD;
+                } else {
+                        ts->resp = SAS_TASK_COMPLETE;
+                        ts->stat = SAS_PROTO_RESPONSE;
+                        ts->residual = param;
+                        iu = &psspPayload->ssp_resp_iu;
+                        sas_ssp_task_response(pm8001_ha->dev, t, iu);
+                }
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_ABORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_ABORTED IOMB Tag \n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_ABORTED_TASK;
+                break;
+        case IO_UNDERFLOW:
+                /* SSP Completion with error */
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW"
+                        ",param = %d \n", param));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_UNDERRUN;
+                ts->residual = param;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_NO_DEVICE:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_NO_DEVICE\n"));
+                ts->resp = SAS_TASK_UNDELIVERED;
+                ts->stat = SAS_PHY_DOWN;
+                break;
+        case IO_XFER_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        case IO_XFER_ERROR_PHY_NOT_READY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_EPROTO;
+                break;
+        case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                break;
+        case IO_OPEN_CNX_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                if (!t->uldd_task)
+                        pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+                break;
+        case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+                break;
+        case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_CONNECTION_RATE_"
+                        "NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+                break;
+        case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
+                ts->resp = SAS_TASK_UNDELIVERED;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+                break;
+        case IO_XFER_ERROR_NAK_RECEIVED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_NAK_R_ERR;
+                break;
+        case IO_XFER_ERROR_DMA:
+                PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("IO_XFER_ERROR_DMA\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        case IO_XFER_OPEN_RETRY_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_XFER_ERROR_OFFSET_MISMATCH:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_OFFSET_MISMATCH\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        case IO_PORT_IN_RESET:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_PORT_IN_RESET\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        case IO_DS_NON_OPERATIONAL:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_DS_NON_OPERATIONAL\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                if (!t->uldd_task)
+                        pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_DS_NON_OPERATIONAL);
+                break;
+        case IO_DS_IN_RECOVERY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_DS_IN_RECOVERY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        case IO_TM_TAG_NOT_FOUND:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_TM_TAG_NOT_FOUND\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        case IO_SSP_EXT_IU_ZERO_LEN_ERROR:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_SSP_EXT_IU_ZERO_LEN_ERROR\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        case IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+        default:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("Unknown status 0x%x\n", status));
+                /* not allowed case. Therefore, return failed status */
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        }
+        PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("scsi_status = %x \n ",
+                psspPayload->ssp_resp_iu.status));
+        spin_lock_irqsave(&t->task_state_lock, flags);
+        t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+        t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+        t->task_state_flags |= SAS_TASK_STATE_DONE;
+        if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("task 0x%p done with"
+                        " io_status 0x%x resp 0x%x "
+                        "stat 0x%x but aborted by upper layer!\n",
+                        t, status, ts->resp, ts->stat));
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+        } else {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                mb();/* in order to force CPU ordering */
+                t->task_done(t);
+        }
+}
+
+/*See the comments for mpi_ssp_completion */
+static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+{
+        struct sas_task *t;
+        unsigned long flags;
+        struct task_status_struct *ts;
+        struct pm8001_ccb_info *ccb;
+        struct pm8001_device *pm8001_dev;
+        struct ssp_event_resp *psspPayload =
+                (struct ssp_event_resp *)(piomb + 4);
+        u32 event = le32_to_cpu(psspPayload->event);
+        u32 tag = le32_to_cpu(psspPayload->tag);
+        u32 port_id = le32_to_cpu(psspPayload->port_id);
+        u32 dev_id = le32_to_cpu(psspPayload->device_id);
+
+        ccb = &pm8001_ha->ccb_info[tag];
+        t = ccb->task;
+        pm8001_dev = ccb->device;
+        if (event)
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("sas IO status 0x%x\n", event));
+        if (unlikely(!t || !t->lldd_task || !t->dev))
+                return;
+        ts = &t->task_status;
+        PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("port_id = %x,device_id = %x\n",
+                port_id, dev_id));
+        switch (event) {
+        case IO_OVERFLOW:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n");)
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                ts->residual = 0;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_XFER_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_INTERRUPTED;
+                break;
+        case IO_XFER_ERROR_PHY_NOT_READY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_PROTOCOL_NOT"
+                        "_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_EPROTO;
+                break;
+        case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                break;
+        case IO_OPEN_CNX_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                if (!t->uldd_task)
+                        pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+                break;
+        case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+                break;
+        case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_CONNECTION_RATE_"
+                        "NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+                break;
+        case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+                break;
+        case IO_XFER_ERROR_NAK_RECEIVED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_NAK_R_ERR;
+                break;
+        case IO_XFER_OPEN_RETRY_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_XFER_ERROR_UNEXPECTED_PHASE:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_UNEXPECTED_PHASE\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        case IO_XFER_ERROR_XFER_RDY_OVERRUN:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_XFER_RDY_OVERRUN\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        case IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED:
+                PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        case IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        case IO_XFER_ERROR_OFFSET_MISMATCH:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_OFFSET_MISMATCH\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        case IO_XFER_ERROR_XFER_ZERO_DATA_LEN:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        case IO_XFER_CMD_FRAME_ISSUED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("  IO_XFER_CMD_FRAME_ISSUED\n"));
+                return;
+        default:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("Unknown status 0x%x\n", event));
+                /* not allowed case. Therefore, return failed status */
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        }
+        spin_lock_irqsave(&t->task_state_lock, flags);
+        t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+        t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+        t->task_state_flags |= SAS_TASK_STATE_DONE;
+        if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("task 0x%p done with"
+                        " event 0x%x resp 0x%x "
+                        "stat 0x%x but aborted by upper layer!\n",
+                        t, event, ts->resp, ts->stat));
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+        } else {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                mb();/* in order to force CPU ordering */
+                t->task_done(t);
+        }
+}
+
+/*See the comments for mpi_ssp_completion */
+static void
+mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct sas_task *t;
+        struct pm8001_ccb_info *ccb;
+        unsigned long flags = 0;
+        u32 param;
+        u32 status;
+        u32 tag;
+        struct sata_completion_resp *psataPayload;
+        struct task_status_struct *ts;
+        struct ata_task_resp *resp ;
+        u32 *sata_resp;
+        struct pm8001_device *pm8001_dev;
+
+        psataPayload = (struct sata_completion_resp *)(piomb + 4);
+        status = le32_to_cpu(psataPayload->status);
+        tag = le32_to_cpu(psataPayload->tag);
+
+        ccb = &pm8001_ha->ccb_info[tag];
+        param = le32_to_cpu(psataPayload->param);
+        t = ccb->task;
+        ts = &t->task_status;
+        pm8001_dev = ccb->device;
+        if (status)
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("sata IO status 0x%x\n", status));
+        if (unlikely(!t || !t->lldd_task || !t->dev))
+                return;
+
+        switch (status) {
+        case IO_SUCCESS:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_SUCCESS\n"));
+                if (param == 0) {
+                        ts->resp = SAS_TASK_COMPLETE;
+                        ts->stat = SAM_GOOD;
+                } else {
+                        u8 len;
+                        ts->resp = SAS_TASK_COMPLETE;
+                        ts->stat = SAS_PROTO_RESPONSE;
+                        ts->residual = param;
+                        PM8001_IO_DBG(pm8001_ha,
+                                pm8001_printk("SAS_PROTO_RESPONSE len = %d\n",
+                                param));
+                        sata_resp = &psataPayload->sata_resp[0];
+                        resp = (struct ata_task_resp *)ts->buf;
+                        if (t->ata_task.dma_xfer == 0 &&
+                        t->data_dir == PCI_DMA_FROMDEVICE) {
+                                len = sizeof(struct pio_setup_fis);
+                                PM8001_IO_DBG(pm8001_ha,
+                                pm8001_printk("PIO read len = %d\n", len));
+                        } else if (t->ata_task.use_ncq) {
+                                len = sizeof(struct set_dev_bits_fis);
+                                PM8001_IO_DBG(pm8001_ha,
+                                        pm8001_printk("FPDMA len = %d\n", len));
+                        } else {
+                                len = sizeof(struct dev_to_host_fis);
+                                PM8001_IO_DBG(pm8001_ha,
+                                pm8001_printk("other len = %d\n", len));
+                        }
+                        if (SAS_STATUS_BUF_SIZE >= sizeof(*resp)) {
+                                resp->frame_len = len;
+                                memcpy(&resp->ending_fis[0], sata_resp, len);
+                                ts->buf_valid_size = sizeof(*resp);
+                        } else
+                                PM8001_IO_DBG(pm8001_ha,
+                                        pm8001_printk("response to large \n"));
+                }
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_ABORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_ABORTED IOMB Tag \n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_ABORTED_TASK;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+                /* following cases are to do cases */
+        case IO_UNDERFLOW:
+                /* SATA Completion with error */
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_UNDERFLOW param = %d\n", param));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_UNDERRUN;
+                ts->residual =  param;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_NO_DEVICE:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_NO_DEVICE\n"));
+                ts->resp = SAS_TASK_UNDELIVERED;
+                ts->stat = SAS_PHY_DOWN;
+                break;
+        case IO_XFER_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_INTERRUPTED;
+                break;
+        case IO_XFER_ERROR_PHY_NOT_READY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_PROTOCOL_NOT"
+                        "_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_EPROTO;
+                break;
+        case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                break;
+        case IO_OPEN_CNX_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_CONT0;
+                break;
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                if (!t->uldd_task) {
+                        pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+                        ts->resp = SAS_TASK_UNDELIVERED;
+                        ts->stat = SAS_QUEUE_FULL;
+                        pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                        mb();/*in order to force CPU ordering*/
+                        spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                        t->task_done(t);
+                        spin_lock_irqsave(&pm8001_ha->lock, flags);
+                        return;
+                }
+                break;
+        case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
+                ts->resp = SAS_TASK_UNDELIVERED;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+                if (!t->uldd_task) {
+                        pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+                        ts->resp = SAS_TASK_UNDELIVERED;
+                        ts->stat = SAS_QUEUE_FULL;
+                        pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                        mb();/*ditto*/
+                        spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                        t->task_done(t);
+                        spin_lock_irqsave(&pm8001_ha->lock, flags);
+                        return;
+                }
+                break;
+        case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_CONNECTION_RATE_"
+                        "NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+                break;
+        case IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_STP_RESOURCES"
+                        "_BUSY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                if (!t->uldd_task) {
+                        pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY);
+                        ts->resp = SAS_TASK_UNDELIVERED;
+                        ts->stat = SAS_QUEUE_FULL;
+                        pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                        mb();/* ditto*/
+                        spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                        t->task_done(t);
+                        spin_lock_irqsave(&pm8001_ha->lock, flags);
+                        return;
+                }
+                break;
+        case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+                break;
+        case IO_XFER_ERROR_NAK_RECEIVED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_NAK_R_ERR;
+                break;
+        case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_NAK_R_ERR;
+                break;
+        case IO_XFER_ERROR_DMA:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_DMA\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_ABORTED_TASK;
+                break;
+        case IO_XFER_ERROR_SATA_LINK_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_SATA_LINK_TIMEOUT\n"));
+                ts->resp = SAS_TASK_UNDELIVERED;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                break;
+        case IO_XFER_ERROR_REJECTED_NCQ_MODE:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_REJECTED_NCQ_MODE\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_UNDERRUN;
+                break;
+        case IO_XFER_OPEN_RETRY_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_PORT_IN_RESET:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_PORT_IN_RESET\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                break;
+        case IO_DS_NON_OPERATIONAL:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_DS_NON_OPERATIONAL\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                if (!t->uldd_task) {
+                        pm8001_handle_event(pm8001_ha, pm8001_dev,
+                                    IO_DS_NON_OPERATIONAL);
+                        ts->resp = SAS_TASK_UNDELIVERED;
+                        ts->stat = SAS_QUEUE_FULL;
+                        pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                        mb();/*ditto*/
+                        spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                        t->task_done(t);
+                        spin_lock_irqsave(&pm8001_ha->lock, flags);
+                        return;
+                }
+                break;
+        case IO_DS_IN_RECOVERY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("  IO_DS_IN_RECOVERY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                break;
+        case IO_DS_IN_ERROR:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_DS_IN_ERROR\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                if (!t->uldd_task) {
+                        pm8001_handle_event(pm8001_ha, pm8001_dev,
+                                    IO_DS_IN_ERROR);
+                        ts->resp = SAS_TASK_UNDELIVERED;
+                        ts->stat = SAS_QUEUE_FULL;
+                        pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                        mb();/*ditto*/
+                        spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                        t->task_done(t);
+                        spin_lock_irqsave(&pm8001_ha->lock, flags);
+                        return;
+                }
+                break;
+        case IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+        default:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("Unknown status 0x%x\n", status));
+                /* not allowed case. Therefore, return failed status */
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                break;
+        }
+        spin_lock_irqsave(&t->task_state_lock, flags);
+        t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+        t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+        t->task_state_flags |= SAS_TASK_STATE_DONE;
+        if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("task 0x%p done with io_status 0x%x"
+                        " resp 0x%x stat 0x%x but aborted by upper layer!\n",
+                        t, status, ts->resp, ts->stat));
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+        } else if (t->uldd_task) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                mb();/* ditto */
+                spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                t->task_done(t);
+                spin_lock_irqsave(&pm8001_ha->lock, flags);
+        } else if (!t->uldd_task) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                mb();/*ditto*/
+                spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                t->task_done(t);
+                spin_lock_irqsave(&pm8001_ha->lock, flags);
+        }
+}
+
+/*See the comments for mpi_ssp_completion */
+static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+{
+        struct sas_task *t;
+        unsigned long flags = 0;
+        struct task_status_struct *ts;
+        struct pm8001_ccb_info *ccb;
+        struct pm8001_device *pm8001_dev;
+        struct sata_event_resp *psataPayload =
+                (struct sata_event_resp *)(piomb + 4);
+        u32 event = le32_to_cpu(psataPayload->event);
+        u32 tag = le32_to_cpu(psataPayload->tag);
+        u32 port_id = le32_to_cpu(psataPayload->port_id);
+        u32 dev_id = le32_to_cpu(psataPayload->device_id);
+
+        ccb = &pm8001_ha->ccb_info[tag];
+        t = ccb->task;
+        pm8001_dev = ccb->device;
+        if (event)
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("sata IO status 0x%x\n", event));
+        if (unlikely(!t || !t->lldd_task || !t->dev))
+                return;
+        ts = &t->task_status;
+        PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("port_id = %x,device_id = %x\n",
+                port_id, dev_id));
+        switch (event) {
+        case IO_OVERFLOW:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                ts->residual = 0;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_XFER_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_INTERRUPTED;
+                break;
+        case IO_XFER_ERROR_PHY_NOT_READY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_PROTOCOL_NOT"
+                        "_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_EPROTO;
+                break;
+        case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                break;
+        case IO_OPEN_CNX_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_CONT0;
+                break;
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
+                ts->resp = SAS_TASK_UNDELIVERED;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                if (!t->uldd_task) {
+                        pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+                        ts->resp = SAS_TASK_COMPLETE;
+                        ts->stat = SAS_QUEUE_FULL;
+                        pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                        mb();/*ditto*/
+                        spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                        t->task_done(t);
+                        spin_lock_irqsave(&pm8001_ha->lock, flags);
+                        return;
+                }
+                break;
+        case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
+                ts->resp = SAS_TASK_UNDELIVERED;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+                break;
+        case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_CONNECTION_RATE_"
+                        "NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+                break;
+        case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+                break;
+        case IO_XFER_ERROR_NAK_RECEIVED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_NAK_R_ERR;
+                break;
+        case IO_XFER_ERROR_PEER_ABORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_PEER_ABORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_NAK_R_ERR;
+                break;
+        case IO_XFER_ERROR_REJECTED_NCQ_MODE:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_REJECTED_NCQ_MODE\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_UNDERRUN;
+                break;
+        case IO_XFER_OPEN_RETRY_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_XFER_ERROR_UNEXPECTED_PHASE:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_UNEXPECTED_PHASE\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_XFER_ERROR_XFER_RDY_OVERRUN:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_XFER_RDY_OVERRUN\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED:
+                PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_XFER_ERROR_OFFSET_MISMATCH:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_OFFSET_MISMATCH\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_XFER_ERROR_XFER_ZERO_DATA_LEN:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_XFER_CMD_FRAME_ISSUED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_CMD_FRAME_ISSUED\n"));
+                break;
+        case IO_XFER_PIO_SETUP_ERROR:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_PIO_SETUP_ERROR\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        default:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("Unknown status 0x%x\n", event));
+                /* not allowed case. Therefore, return failed status */
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        }
+        spin_lock_irqsave(&t->task_state_lock, flags);
+        t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+        t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+        t->task_state_flags |= SAS_TASK_STATE_DONE;
+        if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("task 0x%p done with io_status 0x%x"
+                        " resp 0x%x stat 0x%x but aborted by upper layer!\n",
+                        t, event, ts->resp, ts->stat));
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+        } else if (t->uldd_task) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                mb();/* ditto */
+                spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                t->task_done(t);
+                spin_lock_irqsave(&pm8001_ha->lock, flags);
+        } else if (!t->uldd_task) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                mb();/*ditto*/
+                spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                t->task_done(t);
+                spin_lock_irqsave(&pm8001_ha->lock, flags);
+        }
+}
+
+/*See the comments for mpi_ssp_completion */
+static void
+mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        u32 param;
+        struct sas_task *t;
+        struct pm8001_ccb_info *ccb;
+        unsigned long flags;
+        u32 status;
+        u32 tag;
+        struct smp_completion_resp *psmpPayload;
+        struct task_status_struct *ts;
+        struct pm8001_device *pm8001_dev;
+
+        psmpPayload = (struct smp_completion_resp *)(piomb + 4);
+        status = le32_to_cpu(psmpPayload->status);
+        tag = le32_to_cpu(psmpPayload->tag);
+
+        ccb = &pm8001_ha->ccb_info[tag];
+        param = le32_to_cpu(psmpPayload->param);
+        t = ccb->task;
+        ts = &t->task_status;
+        pm8001_dev = ccb->device;
+        if (status)
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("smp IO status 0x%x\n", status));
+        if (unlikely(!t || !t->lldd_task || !t->dev))
+                return;
+
+        switch (status) {
+        case IO_SUCCESS:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_SUCCESS\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAM_GOOD;
+        if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_ABORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_ABORTED IOMB\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_ABORTED_TASK;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_OVERFLOW:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                ts->residual = 0;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_NO_DEVICE:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_NO_DEVICE\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_PHY_DOWN;
+                break;
+        case IO_ERROR_HW_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_ERROR_HW_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAM_BUSY;
+                break;
+        case IO_XFER_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAM_BUSY;
+                break;
+        case IO_XFER_ERROR_PHY_NOT_READY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAM_BUSY;
+                break;
+        case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                break;
+        case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                break;
+        case IO_OPEN_CNX_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_CONT0;
+                break;
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+                break;
+        case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+                break;
+        case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_CONNECTION_RATE_"
+                        "NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+                break;
+        case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                       pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+                break;
+        case IO_XFER_ERROR_RX_FRAME:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_RX_FRAME\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                break;
+        case IO_XFER_OPEN_RETRY_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_ERROR_INTERNAL_SMP_RESOURCE:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_ERROR_INTERNAL_SMP_RESOURCE\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_QUEUE_FULL;
+                break;
+        case IO_PORT_IN_RESET:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_PORT_IN_RESET\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_DS_NON_OPERATIONAL:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_DS_NON_OPERATIONAL\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                break;
+        case IO_DS_IN_RECOVERY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_DS_IN_RECOVERY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        default:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("Unknown status 0x%x\n", status));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                /* not allowed case. Therefore, return failed status */
+                break;
+        }
+        spin_lock_irqsave(&t->task_state_lock, flags);
+        t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+        t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+        t->task_state_flags |= SAS_TASK_STATE_DONE;
+        if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("task 0x%p done with"
+                        " io_status 0x%x resp 0x%x "
+                        "stat 0x%x but aborted by upper layer!\n",
+                        t, status, ts->resp, ts->stat));
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+        } else {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                mb();/* in order to force CPU ordering */
+                t->task_done(t);
+        }
+}
+
+static void
+mpi_set_dev_state_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct set_dev_state_resp *pPayload =
+                (struct set_dev_state_resp *)(piomb + 4);
+        u32 tag = le32_to_cpu(pPayload->tag);
+        struct pm8001_ccb_info *ccb = &pm8001_ha->ccb_info[tag];
+        struct pm8001_device *pm8001_dev = ccb->device;
+        u32 status = le32_to_cpu(pPayload->status);
+        u32 device_id = le32_to_cpu(pPayload->device_id);
+        u8 pds = le32_to_cpu(pPayload->pds_nds) | PDS_BITS;
+        u8 nds = le32_to_cpu(pPayload->pds_nds) | NDS_BITS;
+        PM8001_MSG_DBG(pm8001_ha, pm8001_printk("Set device id = 0x%x state "
+                "from 0x%x to 0x%x status = 0x%x!\n",
+                device_id, pds, nds, status));
+        complete(pm8001_dev->setds_completion);
+        ccb->task = NULL;
+        ccb->ccb_tag = 0xFFFFFFFF;
+        pm8001_ccb_free(pm8001_ha, tag);
+}
+
+static void
+mpi_set_nvmd_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct get_nvm_data_resp *pPayload =
+                (struct get_nvm_data_resp *)(piomb + 4);
+        u32 tag = le32_to_cpu(pPayload->tag);
+        struct pm8001_ccb_info *ccb = &pm8001_ha->ccb_info[tag];
+        u32 dlen_status = le32_to_cpu(pPayload->dlen_status);
+        complete(pm8001_ha->nvmd_completion);
+        PM8001_MSG_DBG(pm8001_ha, pm8001_printk("Set nvm data complete!\n"));
+        if ((dlen_status & NVMD_STAT) != 0) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("Set nvm data error!\n"));
+                return;
+        }
+        ccb->task = NULL;
+        ccb->ccb_tag = 0xFFFFFFFF;
+        pm8001_ccb_free(pm8001_ha, tag);
+}
+
+static void
+mpi_get_nvmd_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct fw_control_ex    *fw_control_context;
+        struct get_nvm_data_resp *pPayload =
+                (struct get_nvm_data_resp *)(piomb + 4);
+        u32 tag = le32_to_cpu(pPayload->tag);
+        struct pm8001_ccb_info *ccb = &pm8001_ha->ccb_info[tag];
+        u32 dlen_status = le32_to_cpu(pPayload->dlen_status);
+        u32 ir_tds_bn_dps_das_nvm =
+                le32_to_cpu(pPayload->ir_tda_bn_dps_das_nvm);
+        void *virt_addr = pm8001_ha->memoryMap.region[NVMD].virt_ptr;
+        fw_control_context = ccb->fw_control_context;
+
+        PM8001_MSG_DBG(pm8001_ha, pm8001_printk("Get nvm data complete!\n"));
+        if ((dlen_status & NVMD_STAT) != 0) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("Get nvm data error!\n"));
+                complete(pm8001_ha->nvmd_completion);
+                return;
+        }
+
+        if (ir_tds_bn_dps_das_nvm & IPMode) {
+                /* indirect mode - IR bit set */
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("Get NVMD success, IR=1\n"));
+                if ((ir_tds_bn_dps_das_nvm & NVMD_TYPE) == TWI_DEVICE) {
+                        if (ir_tds_bn_dps_das_nvm == 0x80a80200) {
+                                memcpy(pm8001_ha->sas_addr,
+                                      ((u8 *)virt_addr + 4),
+                                       SAS_ADDR_SIZE);
+                                PM8001_MSG_DBG(pm8001_ha,
+                                        pm8001_printk("Get SAS address"
+                                        " from VPD successfully!\n"));
+                        }
+                } else if (((ir_tds_bn_dps_das_nvm & NVMD_TYPE) == C_SEEPROM)
+                        || ((ir_tds_bn_dps_das_nvm & NVMD_TYPE) == VPD_FLASH) ||
+                        ((ir_tds_bn_dps_das_nvm & NVMD_TYPE) == EXPAN_ROM)) {
+                                ;
+                } else if (((ir_tds_bn_dps_das_nvm & NVMD_TYPE) == AAP1_RDUMP)
+                        || ((ir_tds_bn_dps_das_nvm & NVMD_TYPE) == IOP_RDUMP)) {
+                        ;
+                } else {
+                        /* Should not be happened*/
+                        PM8001_MSG_DBG(pm8001_ha,
+                                pm8001_printk("(IR=1)Wrong Device type 0x%x\n",
+                                ir_tds_bn_dps_das_nvm));
+                }
+        } else /* direct mode */{
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("Get NVMD success, IR=0, dataLen=%d\n",
+                        (dlen_status & NVMD_LEN) >> 24));
+        }
+        memcpy(fw_control_context->usrAddr,
+                pm8001_ha->memoryMap.region[NVMD].virt_ptr,
+                fw_control_context->len);
+        complete(pm8001_ha->nvmd_completion);
+        ccb->task = NULL;
+        ccb->ccb_tag = 0xFFFFFFFF;
+        pm8001_ccb_free(pm8001_ha, tag);
+}
+
+static int mpi_local_phy_ctl(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct local_phy_ctl_resp *pPayload =
+                (struct local_phy_ctl_resp *)(piomb + 4);
+        u32 status = le32_to_cpu(pPayload->status);
+        u32 phy_id = le32_to_cpu(pPayload->phyop_phyid) & ID_BITS;
+        u32 phy_op = le32_to_cpu(pPayload->phyop_phyid) & OP_BITS;
+        if (status != 0) {
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("%x phy execute %x phy op failed! \n",
+                        phy_id, phy_op));
+        } else
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("%x phy execute %x phy op success! \n",
+                        phy_id, phy_op));
+        return 0;
+}
+
+/**
+ * pm8001_bytes_dmaed - one of the interface function communication with libsas
+ * @pm8001_ha: our hba card information
+ * @i: which phy that received the event.
+ *
+ * when HBA driver received the identify done event or initiate FIS received
+ * event(for SATA), it will invoke this function to notify the sas layer that
+ * the sas toplogy has formed, please discover the the whole sas domain,
+ * while receive a broadcast(change) primitive just tell the sas
+ * layer to discover the changed domain rather than the whole domain.
+ */
+static void pm8001_bytes_dmaed(struct pm8001_hba_info *pm8001_ha, int i)
+{
+        struct pm8001_phy *phy = &pm8001_ha->phy[i];
+        struct asd_sas_phy *sas_phy = &phy->sas_phy;
+        struct sas_ha_struct *sas_ha;
+        if (!phy->phy_attached)
+                return;
+
+        sas_ha = pm8001_ha->sas;
+        if (sas_phy->phy) {
+                struct sas_phy *sphy = sas_phy->phy;
+                sphy->negotiated_linkrate = sas_phy->linkrate;
+                sphy->minimum_linkrate = phy->minimum_linkrate;
+                sphy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
+                sphy->maximum_linkrate = phy->maximum_linkrate;
+                sphy->maximum_linkrate_hw = phy->maximum_linkrate;
+        }
+
+        if (phy->phy_type & PORT_TYPE_SAS) {
+                struct sas_identify_frame *id;
+                id = (struct sas_identify_frame *)phy->frame_rcvd;
+                id->dev_type = phy->identify.device_type;
+                id->initiator_bits = SAS_PROTOCOL_ALL;
+                id->target_bits = phy->identify.target_port_protocols;
+        } else if (phy->phy_type & PORT_TYPE_SATA) {
+                /*Nothing*/
+        }
+        PM8001_MSG_DBG(pm8001_ha, pm8001_printk("phy %d byte dmaded.\n", i));
+
+        sas_phy->frame_rcvd_size = phy->frame_rcvd_size;
+        pm8001_ha->sas->notify_port_event(sas_phy, PORTE_BYTES_DMAED);
+}
+
+/* Get the link rate speed  */
+static void get_lrate_mode(struct pm8001_phy *phy, u8 link_rate)
+{
+        struct sas_phy *sas_phy = phy->sas_phy.phy;
+
+        switch (link_rate) {
+        case PHY_SPEED_60:
+                phy->sas_phy.linkrate = SAS_LINK_RATE_6_0_GBPS;
+                phy->sas_phy.phy->negotiated_linkrate = SAS_LINK_RATE_6_0_GBPS;
+                break;
+        case PHY_SPEED_30:
+                phy->sas_phy.linkrate = SAS_LINK_RATE_3_0_GBPS;
+                phy->sas_phy.phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS;
+                break;
+        case PHY_SPEED_15:
+                phy->sas_phy.linkrate = SAS_LINK_RATE_1_5_GBPS;
+                phy->sas_phy.phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS;
+                break;
+        }
+        sas_phy->negotiated_linkrate = phy->sas_phy.linkrate;
+        sas_phy->maximum_linkrate_hw = SAS_LINK_RATE_6_0_GBPS;
+        sas_phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS;
+        sas_phy->maximum_linkrate = SAS_LINK_RATE_6_0_GBPS;
+        sas_phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS;
+}
+
+/**
+ * asd_get_attached_sas_addr -- extract/generate attached SAS address
+ * @phy: pointer to asd_phy
+ * @sas_addr: pointer to buffer where the SAS address is to be written
+ *
+ * This function extracts the SAS address from an IDENTIFY frame
+ * received.  If OOB is SATA, then a SAS address is generated from the
+ * HA tables.
+ *
+ * LOCKING: the frame_rcvd_lock needs to be held since this parses the frame
+ * buffer.
+ */
+static void pm8001_get_attached_sas_addr(struct pm8001_phy *phy,
+        u8 *sas_addr)
+{
+        if (phy->sas_phy.frame_rcvd[0] == 0x34
+                && phy->sas_phy.oob_mode == SATA_OOB_MODE) {
+                struct pm8001_hba_info *pm8001_ha = phy->sas_phy.ha->lldd_ha;
+                /* FIS device-to-host */
+                u64 addr = be64_to_cpu(*(__be64 *)pm8001_ha->sas_addr);
+                addr += phy->sas_phy.id;
+                *(__be64 *)sas_addr = cpu_to_be64(addr);
+        } else {
+                struct sas_identify_frame *idframe =
+                        (void *) phy->sas_phy.frame_rcvd;
+                memcpy(sas_addr, idframe->sas_addr, SAS_ADDR_SIZE);
+        }
+}
+
+/**
+ * pm8001_hw_event_ack_req- For PM8001,some events need to acknowage to FW.
+ * @pm8001_ha: our hba card information
+ * @Qnum: the outbound queue message number.
+ * @SEA: source of event to ack
+ * @port_id: port id.
+ * @phyId: phy id.
+ * @param0: parameter 0.
+ * @param1: parameter 1.
+ */
+static void pm8001_hw_event_ack_req(struct pm8001_hba_info *pm8001_ha,
+        u32 Qnum, u32 SEA, u32 port_id, u32 phyId, u32 param0, u32 param1)
+{
+        struct hw_event_ack_req  payload;
+        u32 opc = OPC_INB_SAS_HW_EVENT_ACK;
+
+        struct inbound_queue_table *circularQ;
+
+        memset((u8 *)&payload, 0, sizeof(payload));
+        circularQ = &pm8001_ha->inbnd_q_tbl[Qnum];
+        payload.tag = 1;
+        payload.sea_phyid_portid = cpu_to_le32(((SEA & 0xFFFF) << 8) |
+                ((phyId & 0x0F) << 4) | (port_id & 0x0F));
+        payload.param0 = cpu_to_le32(param0);
+        payload.param1 = cpu_to_le32(param1);
+        mpi_build_cmd(pm8001_ha, circularQ, opc, &payload);
+}
+
+static int pm8001_chip_phy_ctl_req(struct pm8001_hba_info *pm8001_ha,
+        u32 phyId, u32 phy_op);
+
+/**
+ * hw_event_sas_phy_up -FW tells me a SAS phy up event.
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static void
+hw_event_sas_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct hw_event_resp *pPayload =
+                (struct hw_event_resp *)(piomb + 4);
+        u32 lr_evt_status_phyid_portid =
+                le32_to_cpu(pPayload->lr_evt_status_phyid_portid);
+        u8 link_rate =
+                (u8)((lr_evt_status_phyid_portid & 0xF0000000) >> 28);
+        u8 port_id = (u8)(lr_evt_status_phyid_portid & 0x0000000F);
+        u8 phy_id =
+                (u8)((lr_evt_status_phyid_portid & 0x000000F0) >> 4);
+        u32 npip_portstate = le32_to_cpu(pPayload->npip_portstate);
+        u8 portstate = (u8)(npip_portstate & 0x0000000F);
+        struct pm8001_port *port = &pm8001_ha->port[port_id];
+        struct sas_ha_struct *sas_ha = pm8001_ha->sas;
+        struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+        unsigned long flags;
+        u8 deviceType = pPayload->sas_identify.dev_type;
+        port->port_state =  portstate;
+        PM8001_MSG_DBG(pm8001_ha,
+                pm8001_printk("HW_EVENT_SAS_PHY_UP port id = %d, phy id = %d\n",
+                port_id, phy_id));
+
+        switch (deviceType) {
+        case SAS_PHY_UNUSED:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("device type no device.\n"));
+                break;
+        case SAS_END_DEVICE:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk("end device.\n"));
+                pm8001_chip_phy_ctl_req(pm8001_ha, phy_id,
+                        PHY_NOTIFY_ENABLE_SPINUP);
+                port->port_attached = 1;
+                get_lrate_mode(phy, link_rate);
+                break;
+        case SAS_EDGE_EXPANDER_DEVICE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("expander device.\n"));
+                port->port_attached = 1;
+                get_lrate_mode(phy, link_rate);
+                break;
+        case SAS_FANOUT_EXPANDER_DEVICE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("fanout expander device.\n"));
+                port->port_attached = 1;
+                get_lrate_mode(phy, link_rate);
+                break;
+        default:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("unknown device type(%x)\n", deviceType));
+                break;
+        }
+        phy->phy_type |= PORT_TYPE_SAS;
+        phy->identify.device_type = deviceType;
+        phy->phy_attached = 1;
+        if (phy->identify.device_type == SAS_END_DEV)
+                phy->identify.target_port_protocols = SAS_PROTOCOL_SSP;
+        else if (phy->identify.device_type != NO_DEVICE)
+                phy->identify.target_port_protocols = SAS_PROTOCOL_SMP;
+        phy->sas_phy.oob_mode = SAS_OOB_MODE;
+        sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
+        spin_lock_irqsave(&phy->sas_phy.frame_rcvd_lock, flags);
+        memcpy(phy->frame_rcvd, &pPayload->sas_identify,
+                sizeof(struct sas_identify_frame)-4);
+        phy->frame_rcvd_size = sizeof(struct sas_identify_frame) - 4;
+        pm8001_get_attached_sas_addr(phy, phy->sas_phy.attached_sas_addr);
+        spin_unlock_irqrestore(&phy->sas_phy.frame_rcvd_lock, flags);
+        if (pm8001_ha->flags == PM8001F_RUN_TIME)
+                mdelay(200);/*delay a moment to wait disk to spinup*/
+        pm8001_bytes_dmaed(pm8001_ha, phy_id);
+}
+
+/**
+ * hw_event_sata_phy_up -FW tells me a SATA phy up event.
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static void
+hw_event_sata_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct hw_event_resp *pPayload =
+                (struct hw_event_resp *)(piomb + 4);
+        u32 lr_evt_status_phyid_portid =
+                le32_to_cpu(pPayload->lr_evt_status_phyid_portid);
+        u8 link_rate =
+                (u8)((lr_evt_status_phyid_portid & 0xF0000000) >> 28);
+        u8 port_id = (u8)(lr_evt_status_phyid_portid & 0x0000000F);
+        u8 phy_id =
+                (u8)((lr_evt_status_phyid_portid & 0x000000F0) >> 4);
+        u32 npip_portstate = le32_to_cpu(pPayload->npip_portstate);
+        u8 portstate = (u8)(npip_portstate & 0x0000000F);
+        struct pm8001_port *port = &pm8001_ha->port[port_id];
+        struct sas_ha_struct *sas_ha = pm8001_ha->sas;
+        struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+        unsigned long flags;
+        PM8001_MSG_DBG(pm8001_ha,
+                pm8001_printk("HW_EVENT_SATA_PHY_UP port id = %d,"
+                " phy id = %d\n", port_id, phy_id));
+        port->port_state =  portstate;
+        port->port_attached = 1;
+        get_lrate_mode(phy, link_rate);
+        phy->phy_type |= PORT_TYPE_SATA;
+        phy->phy_attached = 1;
+        phy->sas_phy.oob_mode = SATA_OOB_MODE;
+        sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
+        spin_lock_irqsave(&phy->sas_phy.frame_rcvd_lock, flags);
+        memcpy(phy->frame_rcvd, ((u8 *)&pPayload->sata_fis - 4),
+                sizeof(struct dev_to_host_fis));
+        phy->frame_rcvd_size = sizeof(struct dev_to_host_fis);
+        phy->identify.target_port_protocols = SAS_PROTOCOL_SATA;
+        phy->identify.device_type = SATA_DEV;
+        pm8001_get_attached_sas_addr(phy, phy->sas_phy.attached_sas_addr);
+        spin_unlock_irqrestore(&phy->sas_phy.frame_rcvd_lock, flags);
+        pm8001_bytes_dmaed(pm8001_ha, phy_id);
+}
+
+/**
+ * hw_event_phy_down -we should notify the libsas the phy is down.
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static void
+hw_event_phy_down(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct hw_event_resp *pPayload =
+                (struct hw_event_resp *)(piomb + 4);
+        u32 lr_evt_status_phyid_portid =
+                le32_to_cpu(pPayload->lr_evt_status_phyid_portid);
+        u8 port_id = (u8)(lr_evt_status_phyid_portid & 0x0000000F);
+        u8 phy_id =
+                (u8)((lr_evt_status_phyid_portid & 0x000000F0) >> 4);
+        u32 npip_portstate = le32_to_cpu(pPayload->npip_portstate);
+        u8 portstate = (u8)(npip_portstate & 0x0000000F);
+        struct pm8001_port *port = &pm8001_ha->port[port_id];
+        struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+        port->port_state =  portstate;
+        phy->phy_type = 0;
+        phy->identify.device_type = 0;
+        phy->phy_attached = 0;
+        memset(&phy->dev_sas_addr, 0, SAS_ADDR_SIZE);
+        switch (portstate) {
+        case PORT_VALID:
+                break;
+        case PORT_INVALID:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" PortInvalid portID %d \n", port_id));
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" Last phy Down and port invalid\n"));
+                port->port_attached = 0;
+                pm8001_hw_event_ack_req(pm8001_ha, 0, HW_EVENT_PHY_DOWN,
+                        port_id, phy_id, 0, 0);
+                break;
+        case PORT_IN_RESET:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" Port In Reset portID %d \n", port_id));
+                break;
+        case PORT_NOT_ESTABLISHED:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" phy Down and PORT_NOT_ESTABLISHED\n"));
+                port->port_attached = 0;
+                break;
+        case PORT_LOSTCOMM:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" phy Down and PORT_LOSTCOMM\n"));
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" Last phy Down and port invalid\n"));
+                port->port_attached = 0;
+                pm8001_hw_event_ack_req(pm8001_ha, 0, HW_EVENT_PHY_DOWN,
+                        port_id, phy_id, 0, 0);
+                break;
+        default:
+                port->port_attached = 0;
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" phy Down and(default) = %x\n",
+                        portstate));
+                break;
+
+        }
+}
+
+/**
+ * mpi_reg_resp -process register device ID response.
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ *
+ * when sas layer find a device it will notify LLDD, then the driver register
+ * the domain device to FW, this event is the return device ID which the FW
+ * has assigned, from now,inter-communication with FW is no longer using the
+ * SAS address, use device ID which FW assigned.
+ */
+static int mpi_reg_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        u32 status;
+        u32 device_id;
+        u32 htag;
+        struct pm8001_ccb_info *ccb;
+        struct pm8001_device *pm8001_dev;
+        struct dev_reg_resp *registerRespPayload =
+                (struct dev_reg_resp *)(piomb + 4);
+
+        htag = le32_to_cpu(registerRespPayload->tag);
+        ccb = &pm8001_ha->ccb_info[registerRespPayload->tag];
+        pm8001_dev = ccb->device;
+        status = le32_to_cpu(registerRespPayload->status);
+        device_id = le32_to_cpu(registerRespPayload->device_id);
+        PM8001_MSG_DBG(pm8001_ha,
+                pm8001_printk(" register device is status = %d\n", status));
+        switch (status) {
+        case DEVREG_SUCCESS:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk("DEVREG_SUCCESS\n"));
+                pm8001_dev->device_id = device_id;
+                break;
+        case DEVREG_FAILURE_OUT_OF_RESOURCE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("DEVREG_FAILURE_OUT_OF_RESOURCE\n"));
+                break;
+        case DEVREG_FAILURE_DEVICE_ALREADY_REGISTERED:
+                PM8001_MSG_DBG(pm8001_ha,
+                   pm8001_printk("DEVREG_FAILURE_DEVICE_ALREADY_REGISTERED\n"));
+                break;
+        case DEVREG_FAILURE_INVALID_PHY_ID:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("DEVREG_FAILURE_INVALID_PHY_ID\n"));
+                break;
+        case DEVREG_FAILURE_PHY_ID_ALREADY_REGISTERED:
+                PM8001_MSG_DBG(pm8001_ha,
+                   pm8001_printk("DEVREG_FAILURE_PHY_ID_ALREADY_REGISTERED\n"));
+                break;
+        case DEVREG_FAILURE_PORT_ID_OUT_OF_RANGE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("DEVREG_FAILURE_PORT_ID_OUT_OF_RANGE\n"));
+                break;
+        case DEVREG_FAILURE_PORT_NOT_VALID_STATE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("DEVREG_FAILURE_PORT_NOT_VALID_STATE\n"));
+                break;
+        case DEVREG_FAILURE_DEVICE_TYPE_NOT_VALID:
+                PM8001_MSG_DBG(pm8001_ha,
+                       pm8001_printk("DEVREG_FAILURE_DEVICE_TYPE_NOT_VALID\n"));
+                break;
+        default:
+                PM8001_MSG_DBG(pm8001_ha,
+                 pm8001_printk("DEVREG_FAILURE_DEVICE_TYPE_NOT_UNSORPORTED\n"));
+                break;
+        }
+        complete(pm8001_dev->dcompletion);
+        ccb->task = NULL;
+        ccb->ccb_tag = 0xFFFFFFFF;
+        pm8001_ccb_free(pm8001_ha, htag);
+        return 0;
+}
+
+static int mpi_dereg_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        u32 status;
+        u32 device_id;
+        struct dev_reg_resp *registerRespPayload =
+                (struct dev_reg_resp *)(piomb + 4);
+
+        status = le32_to_cpu(registerRespPayload->status);
+        device_id = le32_to_cpu(registerRespPayload->device_id);
+        if (status != 0)
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" deregister device failed ,status = %x"
+                        ", device_id = %x\n", status, device_id));
+        return 0;
+}
+
+static int
+mpi_fw_flash_update_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        u32 status;
+        struct fw_control_ex    fw_control_context;
+        struct fw_flash_Update_resp *ppayload =
+                (struct fw_flash_Update_resp *)(piomb + 4);
+        u32 tag = le32_to_cpu(ppayload->tag);
+        struct pm8001_ccb_info *ccb = &pm8001_ha->ccb_info[tag];
+        status = le32_to_cpu(ppayload->status);
+        memcpy(&fw_control_context,
+                ccb->fw_control_context,
+                sizeof(fw_control_context));
+        switch (status) {
+        case FLASH_UPDATE_COMPLETE_PENDING_REBOOT:
+                PM8001_MSG_DBG(pm8001_ha,
+                pm8001_printk(": FLASH_UPDATE_COMPLETE_PENDING_REBOOT\n"));
+                break;
+        case FLASH_UPDATE_IN_PROGRESS:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(": FLASH_UPDATE_IN_PROGRESS\n"));
+                break;
+        case FLASH_UPDATE_HDR_ERR:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(": FLASH_UPDATE_HDR_ERR\n"));
+                break;
+        case FLASH_UPDATE_OFFSET_ERR:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(": FLASH_UPDATE_OFFSET_ERR\n"));
+                break;
+        case FLASH_UPDATE_CRC_ERR:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(": FLASH_UPDATE_CRC_ERR\n"));
+                break;
+        case FLASH_UPDATE_LENGTH_ERR:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(": FLASH_UPDATE_LENGTH_ERR\n"));
+                break;
+        case FLASH_UPDATE_HW_ERR:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(": FLASH_UPDATE_HW_ERR\n"));
+                break;
+        case FLASH_UPDATE_DNLD_NOT_SUPPORTED:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(": FLASH_UPDATE_DNLD_NOT_SUPPORTED\n"));
+                break;
+        case FLASH_UPDATE_DISABLED:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(": FLASH_UPDATE_DISABLED\n"));
+                break;
+        default:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("No matched status = %d\n", status));
+                break;
+        }
+        ccb->fw_control_context->fw_control->retcode = status;
+        pci_free_consistent(pm8001_ha->pdev,
+                        fw_control_context.len,
+                        fw_control_context.virtAddr,
+                        fw_control_context.phys_addr);
+        complete(pm8001_ha->nvmd_completion);
+        ccb->task = NULL;
+        ccb->ccb_tag = 0xFFFFFFFF;
+        pm8001_ccb_free(pm8001_ha, tag);
+        return 0;
+}
+
+static int
+mpi_general_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+{
+        u32 status;
+        int i;
+        struct general_event_resp *pPayload =
+                (struct general_event_resp *)(piomb + 4);
+        status = le32_to_cpu(pPayload->status);
+        PM8001_MSG_DBG(pm8001_ha,
+                pm8001_printk(" status = 0x%x\n", status));
+        for (i = 0; i < GENERAL_EVENT_PAYLOAD; i++)
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("inb_IOMB_payload[0x%x] 0x%x, \n", i,
+                        pPayload->inb_IOMB_payload[i]));
+        return 0;
+}
+
+static int
+mpi_task_abort_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct sas_task *t;
+        struct pm8001_ccb_info *ccb;
+        unsigned long flags;
+        u32 status ;
+        u32 tag, scp;
+        struct task_status_struct *ts;
+
+        struct task_abort_resp *pPayload =
+                (struct task_abort_resp *)(piomb + 4);
+        ccb = &pm8001_ha->ccb_info[pPayload->tag];
+        t = ccb->task;
+
+
+        status = le32_to_cpu(pPayload->status);
+        tag = le32_to_cpu(pPayload->tag);
+        scp = le32_to_cpu(pPayload->scp);
+        PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk(" status = 0x%x\n", status));
+        if (t == NULL)
+                return -1;
+        ts = &t->task_status;
+        if (status != 0)
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("task abort failed status 0x%x ,"
+                        "tag = 0x%x, scp= 0x%x\n", status, tag, scp));
+        switch (status) {
+        case IO_SUCCESS:
+                PM8001_EH_DBG(pm8001_ha, pm8001_printk("IO_SUCCESS\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAM_GOOD;
+                break;
+        case IO_NOT_VALID:
+                PM8001_EH_DBG(pm8001_ha, pm8001_printk("IO_NOT_VALID\n"));
+                ts->resp = TMF_RESP_FUNC_FAILED;
+                break;
+        }
+        spin_lock_irqsave(&t->task_state_lock, flags);
+        t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+        t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+        t->task_state_flags |= SAS_TASK_STATE_DONE;
+        spin_unlock_irqrestore(&t->task_state_lock, flags);
+        pm8001_ccb_task_free(pm8001_ha, t, ccb, pPayload->tag);
+        mb();
+        t->task_done(t);
+        return 0;
+}
+
+/**
+ * mpi_hw_event -The hw event has come.
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
+{
+        unsigned long flags;
+        struct hw_event_resp *pPayload =
+                (struct hw_event_resp *)(piomb + 4);
+        u32 lr_evt_status_phyid_portid =
+                le32_to_cpu(pPayload->lr_evt_status_phyid_portid);
+        u8 port_id = (u8)(lr_evt_status_phyid_portid & 0x0000000F);
+        u8 phy_id =
+                (u8)((lr_evt_status_phyid_portid & 0x000000F0) >> 4);
+        u16 eventType =
+                (u16)((lr_evt_status_phyid_portid & 0x00FFFF00) >> 8);
+        u8 status =
+                (u8)((lr_evt_status_phyid_portid & 0x0F000000) >> 24);
+        struct sas_ha_struct *sas_ha = pm8001_ha->sas;
+        struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+        struct asd_sas_phy *sas_phy = sas_ha->sas_phy[phy_id];
+        PM8001_MSG_DBG(pm8001_ha,
+                pm8001_printk("outbound queue HW event & event type : "));
+        switch (eventType) {
+        case HW_EVENT_PHY_START_STATUS:
+                PM8001_MSG_DBG(pm8001_ha,
+                pm8001_printk("HW_EVENT_PHY_START_STATUS"
+                        " status = %x\n", status));
+                if (status == 0) {
+                        phy->phy_state = 1;
+                        if (pm8001_ha->flags == PM8001F_RUN_TIME)
+                                complete(phy->enable_completion);
+                }
+                break;
+        case HW_EVENT_SAS_PHY_UP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PHY_START_STATUS \n"));
+                hw_event_sas_phy_up(pm8001_ha, piomb);
+                break;
+        case HW_EVENT_SATA_PHY_UP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_SATA_PHY_UP \n"));
+                hw_event_sata_phy_up(pm8001_ha, piomb);
+                break;
+        case HW_EVENT_PHY_STOP_STATUS:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PHY_STOP_STATUS "
+                        "status = %x\n", status));
+                if (status == 0)
+                        phy->phy_state = 0;
+                break;
+        case HW_EVENT_SATA_SPINUP_HOLD:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_SATA_SPINUP_HOLD \n"));
+                sas_ha->notify_phy_event(&phy->sas_phy, PHYE_SPINUP_HOLD);
+                break;
+        case HW_EVENT_PHY_DOWN:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PHY_DOWN \n"));
+                sas_ha->notify_phy_event(&phy->sas_phy, PHYE_LOSS_OF_SIGNAL);
+                phy->phy_attached = 0;
+                phy->phy_state = 0;
+                hw_event_phy_down(pm8001_ha, piomb);
+                break;
+        case HW_EVENT_PORT_INVALID:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PORT_INVALID\n"));
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        /* the broadcast change primitive received, tell the LIBSAS this event
+        to revalidate the sas domain*/
+        case HW_EVENT_BROADCAST_CHANGE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_BROADCAST_CHANGE\n"));
+                pm8001_hw_event_ack_req(pm8001_ha, 0, HW_EVENT_BROADCAST_CHANGE,
+                        port_id, phy_id, 1, 0);
+                spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+                sas_phy->sas_prim = HW_EVENT_BROADCAST_CHANGE;
+                spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+                sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+                break;
+        case HW_EVENT_PHY_ERROR:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PHY_ERROR\n"));
+                sas_phy_disconnected(&phy->sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_ERROR);
+                break;
+        case HW_EVENT_BROADCAST_EXP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_BROADCAST_EXP\n"));
+                spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+                sas_phy->sas_prim = HW_EVENT_BROADCAST_EXP;
+                spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+                sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+                break;
+        case HW_EVENT_LINK_ERR_INVALID_DWORD:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_LINK_ERR_INVALID_DWORD\n"));
+                pm8001_hw_event_ack_req(pm8001_ha, 0,
+                        HW_EVENT_LINK_ERR_INVALID_DWORD, port_id, phy_id, 0, 0);
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_LINK_ERR_DISPARITY_ERROR:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_LINK_ERR_DISPARITY_ERROR\n"));
+                pm8001_hw_event_ack_req(pm8001_ha, 0,
+                        HW_EVENT_LINK_ERR_DISPARITY_ERROR,
+                        port_id, phy_id, 0, 0);
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_LINK_ERR_CODE_VIOLATION:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_LINK_ERR_CODE_VIOLATION\n"));
+                pm8001_hw_event_ack_req(pm8001_ha, 0,
+                        HW_EVENT_LINK_ERR_CODE_VIOLATION,
+                        port_id, phy_id, 0, 0);
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH:
+                PM8001_MSG_DBG(pm8001_ha,
+                      pm8001_printk("HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH\n"));
+                pm8001_hw_event_ack_req(pm8001_ha, 0,
+                        HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH,
+                        port_id, phy_id, 0, 0);
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_MALFUNCTION:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_MALFUNCTION\n"));
+                break;
+        case HW_EVENT_BROADCAST_SES:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_BROADCAST_SES\n"));
+                spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+                sas_phy->sas_prim = HW_EVENT_BROADCAST_SES;
+                spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+                sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+                break;
+        case HW_EVENT_INBOUND_CRC_ERROR:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_INBOUND_CRC_ERROR\n"));
+                pm8001_hw_event_ack_req(pm8001_ha, 0,
+                        HW_EVENT_INBOUND_CRC_ERROR,
+                        port_id, phy_id, 0, 0);
+                break;
+        case HW_EVENT_HARD_RESET_RECEIVED:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_HARD_RESET_RECEIVED\n"));
+                sas_ha->notify_port_event(sas_phy, PORTE_HARD_RESET);
+                break;
+        case HW_EVENT_ID_FRAME_TIMEOUT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_ID_FRAME_TIMEOUT\n"));
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_LINK_ERR_PHY_RESET_FAILED:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_LINK_ERR_PHY_RESET_FAILED \n"));
+                pm8001_hw_event_ack_req(pm8001_ha, 0,
+                        HW_EVENT_LINK_ERR_PHY_RESET_FAILED,
+                        port_id, phy_id, 0, 0);
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_PORT_RESET_TIMER_TMO:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PORT_RESET_TIMER_TMO \n"));
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_PORT_RECOVERY_TIMER_TMO:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PORT_RECOVERY_TIMER_TMO \n"));
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_PORT_RECOVER:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PORT_RECOVER \n"));
+                break;
+        case HW_EVENT_PORT_RESET_COMPLETE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PORT_RESET_COMPLETE \n"));
+                break;
+        case EVENT_BROADCAST_ASYNCH_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("EVENT_BROADCAST_ASYNCH_EVENT\n"));
+                break;
+        default:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("Unknown event type = %x\n", eventType));
+                break;
+        }
+        return 0;
+}
+
+/**
+ * process_one_iomb - process one outbound Queue memory block
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static void process_one_iomb(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        u32 pHeader = (u32)*(u32 *)piomb;
+        u8 opc = (u8)((le32_to_cpu(pHeader)) & 0xFFF);
+
+        PM8001_MSG_DBG(pm8001_ha, pm8001_printk("process_one_iomb:"));
+
+        switch (opc) {
+        case OPC_OUB_ECHO:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk("OPC_OUB_ECHO \n"));
+                break;
+        case OPC_OUB_HW_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_HW_EVENT \n"));
+                mpi_hw_event(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SSP_COMP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SSP_COMP \n"));
+                mpi_ssp_completion(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SMP_COMP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SMP_COMP \n"));
+                mpi_smp_completion(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_LOCAL_PHY_CNTRL:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_LOCAL_PHY_CNTRL\n"));
+                mpi_local_phy_ctl(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_DEV_REGIST:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_DEV_REGIST \n"));
+                mpi_reg_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_DEREG_DEV:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("unresgister the deviece \n"));
+                mpi_dereg_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_GET_DEV_HANDLE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_GET_DEV_HANDLE \n"));
+                break;
+        case OPC_OUB_SATA_COMP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SATA_COMP \n"));
+                mpi_sata_completion(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SATA_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SATA_EVENT \n"));
+                mpi_sata_event(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SSP_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SSP_EVENT\n"));
+                mpi_ssp_event(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_DEV_HANDLE_ARRIV:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_DEV_HANDLE_ARRIV\n"));
+                /*This is for target*/
+                break;
+        case OPC_OUB_SSP_RECV_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SSP_RECV_EVENT\n"));
+                /*This is for target*/
+                break;
+        case OPC_OUB_DEV_INFO:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_DEV_INFO\n"));
+                break;
+        case OPC_OUB_FW_FLASH_UPDATE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_FW_FLASH_UPDATE\n"));
+                mpi_fw_flash_update_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_GPIO_RESPONSE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_GPIO_RESPONSE\n"));
+                break;
+        case OPC_OUB_GPIO_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_GPIO_EVENT\n"));
+                break;
+        case OPC_OUB_GENERAL_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_GENERAL_EVENT\n"));
+                mpi_general_event(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SSP_ABORT_RSP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SSP_ABORT_RSP\n"));
+                mpi_task_abort_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SATA_ABORT_RSP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SATA_ABORT_RSP\n"));
+                mpi_task_abort_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SAS_DIAG_MODE_START_END:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SAS_DIAG_MODE_START_END\n"));
+                break;
+        case OPC_OUB_SAS_DIAG_EXECUTE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SAS_DIAG_EXECUTE\n"));
+                break;
+        case OPC_OUB_GET_TIME_STAMP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_GET_TIME_STAMP\n"));
+                break;
+        case OPC_OUB_SAS_HW_EVENT_ACK:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SAS_HW_EVENT_ACK\n"));
+                break;
+        case OPC_OUB_PORT_CONTROL:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_PORT_CONTROL\n"));
+                break;
+        case OPC_OUB_SMP_ABORT_RSP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SMP_ABORT_RSP\n"));
+                mpi_task_abort_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_GET_NVMD_DATA:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_GET_NVMD_DATA\n"));
+                mpi_get_nvmd_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SET_NVMD_DATA:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SET_NVMD_DATA\n"));
+                mpi_set_nvmd_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_DEVICE_HANDLE_REMOVAL:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_DEVICE_HANDLE_REMOVAL\n"));
+                break;
+        case OPC_OUB_SET_DEVICE_STATE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SET_DEVICE_STATE\n"));
+                mpi_set_dev_state_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_GET_DEVICE_STATE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_GET_DEVICE_STATE\n"));
+                break;
+        case OPC_OUB_SET_DEV_INFO:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SET_DEV_INFO\n"));
+                break;
+        case OPC_OUB_SAS_RE_INITIALIZE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SAS_RE_INITIALIZE\n"));
+                break;
+        default:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("Unknown outbound Queue IOMB OPC = %x\n",
+                        opc));
+                break;
+        }
+}
+
+static int process_oq(struct pm8001_hba_info *pm8001_ha)
+{
+        struct outbound_queue_table *circularQ;
+        void *pMsg1 = NULL;
+        u8 bc = 0;
+        u32 ret = MPI_IO_STATUS_FAIL;
+
+        circularQ = &pm8001_ha->outbnd_q_tbl[0];
+        do {
+                ret = mpi_msg_consume(pm8001_ha, circularQ, &pMsg1, &bc);
+                if (MPI_IO_STATUS_SUCCESS == ret) {
+                        /* process the outbound message */
+                        process_one_iomb(pm8001_ha, (void *)(pMsg1 - 4));
+                        /* free the message from the outbound circular buffer */
+                        mpi_msg_free_set(pm8001_ha, pMsg1, circularQ, bc);
+                }
+                if (MPI_IO_STATUS_BUSY == ret) {
+                        u32 producer_idx;
+                        /* Update the producer index from SPC */
+                        producer_idx = pm8001_read_32(circularQ->pi_virt);
+                        circularQ->producer_index = cpu_to_le32(producer_idx);
+                        if (circularQ->producer_index ==
+                                circularQ->consumer_idx)
+                                /* OQ is empty */
+                                break;
+                }
+        } while (1);
+        return ret;
+}
+
+/* PCI_DMA_... to our direction translation. */
+static const u8 data_dir_flags[] = {
+        [PCI_DMA_BIDIRECTIONAL] = DATA_DIR_BYRECIPIENT,/* UNSPECIFIED */
+        [PCI_DMA_TODEVICE]      = DATA_DIR_OUT,/* OUTBOUND */
+        [PCI_DMA_FROMDEVICE]    = DATA_DIR_IN,/* INBOUND */
+        [PCI_DMA_NONE]          = DATA_DIR_NONE,/* NO TRANSFER */
+};
+static void
+pm8001_chip_make_sg(struct scatterlist *scatter, int nr, void *prd)
+{
+        int i;
+        struct scatterlist *sg;
+        struct pm8001_prd *buf_prd = prd;
+
+        for_each_sg(scatter, sg, nr, i) {
+                buf_prd->addr = cpu_to_le64(sg_dma_address(sg));
+                buf_prd->im_len.len = cpu_to_le32(sg_dma_len(sg));
+                buf_prd->im_len.e = 0;
+                buf_prd++;
+        }
+}
+
+static void build_smp_cmd(u32 deviceID, u32 hTag, struct smp_req *psmp_cmd)
+{
+        psmp_cmd->tag = cpu_to_le32(hTag);
+        psmp_cmd->device_id = cpu_to_le32(deviceID);
+        psmp_cmd->len_ip_ir = cpu_to_le32(1|(1 << 1));
+}
+
+/**
+ * pm8001_chip_smp_req - send a SMP task to FW
+ * @pm8001_ha: our hba card information.
+ * @ccb: the ccb information this request used.
+ */
+static int pm8001_chip_smp_req(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_ccb_info *ccb)
+{
+        int elem, rc;
+        struct sas_task *task = ccb->task;
+        struct domain_device *dev = task->dev;
+        struct pm8001_device *pm8001_dev = dev->lldd_dev;
+        struct scatterlist *sg_req, *sg_resp;
+        u32 req_len, resp_len;
+        struct smp_req smp_cmd;
+        u32 opc;
+        struct inbound_queue_table *circularQ;
+
+        memset(&smp_cmd, 0, sizeof(smp_cmd));
+        /*
+         * DMA-map SMP request, response buffers
+         */
+        sg_req = &task->smp_task.smp_req;
+        elem = dma_map_sg(pm8001_ha->dev, sg_req, 1, PCI_DMA_TODEVICE);
+        if (!elem)
+                return -ENOMEM;
+        req_len = sg_dma_len(sg_req);
+
+        sg_resp = &task->smp_task.smp_resp;
+        elem = dma_map_sg(pm8001_ha->dev, sg_resp, 1, PCI_DMA_FROMDEVICE);
+        if (!elem) {
+                rc = -ENOMEM;
+                goto err_out;
+        }
+        resp_len = sg_dma_len(sg_resp);
+        /* must be in dwords */
+        if ((req_len & 0x3) || (resp_len & 0x3)) {
+                rc = -EINVAL;
+                goto err_out_2;
+        }
+
+        opc = OPC_INB_SMP_REQUEST;
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        smp_cmd.tag = cpu_to_le32(ccb->ccb_tag);
+        smp_cmd.long_smp_req.long_req_addr =
+                cpu_to_le64((u64)sg_dma_address(&task->smp_task.smp_req));
+        smp_cmd.long_smp_req.long_req_size =
+                cpu_to_le32((u32)sg_dma_len(&task->smp_task.smp_req)-4);
+        smp_cmd.long_smp_req.long_resp_addr =
+                cpu_to_le64((u64)sg_dma_address(&task->smp_task.smp_resp));
+        smp_cmd.long_smp_req.long_resp_size =
+                cpu_to_le32((u32)sg_dma_len(&task->smp_task.smp_resp)-4);
+        build_smp_cmd(pm8001_dev->device_id, smp_cmd.tag, &smp_cmd);
+        mpi_build_cmd(pm8001_ha, circularQ, opc, (u32 *)&smp_cmd);
+        return 0;
+
+err_out_2:
+        dma_unmap_sg(pm8001_ha->dev, &ccb->task->smp_task.smp_resp, 1,
+                        PCI_DMA_FROMDEVICE);
+err_out:
+        dma_unmap_sg(pm8001_ha->dev, &ccb->task->smp_task.smp_req, 1,
+                        PCI_DMA_TODEVICE);
+        return rc;
+}
+
+/**
+ * pm8001_chip_ssp_io_req - send a SSP task to FW
+ * @pm8001_ha: our hba card information.
+ * @ccb: the ccb information this request used.
+ */
+static int pm8001_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_ccb_info *ccb)
+{
+        struct sas_task *task = ccb->task;
+        struct domain_device *dev = task->dev;
+        struct pm8001_device *pm8001_dev = dev->lldd_dev;
+        struct ssp_ini_io_start_req ssp_cmd;
+        u32 tag = ccb->ccb_tag;
+        int ret;
+        __le64 phys_addr;
+        struct inbound_queue_table *circularQ;
+        u32 opc = OPC_INB_SSPINIIOSTART;
+        memset(&ssp_cmd, 0, sizeof(ssp_cmd));
+        memcpy(ssp_cmd.ssp_iu.lun, task->ssp_task.LUN, 8);
+        ssp_cmd.dir_m_tlr =
+                cpu_to_le32(data_dir_flags[task->data_dir] << 8 | 0x0);/*0 for
+        SAS 1.1 compatible TLR*/
+        ssp_cmd.data_len = cpu_to_le32(task->total_xfer_len);
+        ssp_cmd.device_id = cpu_to_le32(pm8001_dev->device_id);
+        ssp_cmd.tag = cpu_to_le32(tag);
+        if (task->ssp_task.enable_first_burst)
+                ssp_cmd.ssp_iu.efb_prio_attr |= 0x80;
+        ssp_cmd.ssp_iu.efb_prio_attr |= (task->ssp_task.task_prio << 3);
+        ssp_cmd.ssp_iu.efb_prio_attr |= (task->ssp_task.task_attr & 7);
+        memcpy(ssp_cmd.ssp_iu.cdb, task->ssp_task.cdb, 16);
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+
+        /* fill in PRD (scatter/gather) table, if any */
+        if (task->num_scatter > 1) {
+                pm8001_chip_make_sg(task->scatter, ccb->n_elem, ccb->buf_prd);
+                phys_addr = cpu_to_le64(ccb->ccb_dma_handle +
+                                offsetof(struct pm8001_ccb_info, buf_prd[0]));
+                ssp_cmd.addr_low = lower_32_bits(phys_addr);
+                ssp_cmd.addr_high = upper_32_bits(phys_addr);
+                ssp_cmd.esgl = cpu_to_le32(1<<31);
+        } else if (task->num_scatter == 1) {
+                __le64 dma_addr = cpu_to_le64(sg_dma_address(task->scatter));
+                ssp_cmd.addr_low = lower_32_bits(dma_addr);
+                ssp_cmd.addr_high = upper_32_bits(dma_addr);
+                ssp_cmd.len = cpu_to_le32(task->total_xfer_len);
+                ssp_cmd.esgl = 0;
+        } else if (task->num_scatter == 0) {
+                ssp_cmd.addr_low = 0;
+                ssp_cmd.addr_high = 0;
+                ssp_cmd.len = cpu_to_le32(task->total_xfer_len);
+                ssp_cmd.esgl = 0;
+        }
+        ret = mpi_build_cmd(pm8001_ha, circularQ, opc, &ssp_cmd);
+        return ret;
+}
+
+static int pm8001_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_ccb_info *ccb)
+{
+        struct sas_task *task = ccb->task;
+        struct domain_device *dev = task->dev;
+        struct pm8001_device *pm8001_ha_dev = dev->lldd_dev;
+        u32 tag = ccb->ccb_tag;
+        int ret;
+        struct sata_start_req sata_cmd;
+        u32 hdr_tag, ncg_tag = 0;
+        __le64 phys_addr;
+        u32 ATAP = 0x0;
+        u32 dir;
+        struct inbound_queue_table *circularQ;
+        u32  opc = OPC_INB_SATA_HOST_OPSTART;
+        memset(&sata_cmd, 0, sizeof(sata_cmd));
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        if (task->data_dir == PCI_DMA_NONE) {
+                ATAP = 0x04;  /* no data*/
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("no data \n"));
+        } else if (likely(!task->ata_task.device_control_reg_update)) {
+                if (task->ata_task.dma_xfer) {
+                        ATAP = 0x06; /* DMA */
+                        PM8001_IO_DBG(pm8001_ha, pm8001_printk("DMA \n"));
+                } else {
+                        ATAP = 0x05; /* PIO*/
+                        PM8001_IO_DBG(pm8001_ha, pm8001_printk("PIO \n"));
+                }
+                if (task->ata_task.use_ncq &&
+                        dev->sata_dev.command_set != ATAPI_COMMAND_SET) {
+                        ATAP = 0x07; /* FPDMA */
+                        PM8001_IO_DBG(pm8001_ha, pm8001_printk("FPDMA \n"));
+                }
+        }
+        if (task->ata_task.use_ncq && pm8001_get_ncq_tag(task, &hdr_tag))
+                ncg_tag = hdr_tag;
+        dir = data_dir_flags[task->data_dir] << 8;
+        sata_cmd.tag = cpu_to_le32(tag);
+        sata_cmd.device_id = cpu_to_le32(pm8001_ha_dev->device_id);
+        sata_cmd.data_len = cpu_to_le32(task->total_xfer_len);
+        sata_cmd.ncqtag_atap_dir_m =
+                cpu_to_le32(((ncg_tag & 0xff)<<16)|((ATAP & 0x3f) << 10) | dir);
+        sata_cmd.sata_fis = task->ata_task.fis;
+        if (likely(!task->ata_task.device_control_reg_update))
+                sata_cmd.sata_fis.flags |= 0x80;/* C=1: update ATA cmd reg */
+        sata_cmd.sata_fis.flags &= 0xF0;/* PM_PORT field shall be 0 */
+        /* fill in PRD (scatter/gather) table, if any */
+        if (task->num_scatter > 1) {
+                pm8001_chip_make_sg(task->scatter, ccb->n_elem, ccb->buf_prd);
+                phys_addr = cpu_to_le64(ccb->ccb_dma_handle +
+                                offsetof(struct pm8001_ccb_info, buf_prd[0]));
+                sata_cmd.addr_low = lower_32_bits(phys_addr);
+                sata_cmd.addr_high = upper_32_bits(phys_addr);
+                sata_cmd.esgl = cpu_to_le32(1 << 31);
+        } else if (task->num_scatter == 1) {
+                __le64 dma_addr = cpu_to_le64(sg_dma_address(task->scatter));
+                sata_cmd.addr_low = lower_32_bits(dma_addr);
+                sata_cmd.addr_high = upper_32_bits(dma_addr);
+                sata_cmd.len = cpu_to_le32(task->total_xfer_len);
+                sata_cmd.esgl = 0;
+        } else if (task->num_scatter == 0) {
+                sata_cmd.addr_low = 0;
+                sata_cmd.addr_high = 0;
+                sata_cmd.len = cpu_to_le32(task->total_xfer_len);
+                sata_cmd.esgl = 0;
+        }
+        ret = mpi_build_cmd(pm8001_ha, circularQ, opc, &sata_cmd);
+        return ret;
+}
+
+/**
+ * pm8001_chip_phy_start_req - start phy via PHY_START COMMAND
+ * @pm8001_ha: our hba card information.
+ * @num: the inbound queue number
+ * @phy_id: the phy id which we wanted to start up.
+ */
+static int
+pm8001_chip_phy_start_req(struct pm8001_hba_info *pm8001_ha, u8 phy_id)
+{
+        struct phy_start_req payload;
+        struct inbound_queue_table *circularQ;
+        int ret;
+        u32 tag = 0x01;
+        u32 opcode = OPC_INB_PHYSTART;
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        memset(&payload, 0, sizeof(payload));
+        payload.tag = cpu_to_le32(tag);
+        /*
+         ** [0:7]   PHY Identifier
+         ** [8:11]  link rate 1.5G, 3G, 6G
+         ** [12:13] link mode 01b SAS mode; 10b SATA mode; 11b both
+         ** [14]    0b disable spin up hold; 1b enable spin up hold
+         */
+        payload.ase_sh_lm_slr_phyid = cpu_to_le32(SPINHOLD_DISABLE |
+                LINKMODE_AUTO | LINKRATE_15 |
+                LINKRATE_30 | LINKRATE_60 | phy_id);
+        payload.sas_identify.dev_type = SAS_END_DEV;
+        payload.sas_identify.initiator_bits = SAS_PROTOCOL_ALL;
+        memcpy(payload.sas_identify.sas_addr,
+                pm8001_ha->sas_addr, SAS_ADDR_SIZE);
+        payload.sas_identify.phy_id = phy_id;
+        ret = mpi_build_cmd(pm8001_ha, circularQ, opcode, &payload);
+        return ret;
+}
+
+/**
+ * pm8001_chip_phy_stop_req - start phy via PHY_STOP COMMAND
+ * @pm8001_ha: our hba card information.
+ * @num: the inbound queue number
+ * @phy_id: the phy id which we wanted to start up.
+ */
+static int pm8001_chip_phy_stop_req(struct pm8001_hba_info *pm8001_ha,
+        u8 phy_id)
+{
+        struct phy_stop_req payload;
+        struct inbound_queue_table *circularQ;
+        int ret;
+        u32 tag = 0x01;
+        u32 opcode = OPC_INB_PHYSTOP;
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        memset(&payload, 0, sizeof(payload));
+        payload.tag = cpu_to_le32(tag);
+        payload.phy_id = cpu_to_le32(phy_id);
+        ret = mpi_build_cmd(pm8001_ha, circularQ, opcode, &payload);
+        return ret;
+}
+
+/**
+ * see comments on mpi_reg_resp.
+ */
+static int pm8001_chip_reg_dev_req(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_device *pm8001_dev, u32 flag)
+{
+        struct reg_dev_req payload;
+        u32     opc;
+        u32 stp_sspsmp_sata = 0x4;
+        struct inbound_queue_table *circularQ;
+        u32 linkrate, phy_id;
+        int rc, tag = 0xdeadbeef;
+        struct pm8001_ccb_info *ccb;
+        u8 retryFlag = 0x1;
+        u16 firstBurstSize = 0;
+        u16 ITNT = 2000;
+        struct domain_device *dev = pm8001_dev->sas_device;
+        struct domain_device *parent_dev = dev->parent;
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+
+        memset(&payload, 0, sizeof(payload));
+        rc = pm8001_tag_alloc(pm8001_ha, &tag);
+        if (rc)
+                return rc;
+        ccb = &pm8001_ha->ccb_info[tag];
+        ccb->device = pm8001_dev;
+        ccb->ccb_tag = tag;
+        payload.tag = cpu_to_le32(tag);
+        if (flag == 1)
+                stp_sspsmp_sata = 0x02; /*direct attached sata */
+        else {
+                if (pm8001_dev->dev_type == SATA_DEV)
+                        stp_sspsmp_sata = 0x00; /* stp*/
+                else if (pm8001_dev->dev_type == SAS_END_DEV ||
+                        pm8001_dev->dev_type == EDGE_DEV ||
+                        pm8001_dev->dev_type == FANOUT_DEV)
+                        stp_sspsmp_sata = 0x01; /*ssp or smp*/
+        }
+        if (parent_dev && DEV_IS_EXPANDER(parent_dev->dev_type))
+                phy_id = parent_dev->ex_dev.ex_phy->phy_id;
+        else
+                phy_id = pm8001_dev->attached_phy;
+        opc = OPC_INB_REG_DEV;
+        linkrate = (pm8001_dev->sas_device->linkrate < dev->port->linkrate) ?
+                        pm8001_dev->sas_device->linkrate : dev->port->linkrate;
+        payload.phyid_portid =
+                cpu_to_le32(((pm8001_dev->sas_device->port->id) & 0x0F) |
+                ((phy_id & 0x0F) << 4));
+        payload.dtype_dlr_retry = cpu_to_le32((retryFlag & 0x01) |
+                ((linkrate & 0x0F) * 0x1000000) |
+                ((stp_sspsmp_sata & 0x03) * 0x10000000));
+        payload.firstburstsize_ITNexustimeout =
+                cpu_to_le32(ITNT | (firstBurstSize * 0x10000));
+        memcpy(payload.sas_addr, pm8001_dev->sas_device->sas_addr,
+                SAS_ADDR_SIZE);
+        rc = mpi_build_cmd(pm8001_ha, circularQ, opc, &payload);
+        return rc;
+}
+
+/**
+ * see comments on mpi_reg_resp.
+ */
+static int pm8001_chip_dereg_dev_req(struct pm8001_hba_info *pm8001_ha,
+        u32 device_id)
+{
+        struct dereg_dev_req payload;
+        u32 opc = OPC_INB_DEREG_DEV_HANDLE;
+        int ret;
+        struct inbound_queue_table *circularQ;
+
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        memset(&payload, 0, sizeof(payload));
+        payload.tag = 1;
+        payload.device_id = cpu_to_le32(device_id);
+        PM8001_MSG_DBG(pm8001_ha,
+                pm8001_printk("unregister device device_id = %d\n", device_id));
+        ret = mpi_build_cmd(pm8001_ha, circularQ, opc, &payload);
+        return ret;
+}
+
+/**
+ * pm8001_chip_phy_ctl_req - support the local phy operation
+ * @pm8001_ha: our hba card information.
+ * @num: the inbound queue number
+ * @phy_id: the phy id which we wanted to operate
+ * @phy_op:
+ */
+static int pm8001_chip_phy_ctl_req(struct pm8001_hba_info *pm8001_ha,
+        u32 phyId, u32 phy_op)
+{
+        struct local_phy_ctl_req payload;
+        struct inbound_queue_table *circularQ;
+        int ret;
+        u32 opc = OPC_INB_LOCAL_PHY_CONTROL;
+        memset(&payload, 0, sizeof(payload));
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        payload.tag = 1;
+        payload.phyop_phyid =
+                cpu_to_le32(((phy_op & 0xff) << 8) | (phyId & 0x0F));
+        ret = mpi_build_cmd(pm8001_ha, circularQ, opc, &payload);
+        return ret;
+}
+
+static u32 pm8001_chip_is_our_interupt(struct pm8001_hba_info *pm8001_ha)
+{
+        u32 value;
+#ifdef PM8001_USE_MSIX
+        return 1;
+#endif
+        value = pm8001_cr32(pm8001_ha, 0, MSGU_ODR);
+        if (value)
+                return 1;
+        return 0;
+
+}
+
+/**
+ * pm8001_chip_isr - PM8001 isr handler.
+ * @pm8001_ha: our hba card information.
+ * @irq: irq number.
+ * @stat: stat.
+ */
+static irqreturn_t
+pm8001_chip_isr(struct pm8001_hba_info *pm8001_ha)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&pm8001_ha->lock, flags);
+        pm8001_chip_interrupt_disable(pm8001_ha);
+        process_oq(pm8001_ha);
+        pm8001_chip_interrupt_enable(pm8001_ha);
+        spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+        return IRQ_HANDLED;
+}
+
+static int send_task_abort(struct pm8001_hba_info *pm8001_ha, u32 opc,
+        u32 dev_id, u8 flag, u32 task_tag, u32 cmd_tag)
+{
+        struct task_abort_req task_abort;
+        struct inbound_queue_table *circularQ;
+        int ret;
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        memset(&task_abort, 0, sizeof(task_abort));
+        if (ABORT_SINGLE == (flag & ABORT_MASK)) {
+                task_abort.abort_all = 0;
+                task_abort.device_id = cpu_to_le32(dev_id);
+                task_abort.tag_to_abort = cpu_to_le32(task_tag);
+                task_abort.tag = cpu_to_le32(cmd_tag);
+        } else if (ABORT_ALL == (flag & ABORT_MASK)) {
+                task_abort.abort_all = cpu_to_le32(1);
+                task_abort.device_id = cpu_to_le32(dev_id);
+                task_abort.tag = cpu_to_le32(cmd_tag);
+        }
+        ret = mpi_build_cmd(pm8001_ha, circularQ, opc, &task_abort);
+        return ret;
+}
+
+/**
+ * pm8001_chip_abort_task - SAS abort task when error or exception happened.
+ * @task: the task we wanted to aborted.
+ * @flag: the abort flag.
+ */
+static int pm8001_chip_abort_task(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_device *pm8001_dev, u8 flag, u32 task_tag, u32 cmd_tag)
+{
+        u32 opc, device_id;
+        int rc = TMF_RESP_FUNC_FAILED;
+        PM8001_EH_DBG(pm8001_ha, pm8001_printk("cmd_tag = %x, abort task tag"
+                " = %x", cmd_tag, task_tag));
+        if (pm8001_dev->dev_type == SAS_END_DEV)
+                opc = OPC_INB_SSP_ABORT;
+        else if (pm8001_dev->dev_type == SATA_DEV)
+                opc = OPC_INB_SATA_ABORT;
+        else
+                opc = OPC_INB_SMP_ABORT;/* SMP */
+        device_id = pm8001_dev->device_id;
+        rc = send_task_abort(pm8001_ha, opc, device_id, flag,
+                task_tag, cmd_tag);
+        if (rc != TMF_RESP_FUNC_COMPLETE)
+                PM8001_EH_DBG(pm8001_ha, pm8001_printk("rc= %d\n", rc));
+        return rc;
+}
+
+/**
+ * pm8001_chip_ssp_tm_req - built the task managment command.
+ * @pm8001_ha: our hba card information.
+ * @ccb: the ccb information.
+ * @tmf: task management function.
+ */
+static int pm8001_chip_ssp_tm_req(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_ccb_info *ccb, struct pm8001_tmf_task *tmf)
+{
+        struct sas_task *task = ccb->task;
+        struct domain_device *dev = task->dev;
+        struct pm8001_device *pm8001_dev = dev->lldd_dev;
+        u32 opc = OPC_INB_SSPINITMSTART;
+        struct inbound_queue_table *circularQ;
+        struct ssp_ini_tm_start_req sspTMCmd;
+        int ret;
+
+        memset(&sspTMCmd, 0, sizeof(sspTMCmd));
+        sspTMCmd.device_id = cpu_to_le32(pm8001_dev->device_id);
+        sspTMCmd.relate_tag = cpu_to_le32(tmf->tag_of_task_to_be_managed);
+        sspTMCmd.tmf = cpu_to_le32(tmf->tmf);
+        memcpy(sspTMCmd.lun, task->ssp_task.LUN, 8);
+        sspTMCmd.tag = cpu_to_le32(ccb->ccb_tag);
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        ret = mpi_build_cmd(pm8001_ha, circularQ, opc, &sspTMCmd);
+        return ret;
+}
+
+static int pm8001_chip_get_nvmd_req(struct pm8001_hba_info *pm8001_ha,
+        void *payload)
+{
+        u32 opc = OPC_INB_GET_NVMD_DATA;
+        u32 nvmd_type;
+        int rc;
+        u32 tag;
+        struct pm8001_ccb_info *ccb;
+        struct inbound_queue_table *circularQ;
+        struct get_nvm_data_req nvmd_req;
+        struct fw_control_ex *fw_control_context;
+        struct pm8001_ioctl_payload *ioctl_payload = payload;
+
+        nvmd_type = ioctl_payload->minor_function;
+        fw_control_context = kzalloc(sizeof(struct fw_control_ex), GFP_KERNEL);
+        fw_control_context->usrAddr = (u8 *)&ioctl_payload->func_specific[0];
+        fw_control_context->len = ioctl_payload->length;
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        memset(&nvmd_req, 0, sizeof(nvmd_req));
+        rc = pm8001_tag_alloc(pm8001_ha, &tag);
+        if (rc)
+                return rc;
+        ccb = &pm8001_ha->ccb_info[tag];
+        ccb->ccb_tag = tag;
+        ccb->fw_control_context = fw_control_context;
+        nvmd_req.tag = cpu_to_le32(tag);
+
+        switch (nvmd_type) {
+        case TWI_DEVICE: {
+                u32 twi_addr, twi_page_size;
+                twi_addr = 0xa8;
+                twi_page_size = 2;
+
+                nvmd_req.len_ir_vpdd = cpu_to_le32(IPMode | twi_addr << 16 |
+                        twi_page_size << 8 | TWI_DEVICE);
+                nvmd_req.resp_len = cpu_to_le32(ioctl_payload->length);
+                nvmd_req.resp_addr_hi =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_hi);
+                nvmd_req.resp_addr_lo =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_lo);
+                break;
+        }
+        case C_SEEPROM: {
+                nvmd_req.len_ir_vpdd = cpu_to_le32(IPMode | C_SEEPROM);
+                nvmd_req.resp_len = cpu_to_le32(ioctl_payload->length);
+                nvmd_req.resp_addr_hi =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_hi);
+                nvmd_req.resp_addr_lo =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_lo);
+                break;
+        }
+        case VPD_FLASH: {
+                nvmd_req.len_ir_vpdd = cpu_to_le32(IPMode | VPD_FLASH);
+                nvmd_req.resp_len = cpu_to_le32(ioctl_payload->length);
+                nvmd_req.resp_addr_hi =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_hi);
+                nvmd_req.resp_addr_lo =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_lo);
+                break;
+        }
+        case EXPAN_ROM: {
+                nvmd_req.len_ir_vpdd = cpu_to_le32(IPMode | EXPAN_ROM);
+                nvmd_req.resp_len = cpu_to_le32(ioctl_payload->length);
+                nvmd_req.resp_addr_hi =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_hi);
+                nvmd_req.resp_addr_lo =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_lo);
+                break;
+        }
+        default:
+                break;
+        }
+        rc = mpi_build_cmd(pm8001_ha, circularQ, opc, &nvmd_req);
+        return rc;
+}
+
+static int pm8001_chip_set_nvmd_req(struct pm8001_hba_info *pm8001_ha,
+        void *payload)
+{
+        u32 opc = OPC_INB_SET_NVMD_DATA;
+        u32 nvmd_type;
+        int rc;
+        u32 tag;
+        struct pm8001_ccb_info *ccb;
+        struct inbound_queue_table *circularQ;
+        struct set_nvm_data_req nvmd_req;
+        struct fw_control_ex *fw_control_context;
+        struct pm8001_ioctl_payload *ioctl_payload = payload;
+
+        nvmd_type = ioctl_payload->minor_function;
+        fw_control_context = kzalloc(sizeof(struct fw_control_ex), GFP_KERNEL);
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        memcpy(pm8001_ha->memoryMap.region[NVMD].virt_ptr,
+                ioctl_payload->func_specific,
+                ioctl_payload->length);
+        memset(&nvmd_req, 0, sizeof(nvmd_req));
+        rc = pm8001_tag_alloc(pm8001_ha, &tag);
+        if (rc)
+                return rc;
+        ccb = &pm8001_ha->ccb_info[tag];
+        ccb->fw_control_context = fw_control_context;
+        ccb->ccb_tag = tag;
+        nvmd_req.tag = cpu_to_le32(tag);
+        switch (nvmd_type) {
+        case TWI_DEVICE: {
+                u32 twi_addr, twi_page_size;
+                twi_addr = 0xa8;
+                twi_page_size = 2;
+                nvmd_req.reserved[0] = cpu_to_le32(0xFEDCBA98);
+                nvmd_req.len_ir_vpdd = cpu_to_le32(IPMode | twi_addr << 16 |
+                        twi_page_size << 8 | TWI_DEVICE);
+                nvmd_req.resp_len = cpu_to_le32(ioctl_payload->length);
+                nvmd_req.resp_addr_hi =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_hi);
+                nvmd_req.resp_addr_lo =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_lo);
+                break;
+        }
+        case C_SEEPROM:
+                nvmd_req.len_ir_vpdd = cpu_to_le32(IPMode | C_SEEPROM);
+                nvmd_req.resp_len = cpu_to_le32(ioctl_payload->length);
+                nvmd_req.reserved[0] = cpu_to_le32(0xFEDCBA98);
+                nvmd_req.resp_addr_hi =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_hi);
+                nvmd_req.resp_addr_lo =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_lo);
+                break;
+        case VPD_FLASH:
+                nvmd_req.len_ir_vpdd = cpu_to_le32(IPMode | VPD_FLASH);
+                nvmd_req.resp_len = cpu_to_le32(ioctl_payload->length);
+                nvmd_req.reserved[0] = cpu_to_le32(0xFEDCBA98);
+                nvmd_req.resp_addr_hi =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_hi);
+                nvmd_req.resp_addr_lo =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_lo);
+                break;
+        case EXPAN_ROM:
+                nvmd_req.len_ir_vpdd = cpu_to_le32(IPMode | EXPAN_ROM);
+                nvmd_req.resp_len = cpu_to_le32(ioctl_payload->length);
+                nvmd_req.reserved[0] = cpu_to_le32(0xFEDCBA98);
+                nvmd_req.resp_addr_hi =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_hi);
+                nvmd_req.resp_addr_lo =
+                    cpu_to_le32(pm8001_ha->memoryMap.region[NVMD].phys_addr_lo);
+                break;
+        default:
+                break;
+        }
+        rc = mpi_build_cmd(pm8001_ha, circularQ, opc, &nvmd_req);
+        return rc;
+}
+
+/**
+ * pm8001_chip_fw_flash_update_build - support the firmware update operation
+ * @pm8001_ha: our hba card information.
+ * @fw_flash_updata_info: firmware flash update param
+ */
+static int
+pm8001_chip_fw_flash_update_build(struct pm8001_hba_info *pm8001_ha,
+        void *fw_flash_updata_info, u32 tag)
+{
+        struct fw_flash_Update_req payload;
+        struct fw_flash_updata_info *info;
+        struct inbound_queue_table *circularQ;
+        int ret;
+        u32 opc = OPC_INB_FW_FLASH_UPDATE;
+
+        memset(&payload, 0, sizeof(struct fw_flash_Update_req));
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        info = fw_flash_updata_info;
+        payload.tag = cpu_to_le32(tag);
+        payload.cur_image_len = cpu_to_le32(info->cur_image_len);
+        payload.cur_image_offset = cpu_to_le32(info->cur_image_offset);
+        payload.total_image_len = cpu_to_le32(info->total_image_len);
+        payload.len = info->sgl.im_len.len ;
+        payload.sgl_addr_lo = lower_32_bits(info->sgl.addr);
+        payload.sgl_addr_hi = upper_32_bits(info->sgl.addr);
+        ret = mpi_build_cmd(pm8001_ha, circularQ, opc, &payload);
+        return ret;
+}
+
+static int
+pm8001_chip_fw_flash_update_req(struct pm8001_hba_info *pm8001_ha,
+        void *payload)
+{
+        struct fw_flash_updata_info flash_update_info;
+        struct fw_control_info *fw_control;
+        struct fw_control_ex *fw_control_context;
+        int rc;
+        u32 tag;
+        struct pm8001_ccb_info *ccb;
+        void *buffer = NULL;
+        dma_addr_t phys_addr;
+        u32 phys_addr_hi;
+        u32 phys_addr_lo;
+        struct pm8001_ioctl_payload *ioctl_payload = payload;
+
+        fw_control_context = kzalloc(sizeof(struct fw_control_ex), GFP_KERNEL);
+        fw_control = (struct fw_control_info *)&ioctl_payload->func_specific[0];
+        if (fw_control->len != 0) {
+                if (pm8001_mem_alloc(pm8001_ha->pdev,
+                        (void **)&buffer,
+                        &phys_addr,
+                        &phys_addr_hi,
+                        &phys_addr_lo,
+                        fw_control->len, 0) != 0) {
+                                PM8001_FAIL_DBG(pm8001_ha,
+                                        pm8001_printk("Mem alloc failure\n"));
+                                return -ENOMEM;
+                }
+        }
+        memset(buffer, 0, fw_control->len);
+        memcpy(buffer, fw_control->buffer, fw_control->len);
+        flash_update_info.sgl.addr = cpu_to_le64(phys_addr);
+        flash_update_info.sgl.im_len.len = cpu_to_le32(fw_control->len);
+        flash_update_info.sgl.im_len.e = 0;
+        flash_update_info.cur_image_offset = fw_control->offset;
+        flash_update_info.cur_image_len = fw_control->len;
+        flash_update_info.total_image_len = fw_control->size;
+        fw_control_context->fw_control = fw_control;
+        fw_control_context->virtAddr = buffer;
+        fw_control_context->len = fw_control->len;
+        rc = pm8001_tag_alloc(pm8001_ha, &tag);
+        if (rc)
+                return rc;
+        ccb = &pm8001_ha->ccb_info[tag];
+        ccb->fw_control_context = fw_control_context;
+        ccb->ccb_tag = tag;
+        rc = pm8001_chip_fw_flash_update_build(pm8001_ha, &flash_update_info,
+                tag);
+        return rc;
+}
+
+static int
+pm8001_chip_set_dev_state_req(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_device *pm8001_dev, u32 state)
+{
+        struct set_dev_state_req payload;
+        struct inbound_queue_table *circularQ;
+        struct pm8001_ccb_info *ccb;
+        int rc;
+        u32 tag;
+        u32 opc = OPC_INB_SET_DEVICE_STATE;
+        memset(&payload, 0, sizeof(payload));
+        rc = pm8001_tag_alloc(pm8001_ha, &tag);
+        if (rc)
+                return -1;
+        ccb = &pm8001_ha->ccb_info[tag];
+        ccb->ccb_tag = tag;
+        ccb->device = pm8001_dev;
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        payload.tag = cpu_to_le32(tag);
+        payload.device_id = cpu_to_le32(pm8001_dev->device_id);
+        payload.nds = cpu_to_le32(state);
+        rc = mpi_build_cmd(pm8001_ha, circularQ, opc, &payload);
+        return rc;
+
+}
+
+static int
+pm8001_chip_sas_re_initialization(struct pm8001_hba_info *pm8001_ha)
+{
+        struct sas_re_initialization_req payload;
+        struct inbound_queue_table *circularQ;
+        struct pm8001_ccb_info *ccb;
+        int rc;
+        u32 tag;
+        u32 opc = OPC_INB_SAS_RE_INITIALIZE;
+        memset(&payload, 0, sizeof(payload));
+        rc = pm8001_tag_alloc(pm8001_ha, &tag);
+        if (rc)
+                return -1;
+        ccb = &pm8001_ha->ccb_info[tag];
+        ccb->ccb_tag = tag;
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        payload.tag = cpu_to_le32(tag);
+        payload.SSAHOLT = cpu_to_le32(0xd << 25);
+        payload.sata_hol_tmo = cpu_to_le32(80);
+        payload.open_reject_cmdretries_data_retries = cpu_to_le32(0xff00ff);
+        rc = mpi_build_cmd(pm8001_ha, circularQ, opc, &payload);
+        return rc;
+
+}
+
+const struct pm8001_dispatch pm8001_8001_dispatch = {
+        .name                   = "pmc8001",
+        .chip_init              = pm8001_chip_init,
+        .chip_soft_rst          = pm8001_chip_soft_rst,
+        .chip_rst               = pm8001_hw_chip_rst,
+        .chip_iounmap           = pm8001_chip_iounmap,
+        .isr                    = pm8001_chip_isr,
+        .is_our_interupt        = pm8001_chip_is_our_interupt,
+        .isr_process_oq         = process_oq,
+        .interrupt_enable       = pm8001_chip_interrupt_enable,
+        .interrupt_disable      = pm8001_chip_interrupt_disable,
+        .make_prd               = pm8001_chip_make_sg,
+        .smp_req                = pm8001_chip_smp_req,
+        .ssp_io_req             = pm8001_chip_ssp_io_req,
+        .sata_req               = pm8001_chip_sata_req,
+        .phy_start_req          = pm8001_chip_phy_start_req,
+        .phy_stop_req           = pm8001_chip_phy_stop_req,
+        .reg_dev_req            = pm8001_chip_reg_dev_req,
+        .dereg_dev_req          = pm8001_chip_dereg_dev_req,
+        .phy_ctl_req            = pm8001_chip_phy_ctl_req,
+        .task_abort             = pm8001_chip_abort_task,
+        .ssp_tm_req             = pm8001_chip_ssp_tm_req,
+        .get_nvmd_req           = pm8001_chip_get_nvmd_req,
+        .set_nvmd_req           = pm8001_chip_set_nvmd_req,
+        .fw_flash_update_req    = pm8001_chip_fw_flash_update_req,
+        .set_dev_state_req      = pm8001_chip_set_dev_state_req,
+        .sas_re_init_req        = pm8001_chip_sas_re_initialization,
+};
+
diff --git a/drivers/scsi/pm8001/pm8001_hwi.h b/drivers/scsi/pm8001/pm8001_hwi.h
new file mode 100644
index 000000000000..833a5201eda4
--- /dev/null
+++ b/drivers/scsi/pm8001/pm8001_hwi.h
@@ -0,0 +1,1029 @@
+/*
+ * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
+ *
+ * Copyright (c) 2008-2009 USI Co., Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ */
+#ifndef _PMC8001_REG_H_
+#define _PMC8001_REG_H_
+
+#include <linux/types.h>
+#include <scsi/libsas.h>
+
+
+/* for Request Opcode of IOMB */
+#define OPC_INB_ECHO                            1       /* 0x000 */
+#define OPC_INB_PHYSTART                        4       /* 0x004 */
+#define OPC_INB_PHYSTOP                         5       /* 0x005 */
+#define OPC_INB_SSPINIIOSTART                   6       /* 0x006 */
+#define OPC_INB_SSPINITMSTART                   7       /* 0x007 */
+#define OPC_INB_SSPINIEXTIOSTART                8       /* 0x008 */
+#define OPC_INB_DEV_HANDLE_ACCEPT               9       /* 0x009 */
+#define OPC_INB_SSPTGTIOSTART                   10      /* 0x00A */
+#define OPC_INB_SSPTGTRSPSTART                  11      /* 0x00B */
+#define OPC_INB_SSPINIEDCIOSTART                12      /* 0x00C */
+#define OPC_INB_SSPINIEXTEDCIOSTART             13      /* 0x00D */
+#define OPC_INB_SSPTGTEDCIOSTART                14      /* 0x00E */
+#define OPC_INB_SSP_ABORT                       15      /* 0x00F */
+#define OPC_INB_DEREG_DEV_HANDLE                16      /* 0x010 */
+#define OPC_INB_GET_DEV_HANDLE                  17      /* 0x011 */
+#define OPC_INB_SMP_REQUEST                     18      /* 0x012 */
+/* SMP_RESPONSE is removed */
+#define OPC_INB_SMP_RESPONSE                    19      /* 0x013 */
+#define OPC_INB_SMP_ABORT                       20      /* 0x014 */
+#define OPC_INB_REG_DEV                         22      /* 0x016 */
+#define OPC_INB_SATA_HOST_OPSTART               23      /* 0x017 */
+#define OPC_INB_SATA_ABORT                      24      /* 0x018 */
+#define OPC_INB_LOCAL_PHY_CONTROL               25      /* 0x019 */
+#define OPC_INB_GET_DEV_INFO                    26      /* 0x01A */
+#define OPC_INB_FW_FLASH_UPDATE                 32      /* 0x020 */
+#define OPC_INB_GPIO                            34      /* 0x022 */
+#define OPC_INB_SAS_DIAG_MODE_START_END         35      /* 0x023 */
+#define OPC_INB_SAS_DIAG_EXECUTE                36      /* 0x024 */
+#define OPC_INB_SAS_HW_EVENT_ACK                37      /* 0x025 */
+#define OPC_INB_GET_TIME_STAMP                  38      /* 0x026 */
+#define OPC_INB_PORT_CONTROL                    39      /* 0x027 */
+#define OPC_INB_GET_NVMD_DATA                   40      /* 0x028 */
+#define OPC_INB_SET_NVMD_DATA                   41      /* 0x029 */
+#define OPC_INB_SET_DEVICE_STATE                42      /* 0x02A */
+#define OPC_INB_GET_DEVICE_STATE                43      /* 0x02B */
+#define OPC_INB_SET_DEV_INFO                    44      /* 0x02C */
+#define OPC_INB_SAS_RE_INITIALIZE               45      /* 0x02D */
+
+/* for Response Opcode of IOMB */
+#define OPC_OUB_ECHO                            1       /* 0x001 */
+#define OPC_OUB_HW_EVENT                        4       /* 0x004 */
+#define OPC_OUB_SSP_COMP                        5       /* 0x005 */
+#define OPC_OUB_SMP_COMP                        6       /* 0x006 */
+#define OPC_OUB_LOCAL_PHY_CNTRL                 7       /* 0x007 */
+#define OPC_OUB_DEV_REGIST                      10      /* 0x00A */
+#define OPC_OUB_DEREG_DEV                       11      /* 0x00B */
+#define OPC_OUB_GET_DEV_HANDLE                  12      /* 0x00C */
+#define OPC_OUB_SATA_COMP                       13      /* 0x00D */
+#define OPC_OUB_SATA_EVENT                      14      /* 0x00E */
+#define OPC_OUB_SSP_EVENT                       15      /* 0x00F */
+#define OPC_OUB_DEV_HANDLE_ARRIV                16      /* 0x010 */
+/* SMP_RECEIVED Notification is removed */
+#define OPC_OUB_SMP_RECV_EVENT                  17      /* 0x011 */
+#define OPC_OUB_SSP_RECV_EVENT                  18      /* 0x012 */
+#define OPC_OUB_DEV_INFO                        19      /* 0x013 */
+#define OPC_OUB_FW_FLASH_UPDATE                 20      /* 0x014 */
+#define OPC_OUB_GPIO_RESPONSE                   22      /* 0x016 */
+#define OPC_OUB_GPIO_EVENT                      23      /* 0x017 */
+#define OPC_OUB_GENERAL_EVENT                   24      /* 0x018 */
+#define OPC_OUB_SSP_ABORT_RSP                   26      /* 0x01A */
+#define OPC_OUB_SATA_ABORT_RSP                  27      /* 0x01B */
+#define OPC_OUB_SAS_DIAG_MODE_START_END         28      /* 0x01C */
+#define OPC_OUB_SAS_DIAG_EXECUTE                29      /* 0x01D */
+#define OPC_OUB_GET_TIME_STAMP                  30      /* 0x01E */
+#define OPC_OUB_SAS_HW_EVENT_ACK                31      /* 0x01F */
+#define OPC_OUB_PORT_CONTROL                    32      /* 0x020 */
+#define OPC_OUB_SKIP_ENTRY                      33      /* 0x021 */
+#define OPC_OUB_SMP_ABORT_RSP                   34      /* 0x022 */
+#define OPC_OUB_GET_NVMD_DATA                   35      /* 0x023 */
+#define OPC_OUB_SET_NVMD_DATA                   36      /* 0x024 */
+#define OPC_OUB_DEVICE_HANDLE_REMOVAL           37      /* 0x025 */
+#define OPC_OUB_SET_DEVICE_STATE                38      /* 0x026 */
+#define OPC_OUB_GET_DEVICE_STATE                39      /* 0x027 */
+#define OPC_OUB_SET_DEV_INFO                    40      /* 0x028 */
+#define OPC_OUB_SAS_RE_INITIALIZE               41      /* 0x029 */
+
+/* for phy start*/
+#define SPINHOLD_DISABLE                (0x00 << 14)
+#define SPINHOLD_ENABLE                 (0x01 << 14)
+#define LINKMODE_SAS                    (0x01 << 12)
+#define LINKMODE_DSATA                  (0x02 << 12)
+#define LINKMODE_AUTO                   (0x03 << 12)
+#define LINKRATE_15                     (0x01 << 8)
+#define LINKRATE_30                     (0x02 << 8)
+#define LINKRATE_60                     (0x04 << 8)
+
+struct mpi_msg_hdr{
+        __le32  header; /* Bits [11:0]  - Message operation code */
+        /* Bits [15:12] - Message Category */
+        /* Bits [21:16] - Outboundqueue ID for the
+        operation completion message */
+        /* Bits [23:22] - Reserved */
+        /* Bits [28:24] - Buffer Count, indicates how
+        many buffer are allocated for the massage */
+        /* Bits [30:29] - Reserved */
+        /* Bits [31] - Message Valid bit */
+} __attribute__((packed, aligned(4)));
+
+
+/*
+ * brief the data structure of PHY Start Command
+ * use to describe enable the phy (64 bytes)
+ */
+struct phy_start_req {
+        __le32  tag;
+        __le32  ase_sh_lm_slr_phyid;
+        struct sas_identify_frame sas_identify;
+        u32     reserved[5];
+} __attribute__((packed, aligned(4)));
+
+
+/*
+ * brief the data structure of PHY Start Command
+ * use to disable the phy (64 bytes)
+ */
+struct phy_stop_req {
+        __le32  tag;
+        __le32  phy_id;
+        u32     reserved[13];
+} __attribute__((packed, aligned(4)));
+
+
+/* set device bits fis - device to host */
+struct  set_dev_bits_fis {
+        u8      fis_type;       /* 0xA1*/
+        u8      n_i_pmport;
+        /* b7 : n Bit. Notification bit. If set device needs attention. */
+        /* b6 : i Bit. Interrupt Bit */
+        /* b5-b4: reserved2 */
+        /* b3-b0: PM Port */
+        u8      status;
+        u8      error;
+        u32     _r_a;
+} __attribute__ ((packed));
+/* PIO setup FIS - device to host */
+struct  pio_setup_fis {
+        u8      fis_type;       /* 0x5f */
+        u8      i_d_pmPort;
+        /* b7 : reserved */
+        /* b6 : i bit. Interrupt bit */
+        /* b5 : d bit. data transfer direction. set to 1 for device to host
+        xfer */
+        /* b4 : reserved */
+        /* b3-b0: PM Port */
+        u8      status;
+        u8      error;
+        u8      lbal;
+        u8      lbam;
+        u8      lbah;
+        u8      device;
+        u8      lbal_exp;
+        u8      lbam_exp;
+        u8      lbah_exp;
+        u8      _r_a;
+        u8      sector_count;
+        u8      sector_count_exp;
+        u8      _r_b;
+        u8      e_status;
+        u8      _r_c[2];
+        u8      transfer_count;
+} __attribute__ ((packed));
+
+/*
+ * brief the data structure of SATA Completion Response
+ * use to discribe the sata task response (64 bytes)
+ */
+struct sata_completion_resp {
+        __le32  tag;
+        __le32  status;
+        __le32  param;
+        u32     sata_resp[12];
+} __attribute__((packed, aligned(4)));
+
+
+/*
+ * brief the data structure of SAS HW Event Notification
+ * use to alert the host about the hardware event(64 bytes)
+ */
+struct hw_event_resp {
+        __le32  lr_evt_status_phyid_portid;
+        __le32  evt_param;
+        __le32  npip_portstate;
+        struct sas_identify_frame       sas_identify;
+        struct dev_to_host_fis  sata_fis;
+} __attribute__((packed, aligned(4)));
+
+
+/*
+ * brief the data structure of  REGISTER DEVICE Command
+ * use to describe MPI REGISTER DEVICE Command (64 bytes)
+ */
+
+struct reg_dev_req {
+        __le32  tag;
+        __le32  phyid_portid;
+        __le32  dtype_dlr_retry;
+        __le32  firstburstsize_ITNexustimeout;
+        u8      sas_addr[SAS_ADDR_SIZE];
+        __le32  upper_device_id;
+        u32     reserved[8];
+} __attribute__((packed, aligned(4)));
+
+
+/*
+ * brief the data structure of  DEREGISTER DEVICE Command
+ * use to request spc to remove all internal resources associated
+ * with the device id (64 bytes)
+ */
+
+struct dereg_dev_req {
+        __le32  tag;
+        __le32  device_id;
+        u32     reserved[13];
+} __attribute__((packed, aligned(4)));
+
+
+/*
+ * brief the data structure of DEVICE_REGISTRATION Response
+ * use to notify the completion of the device registration  (64 bytes)
+ */
+
+struct dev_reg_resp {
+        __le32  tag;
+        __le32  status;
+        __le32  device_id;
+        u32     reserved[12];
+} __attribute__((packed, aligned(4)));
+
+
+/*
+ * brief the data structure of Local PHY Control Command
+ * use to issue PHY CONTROL to local phy (64 bytes)
+ */
+struct local_phy_ctl_req {
+        __le32  tag;
+        __le32  phyop_phyid;
+        u32     reserved1[13];
+} __attribute__((packed, aligned(4)));
+
+
+/**
+ * brief the data structure of Local Phy Control Response
+ * use to describe MPI Local Phy Control Response (64 bytes)
+ */
+struct local_phy_ctl_resp {
+        __le32  tag;
+        __le32  phyop_phyid;
+        __le32  status;
+        u32     reserved[12];
+} __attribute__((packed, aligned(4)));
+
+
+#define OP_BITS 0x0000FF00
+#define ID_BITS 0x0000000F
+
+/*
+ * brief the data structure of PORT Control Command
+ * use to control port properties (64 bytes)
+ */
+
+struct port_ctl_req {
+        __le32  tag;
+        __le32  portop_portid;
+        __le32  param0;
+        __le32  param1;
+        u32     reserved1[11];
+} __attribute__((packed, aligned(4)));
+
+
+/*
+ * brief the data structure of HW Event Ack Command
+ * use to acknowledge receive HW event (64 bytes)
+ */
+
+struct hw_event_ack_req {
+        __le32  tag;
+        __le32  sea_phyid_portid;
+        __le32  param0;
+        __le32  param1;
+        u32     reserved1[11];
+} __attribute__((packed, aligned(4)));
+
+
+/*
+ * brief the data structure of SSP Completion Response
+ * use to indicate a SSP Completion  (n bytes)
+ */
+struct ssp_completion_resp {
+        __le32  tag;
+        __le32  status;
+        __le32  param;
+        __le32  ssptag_rescv_rescpad;
+        struct ssp_response_iu  ssp_resp_iu;
+        __le32  residual_count;
+} __attribute__((packed, aligned(4)));
+
+
+#define SSP_RESCV_BIT   0x00010000
+
+/*
+ * brief the data structure of SATA EVNET esponse
+ * use to indicate a SATA Completion  (64 bytes)
+ */
+
+struct sata_event_resp {
+        __le32  tag;
+        __le32  event;
+        __le32  port_id;
+        __le32  device_id;
+        u32     reserved[11];
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of SSP EVNET esponse
+ * use to indicate a SSP Completion  (64 bytes)
+ */
+
+struct ssp_event_resp {
+        __le32  tag;
+        __le32  event;
+        __le32  port_id;
+        __le32  device_id;
+        u32     reserved[11];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure of General Event Notification Response
+ * use to describe MPI General Event Notification Response (64 bytes)
+ */
+struct general_event_resp {
+        __le32  status;
+        __le32  inb_IOMB_payload[14];
+} __attribute__((packed, aligned(4)));
+
+
+#define GENERAL_EVENT_PAYLOAD   14
+#define OPCODE_BITS     0x00000fff
+
+/*
+ * brief the data structure of SMP Request Command
+ * use to describe MPI SMP REQUEST Command (64 bytes)
+ */
+struct smp_req {
+        __le32  tag;
+        __le32  device_id;
+        __le32  len_ip_ir;
+        /* Bits [0]  - Indirect response */
+        /* Bits [1] - Indirect Payload */
+        /* Bits [15:2] - Reserved */
+        /* Bits [23:16] - direct payload Len */
+        /* Bits [31:24] - Reserved */
+        u8      smp_req16[16];
+        union {
+                u8      smp_req[32];
+                struct {
+                        __le64 long_req_addr;/* sg dma address, LE */
+                        __le32 long_req_size;/* LE */
+                        u32     _r_a;
+                        __le64 long_resp_addr;/* sg dma address, LE */
+                        __le32 long_resp_size;/* LE */
+                        u32     _r_b;
+                        } long_smp_req;/* sequencer extension */
+        };
+} __attribute__((packed, aligned(4)));
+/*
+ * brief the data structure of SMP Completion Response
+ * use to describe MPI SMP Completion Response (64 bytes)
+ */
+struct smp_completion_resp {
+        __le32  tag;
+        __le32  status;
+        __le32  param;
+        __le32  _r_a[12];
+} __attribute__((packed, aligned(4)));
+
+/*
+ *brief the data structure of SSP SMP SATA Abort Command
+ * use to describe MPI SSP SMP & SATA Abort Command (64 bytes)
+ */
+struct task_abort_req {
+        __le32  tag;
+        __le32  device_id;
+        __le32  tag_to_abort;
+        __le32  abort_all;
+        u32     reserved[11];
+} __attribute__((packed, aligned(4)));
+
+/* These flags used for SSP SMP & SATA Abort */
+#define ABORT_MASK              0x3
+#define ABORT_SINGLE            0x0
+#define ABORT_ALL               0x1
+
+/**
+ * brief the data structure of SSP SATA SMP Abort Response
+ * use to describe SSP SMP & SATA Abort Response ( 64 bytes)
+ */
+struct task_abort_resp {
+        __le32  tag;
+        __le32  status;
+        __le32  scp;
+        u32     reserved[12];
+} __attribute__((packed, aligned(4)));
+
+
+/**
+ * brief the data structure of SAS Diagnostic Start/End Command
+ * use to describe MPI SAS Diagnostic Start/End Command (64 bytes)
+ */
+struct sas_diag_start_end_req {
+        __le32  tag;
+        __le32  operation_phyid;
+        u32     reserved[13];
+} __attribute__((packed, aligned(4)));
+
+
+/**
+ * brief the data structure of SAS Diagnostic Execute Command
+ * use to describe MPI SAS Diagnostic Execute Command (64 bytes)
+ */
+struct sas_diag_execute_req{
+        __le32  tag;
+        __le32  cmdtype_cmddesc_phyid;
+        __le32  pat1_pat2;
+        __le32  threshold;
+        __le32  codepat_errmsk;
+        __le32  pmon;
+        __le32  pERF1CTL;
+        u32     reserved[8];
+} __attribute__((packed, aligned(4)));
+
+
+#define SAS_DIAG_PARAM_BYTES 24
+
+/*
+ * brief the data structure of Set Device State Command
+ * use to describe MPI Set Device State Command (64 bytes)
+ */
+struct set_dev_state_req {
+        __le32  tag;
+        __le32  device_id;
+        __le32  nds;
+        u32     reserved[12];
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of sas_re_initialization
+ */
+struct sas_re_initialization_req {
+
+        __le32  tag;
+        __le32  SSAHOLT;/* bit29-set max port;
+                        ** bit28-set open reject cmd retries.
+                        ** bit27-set open reject data retries.
+                        ** bit26-set open reject option, remap:1 or not:0.
+                        ** bit25-set sata head of line time out.
+                        */
+        __le32 reserved_maxPorts;
+        __le32 open_reject_cmdretries_data_retries;/* cmd retries: 31-bit16;
+                                                    * data retries: bit15-bit0.
+                                                    */
+        __le32  sata_hol_tmo;
+        u32     reserved1[10];
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of SATA Start Command
+ * use to describe MPI SATA IO Start Command (64 bytes)
+ */
+
+struct sata_start_req {
+        __le32  tag;
+        __le32  device_id;
+        __le32  data_len;
+        __le32  ncqtag_atap_dir_m;
+        struct host_to_dev_fis  sata_fis;
+        u32     reserved1;
+        u32     reserved2;
+        u32     addr_low;
+        u32     addr_high;
+        __le32  len;
+        __le32  esgl;
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure of SSP INI TM Start Command
+ * use to describe MPI SSP INI TM Start Command (64 bytes)
+ */
+struct ssp_ini_tm_start_req {
+        __le32  tag;
+        __le32  device_id;
+        __le32  relate_tag;
+        __le32  tmf;
+        u8      lun[8];
+        __le32  ds_ads_m;
+        u32     reserved[8];
+} __attribute__((packed, aligned(4)));
+
+
+struct ssp_info_unit {
+        u8      lun[8];/* SCSI Logical Unit Number */
+        u8      reserved1;/* reserved */
+        u8      efb_prio_attr;
+        /* B7   : enabledFirstBurst */
+        /* B6-3 : taskPriority */
+        /* B2-0 : taskAttribute */
+        u8      reserved2;      /* reserved */
+        u8      additional_cdb_len;
+        /* B7-2 : additional_cdb_len */
+        /* B1-0 : reserved */
+        u8      cdb[16];/* The SCSI CDB up to 16 bytes length */
+} __attribute__((packed, aligned(4)));
+
+
+/**
+ * brief the data structure of SSP INI IO Start Command
+ * use to describe MPI SSP INI IO Start Command (64 bytes)
+ */
+struct ssp_ini_io_start_req {
+        __le32  tag;
+        __le32  device_id;
+        __le32  data_len;
+        __le32  dir_m_tlr;
+        struct ssp_info_unit    ssp_iu;
+        __le32  addr_low;
+        __le32  addr_high;
+        __le32  len;
+        __le32  esgl;
+} __attribute__((packed, aligned(4)));
+
+
+/**
+ * brief the data structure of Firmware download
+ * use to describe MPI FW DOWNLOAD Command (64 bytes)
+ */
+struct fw_flash_Update_req {
+        __le32  tag;
+        __le32  cur_image_offset;
+        __le32  cur_image_len;
+        __le32  total_image_len;
+        u32     reserved0[7];
+        __le32  sgl_addr_lo;
+        __le32  sgl_addr_hi;
+        __le32  len;
+        __le32  ext_reserved;
+} __attribute__((packed, aligned(4)));
+
+
+#define FWFLASH_IOMB_RESERVED_LEN 0x07
+/**
+ * brief the data structure of FW_FLASH_UPDATE Response
+ * use to describe MPI FW_FLASH_UPDATE Response (64 bytes)
+ *
+ */
+struct fw_flash_Update_resp {
+        dma_addr_t      tag;
+        __le32  status;
+        u32     reserved[13];
+} __attribute__((packed, aligned(4)));
+
+
+/**
+ * brief the data structure of Get NVM Data Command
+ * use to get data from NVM in HBA(64 bytes)
+ */
+struct get_nvm_data_req {
+        __le32  tag;
+        __le32  len_ir_vpdd;
+        __le32  vpd_offset;
+        u32     reserved[8];
+        __le32  resp_addr_lo;
+        __le32  resp_addr_hi;
+        __le32  resp_len;
+        u32     reserved1;
+} __attribute__((packed, aligned(4)));
+
+
+struct set_nvm_data_req {
+        __le32  tag;
+        __le32  len_ir_vpdd;
+        __le32  vpd_offset;
+        u32     reserved[8];
+        __le32  resp_addr_lo;
+        __le32  resp_addr_hi;
+        __le32  resp_len;
+        u32     reserved1;
+} __attribute__((packed, aligned(4)));
+
+
+#define TWI_DEVICE      0x0
+#define C_SEEPROM       0x1
+#define VPD_FLASH       0x4
+#define AAP1_RDUMP      0x5
+#define IOP_RDUMP       0x6
+#define EXPAN_ROM       0x7
+
+#define IPMode          0x80000000
+#define NVMD_TYPE       0x0000000F
+#define NVMD_STAT       0x0000FFFF
+#define NVMD_LEN        0xFF000000
+/**
+ * brief the data structure of Get NVMD Data Response
+ * use to describe MPI Get NVMD Data Response (64 bytes)
+ */
+struct get_nvm_data_resp {
+        __le32          tag;
+        __le32          ir_tda_bn_dps_das_nvm;
+        __le32          dlen_status;
+        __le32          nvm_data[12];
+} __attribute__((packed, aligned(4)));
+
+
+/**
+ * brief the data structure of SAS Diagnostic Start/End Response
+ * use to describe MPI SAS Diagnostic Start/End Response (64 bytes)
+ *
+ */
+struct sas_diag_start_end_resp {
+        __le32          tag;
+        __le32          status;
+        u32             reserved[13];
+} __attribute__((packed, aligned(4)));
+
+
+/**
+ * brief the data structure of SAS Diagnostic Execute Response
+ * use to describe MPI SAS Diagnostic Execute Response (64 bytes)
+ *
+ */
+struct sas_diag_execute_resp {
+        __le32          tag;
+        __le32          cmdtype_cmddesc_phyid;
+        __le32          Status;
+        __le32          ReportData;
+        u32             reserved[11];
+} __attribute__((packed, aligned(4)));
+
+
+/**
+ * brief the data structure of Set Device State Response
+ * use to describe MPI Set Device State Response (64 bytes)
+ *
+ */
+struct set_dev_state_resp {
+        __le32          tag;
+        __le32          status;
+        __le32          device_id;
+        __le32          pds_nds;
+        u32             reserved[11];
+} __attribute__((packed, aligned(4)));
+
+
+#define NDS_BITS 0x0F
+#define PDS_BITS 0xF0
+
+/*
+ * HW Events type
+ */
+
+#define HW_EVENT_RESET_START                    0x01
+#define HW_EVENT_CHIP_RESET_COMPLETE            0x02
+#define HW_EVENT_PHY_STOP_STATUS                0x03
+#define HW_EVENT_SAS_PHY_UP                     0x04
+#define HW_EVENT_SATA_PHY_UP                    0x05
+#define HW_EVENT_SATA_SPINUP_HOLD               0x06
+#define HW_EVENT_PHY_DOWN                       0x07
+#define HW_EVENT_PORT_INVALID                   0x08
+#define HW_EVENT_BROADCAST_CHANGE               0x09
+#define HW_EVENT_PHY_ERROR                      0x0A
+#define HW_EVENT_BROADCAST_SES                  0x0B
+#define HW_EVENT_INBOUND_CRC_ERROR              0x0C
+#define HW_EVENT_HARD_RESET_RECEIVED            0x0D
+#define HW_EVENT_MALFUNCTION                    0x0E
+#define HW_EVENT_ID_FRAME_TIMEOUT               0x0F
+#define HW_EVENT_BROADCAST_EXP                  0x10
+#define HW_EVENT_PHY_START_STATUS               0x11
+#define HW_EVENT_LINK_ERR_INVALID_DWORD         0x12
+#define HW_EVENT_LINK_ERR_DISPARITY_ERROR       0x13
+#define HW_EVENT_LINK_ERR_CODE_VIOLATION        0x14
+#define HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH   0x15
+#define HW_EVENT_LINK_ERR_PHY_RESET_FAILED      0x16
+#define HW_EVENT_PORT_RECOVERY_TIMER_TMO        0x17
+#define HW_EVENT_PORT_RECOVER                   0x18
+#define HW_EVENT_PORT_RESET_TIMER_TMO           0x19
+#define HW_EVENT_PORT_RESET_COMPLETE            0x20
+#define EVENT_BROADCAST_ASYNCH_EVENT            0x21
+
+/* port state */
+#define PORT_NOT_ESTABLISHED                    0x00
+#define PORT_VALID                              0x01
+#define PORT_LOSTCOMM                           0x02
+#define PORT_IN_RESET                           0x04
+#define PORT_INVALID                            0x08
+
+/*
+ * SSP/SMP/SATA IO Completion Status values
+ */
+
+#define IO_SUCCESS                              0x00
+#define IO_ABORTED                              0x01
+#define IO_OVERFLOW                             0x02
+#define IO_UNDERFLOW                            0x03
+#define IO_FAILED                               0x04
+#define IO_ABORT_RESET                          0x05
+#define IO_NOT_VALID                            0x06
+#define IO_NO_DEVICE                            0x07
+#define IO_ILLEGAL_PARAMETER                    0x08
+#define IO_LINK_FAILURE                         0x09
+#define IO_PROG_ERROR                           0x0A
+#define IO_EDC_IN_ERROR                         0x0B
+#define IO_EDC_OUT_ERROR                        0x0C
+#define IO_ERROR_HW_TIMEOUT                     0x0D
+#define IO_XFER_ERROR_BREAK                     0x0E
+#define IO_XFER_ERROR_PHY_NOT_READY             0x0F
+#define IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED        0x10
+#define IO_OPEN_CNX_ERROR_ZONE_VIOLATION                0x11
+#define IO_OPEN_CNX_ERROR_BREAK                         0x12
+#define IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS                 0x13
+#define IO_OPEN_CNX_ERROR_BAD_DESTINATION               0x14
+#define IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED 0x15
+#define IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY            0x16
+#define IO_OPEN_CNX_ERROR_WRONG_DESTINATION             0x17
+#define IO_OPEN_CNX_ERROR_UNKNOWN_ERROR                 0x18
+#define IO_XFER_ERROR_NAK_RECEIVED                      0x19
+#define IO_XFER_ERROR_ACK_NAK_TIMEOUT                   0x1A
+#define IO_XFER_ERROR_PEER_ABORTED                      0x1B
+#define IO_XFER_ERROR_RX_FRAME                          0x1C
+#define IO_XFER_ERROR_DMA                               0x1D
+#define IO_XFER_ERROR_CREDIT_TIMEOUT                    0x1E
+#define IO_XFER_ERROR_SATA_LINK_TIMEOUT                 0x1F
+#define IO_XFER_ERROR_SATA                              0x20
+#define IO_XFER_ERROR_ABORTED_DUE_TO_SRST               0x22
+#define IO_XFER_ERROR_REJECTED_NCQ_MODE                 0x21
+#define IO_XFER_ERROR_ABORTED_NCQ_MODE                  0x23
+#define IO_XFER_OPEN_RETRY_TIMEOUT                      0x24
+#define IO_XFER_SMP_RESP_CONNECTION_ERROR               0x25
+#define IO_XFER_ERROR_UNEXPECTED_PHASE                  0x26
+#define IO_XFER_ERROR_XFER_RDY_OVERRUN                  0x27
+#define IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED             0x28
+
+#define IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT         0x30
+#define IO_XFER_ERROR_CMD_ISSUE_BREAK_BEFORE_ACK_NAK    0x31
+#define IO_XFER_ERROR_CMD_ISSUE_PHY_DOWN_BEFORE_ACK_NAK 0x32
+
+#define IO_XFER_ERROR_OFFSET_MISMATCH                   0x34
+#define IO_XFER_ERROR_XFER_ZERO_DATA_LEN                0x35
+#define IO_XFER_CMD_FRAME_ISSUED                        0x36
+#define IO_ERROR_INTERNAL_SMP_RESOURCE                  0x37
+#define IO_PORT_IN_RESET                                0x38
+#define IO_DS_NON_OPERATIONAL                           0x39
+#define IO_DS_IN_RECOVERY                               0x3A
+#define IO_TM_TAG_NOT_FOUND                             0x3B
+#define IO_XFER_PIO_SETUP_ERROR                         0x3C
+#define IO_SSP_EXT_IU_ZERO_LEN_ERROR                    0x3D
+#define IO_DS_IN_ERROR                                  0x3E
+#define IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY              0x3F
+#define IO_ABORT_IN_PROGRESS                            0x40
+#define IO_ABORT_DELAYED                                0x41
+#define IO_INVALID_LENGTH                               0x42
+
+/* WARNING: This error code must always be the last number.
+ * If you add error code, modify this code also
+ * It is used as an index
+ */
+#define IO_ERROR_UNKNOWN_GENERIC                        0x43
+
+/* MSGU CONFIGURATION  TABLE*/
+
+#define SPC_MSGU_CFG_TABLE_UPDATE               0x01/* Inbound doorbell bit0 */
+#define SPC_MSGU_CFG_TABLE_RESET                0x02/* Inbound doorbell bit1 */
+#define SPC_MSGU_CFG_TABLE_FREEZE               0x04/* Inbound doorbell bit2 */
+#define SPC_MSGU_CFG_TABLE_UNFREEZE             0x08/* Inbound doorbell bit4 */
+#define MSGU_IBDB_SET                           0x04
+#define MSGU_HOST_INT_STATUS                    0x08
+#define MSGU_HOST_INT_MASK                      0x0C
+#define MSGU_IOPIB_INT_STATUS                   0x18
+#define MSGU_IOPIB_INT_MASK                     0x1C
+#define MSGU_IBDB_CLEAR                         0x20/* RevB - Host not use */
+#define MSGU_MSGU_CONTROL                       0x24
+#define MSGU_ODR                                0x3C/* RevB */
+#define MSGU_ODCR                               0x40/* RevB */
+#define MSGU_SCRATCH_PAD_0                      0x44
+#define MSGU_SCRATCH_PAD_1                      0x48
+#define MSGU_SCRATCH_PAD_2                      0x4C
+#define MSGU_SCRATCH_PAD_3                      0x50
+#define MSGU_HOST_SCRATCH_PAD_0                 0x54
+#define MSGU_HOST_SCRATCH_PAD_1                 0x58
+#define MSGU_HOST_SCRATCH_PAD_2                 0x5C
+#define MSGU_HOST_SCRATCH_PAD_3                 0x60
+#define MSGU_HOST_SCRATCH_PAD_4                 0x64
+#define MSGU_HOST_SCRATCH_PAD_5                 0x68
+#define MSGU_HOST_SCRATCH_PAD_6                 0x6C
+#define MSGU_HOST_SCRATCH_PAD_7                 0x70
+#define MSGU_ODMR                               0x74/* RevB */
+
+/* bit definition for ODMR register */
+#define ODMR_MASK_ALL                           0xFFFFFFFF/* mask all
+                                        interrupt vector */
+#define ODMR_CLEAR_ALL                          0/* clear all
+                                        interrupt vector */
+/* bit definition for ODCR register */
+#define ODCR_CLEAR_ALL          0xFFFFFFFF   /* mask all
+                                        interrupt vector*/
+/* MSIX Interupts */
+#define MSIX_TABLE_OFFSET               0x2000
+#define MSIX_TABLE_ELEMENT_SIZE         0x10
+#define MSIX_INTERRUPT_CONTROL_OFFSET   0xC
+#define MSIX_TABLE_BASE   (MSIX_TABLE_OFFSET + MSIX_INTERRUPT_CONTROL_OFFSET)
+#define MSIX_INTERRUPT_DISABLE          0x1
+#define MSIX_INTERRUPT_ENABLE           0x0
+
+
+/* state definition for Scratch Pad1 register */
+#define SCRATCH_PAD1_POR                0x00  /* power on reset state */
+#define SCRATCH_PAD1_SFR                0x01  /* soft reset state */
+#define SCRATCH_PAD1_ERR                0x02  /* error state */
+#define SCRATCH_PAD1_RDY                0x03  /* ready state */
+#define SCRATCH_PAD1_RST                0x04  /* soft reset toggle flag */
+#define SCRATCH_PAD1_AAP1RDY_RST        0x08  /* AAP1 ready for soft reset */
+#define SCRATCH_PAD1_STATE_MASK         0xFFFFFFF0   /* ScratchPad1
+ Mask, bit1-0 State, bit2 Soft Reset, bit3 FW RDY for Soft Reset */
+#define SCRATCH_PAD1_RESERVED           0x000003F8   /* Scratch Pad1
+ Reserved bit 3 to 9 */
+
+ /* state definition for Scratch Pad2 register */
+#define SCRATCH_PAD2_POR                0x00  /* power on state */
+#define SCRATCH_PAD2_SFR                0x01  /* soft reset state */
+#define SCRATCH_PAD2_ERR                0x02  /* error state */
+#define SCRATCH_PAD2_RDY                0x03  /* ready state */
+#define SCRATCH_PAD2_FWRDY_RST          0x04  /* FW ready for soft reset flag*/
+#define SCRATCH_PAD2_IOPRDY_RST         0x08  /* IOP ready for soft reset */
+#define SCRATCH_PAD2_STATE_MASK         0xFFFFFFF4 /* ScratchPad 2
+ Mask, bit1-0 State */
+#define SCRATCH_PAD2_RESERVED           0x000003FC   /* Scratch Pad1
+ Reserved bit 2 to 9 */
+
+#define SCRATCH_PAD_ERROR_MASK          0xFFFFFC00   /* Error mask bits */
+#define SCRATCH_PAD_STATE_MASK          0x00000003   /* State Mask bits */
+
+/* main configuration offset - byte offset */
+#define MAIN_SIGNATURE_OFFSET           0x00/* DWORD 0x00 */
+#define MAIN_INTERFACE_REVISION         0x04/* DWORD 0x01 */
+#define MAIN_FW_REVISION                0x08/* DWORD 0x02 */
+#define MAIN_MAX_OUTSTANDING_IO_OFFSET  0x0C/* DWORD 0x03 */
+#define MAIN_MAX_SGL_OFFSET             0x10/* DWORD 0x04 */
+#define MAIN_CNTRL_CAP_OFFSET           0x14/* DWORD 0x05 */
+#define MAIN_GST_OFFSET                 0x18/* DWORD 0x06 */
+#define MAIN_IBQ_OFFSET                 0x1C/* DWORD 0x07 */
+#define MAIN_OBQ_OFFSET                 0x20/* DWORD 0x08 */
+#define MAIN_IQNPPD_HPPD_OFFSET         0x24/* DWORD 0x09 */
+#define MAIN_OB_HW_EVENT_PID03_OFFSET   0x28/* DWORD 0x0A */
+#define MAIN_OB_HW_EVENT_PID47_OFFSET   0x2C/* DWORD 0x0B */
+#define MAIN_OB_NCQ_EVENT_PID03_OFFSET  0x30/* DWORD 0x0C */
+#define MAIN_OB_NCQ_EVENT_PID47_OFFSET  0x34/* DWORD 0x0D */
+#define MAIN_TITNX_EVENT_PID03_OFFSET   0x38/* DWORD 0x0E */
+#define MAIN_TITNX_EVENT_PID47_OFFSET   0x3C/* DWORD 0x0F */
+#define MAIN_OB_SSP_EVENT_PID03_OFFSET  0x40/* DWORD 0x10 */
+#define MAIN_OB_SSP_EVENT_PID47_OFFSET  0x44/* DWORD 0x11 */
+#define MAIN_OB_SMP_EVENT_PID03_OFFSET  0x48/* DWORD 0x12 */
+#define MAIN_OB_SMP_EVENT_PID47_OFFSET  0x4C/* DWORD 0x13 */
+#define MAIN_EVENT_LOG_ADDR_HI          0x50/* DWORD 0x14 */
+#define MAIN_EVENT_LOG_ADDR_LO          0x54/* DWORD 0x15 */
+#define MAIN_EVENT_LOG_BUFF_SIZE        0x58/* DWORD 0x16 */
+#define MAIN_EVENT_LOG_OPTION           0x5C/* DWORD 0x17 */
+#define MAIN_IOP_EVENT_LOG_ADDR_HI      0x60/* DWORD 0x18 */
+#define MAIN_IOP_EVENT_LOG_ADDR_LO      0x64/* DWORD 0x19 */
+#define MAIN_IOP_EVENT_LOG_BUFF_SIZE    0x68/* DWORD 0x1A */
+#define MAIN_IOP_EVENT_LOG_OPTION       0x6C/* DWORD 0x1B */
+#define MAIN_FATAL_ERROR_INTERRUPT      0x70/* DWORD 0x1C */
+#define MAIN_FATAL_ERROR_RDUMP0_OFFSET  0x74/* DWORD 0x1D */
+#define MAIN_FATAL_ERROR_RDUMP0_LENGTH  0x78/* DWORD 0x1E */
+#define MAIN_FATAL_ERROR_RDUMP1_OFFSET  0x7C/* DWORD 0x1F */
+#define MAIN_FATAL_ERROR_RDUMP1_LENGTH  0x80/* DWORD 0x20 */
+#define MAIN_HDA_FLAGS_OFFSET           0x84/* DWORD 0x21 */
+#define MAIN_ANALOG_SETUP_OFFSET        0x88/* DWORD 0x22 */
+
+/* Gereral Status Table offset - byte offset */
+#define GST_GSTLEN_MPIS_OFFSET          0x00
+#define GST_IQ_FREEZE_STATE0_OFFSET     0x04
+#define GST_IQ_FREEZE_STATE1_OFFSET     0x08
+#define GST_MSGUTCNT_OFFSET             0x0C
+#define GST_IOPTCNT_OFFSET              0x10
+#define GST_PHYSTATE_OFFSET             0x18
+#define GST_PHYSTATE0_OFFSET            0x18
+#define GST_PHYSTATE1_OFFSET            0x1C
+#define GST_PHYSTATE2_OFFSET            0x20
+#define GST_PHYSTATE3_OFFSET            0x24
+#define GST_PHYSTATE4_OFFSET            0x28
+#define GST_PHYSTATE5_OFFSET            0x2C
+#define GST_PHYSTATE6_OFFSET            0x30
+#define GST_PHYSTATE7_OFFSET            0x34
+#define GST_RERRINFO_OFFSET             0x44
+
+/* General Status Table - MPI state */
+#define GST_MPI_STATE_UNINIT            0x00
+#define GST_MPI_STATE_INIT              0x01
+#define GST_MPI_STATE_TERMINATION       0x02
+#define GST_MPI_STATE_ERROR             0x03
+#define GST_MPI_STATE_MASK              0x07
+
+#define MBIC_NMI_ENABLE_VPE0_IOP        0x000418
+#define MBIC_NMI_ENABLE_VPE0_AAP1       0x000418
+/* PCIE registers - BAR2(0x18), BAR1(win) 0x010000 */
+#define PCIE_EVENT_INTERRUPT_ENABLE     0x003040
+#define PCIE_EVENT_INTERRUPT            0x003044
+#define PCIE_ERROR_INTERRUPT_ENABLE     0x003048
+#define PCIE_ERROR_INTERRUPT            0x00304C
+/* signature defintion for host scratch pad0 register */
+#define SPC_SOFT_RESET_SIGNATURE        0x252acbcd
+/* Signature for Soft Reset */
+
+/* SPC Reset register - BAR4(0x20), BAR2(win) (need dynamic mapping) */
+#define SPC_REG_RESET                   0x000000/* reset register */
+
+/* bit difination for SPC_RESET register */
+#define   SPC_REG_RESET_OSSP            0x00000001
+#define   SPC_REG_RESET_RAAE            0x00000002
+#define   SPC_REG_RESET_PCS_SPBC        0x00000004
+#define   SPC_REG_RESET_PCS_IOP_SS      0x00000008
+#define   SPC_REG_RESET_PCS_AAP1_SS     0x00000010
+#define   SPC_REG_RESET_PCS_AAP2_SS     0x00000020
+#define   SPC_REG_RESET_PCS_LM          0x00000040
+#define   SPC_REG_RESET_PCS             0x00000080
+#define   SPC_REG_RESET_GSM             0x00000100
+#define   SPC_REG_RESET_DDR2            0x00010000
+#define   SPC_REG_RESET_BDMA_CORE       0x00020000
+#define   SPC_REG_RESET_BDMA_SXCBI      0x00040000
+#define   SPC_REG_RESET_PCIE_AL_SXCBI   0x00080000
+#define   SPC_REG_RESET_PCIE_PWR        0x00100000
+#define   SPC_REG_RESET_PCIE_SFT        0x00200000
+#define   SPC_REG_RESET_PCS_SXCBI       0x00400000
+#define   SPC_REG_RESET_LMS_SXCBI       0x00800000
+#define   SPC_REG_RESET_PMIC_SXCBI      0x01000000
+#define   SPC_REG_RESET_PMIC_CORE       0x02000000
+#define   SPC_REG_RESET_PCIE_PC_SXCBI   0x04000000
+#define   SPC_REG_RESET_DEVICE          0x80000000
+
+/* registers for BAR Shifting - BAR2(0x18), BAR1(win) */
+#define SPC_IBW_AXI_TRANSLATION_LOW     0x003258
+
+#define MBIC_AAP1_ADDR_BASE             0x060000
+#define MBIC_IOP_ADDR_BASE              0x070000
+#define GSM_ADDR_BASE                   0x0700000
+/* Dynamic map through Bar4 - 0x00700000 */
+#define GSM_CONFIG_RESET                0x00000000
+#define RAM_ECC_DB_ERR                  0x00000018
+#define GSM_READ_ADDR_PARITY_INDIC      0x00000058
+#define GSM_WRITE_ADDR_PARITY_INDIC     0x00000060
+#define GSM_WRITE_DATA_PARITY_INDIC     0x00000068
+#define GSM_READ_ADDR_PARITY_CHECK      0x00000038
+#define GSM_WRITE_ADDR_PARITY_CHECK     0x00000040
+#define GSM_WRITE_DATA_PARITY_CHECK     0x00000048
+
+#define RB6_ACCESS_REG                  0x6A0000
+#define HDAC_EXEC_CMD                   0x0002
+#define HDA_C_PA                        0xcb
+#define HDA_SEQ_ID_BITS                 0x00ff0000
+#define HDA_GSM_OFFSET_BITS             0x00FFFFFF
+#define MBIC_AAP1_ADDR_BASE             0x060000
+#define MBIC_IOP_ADDR_BASE              0x070000
+#define GSM_ADDR_BASE                   0x0700000
+#define SPC_TOP_LEVEL_ADDR_BASE         0x000000
+#define GSM_CONFIG_RESET_VALUE          0x00003b00
+#define GPIO_ADDR_BASE                  0x00090000
+#define GPIO_GPIO_0_0UTPUT_CTL_OFFSET   0x0000010c
+
+/* RB6 offset */
+#define SPC_RB6_OFFSET                  0x80C0
+/* Magic number of  soft reset for RB6 */
+#define RB6_MAGIC_NUMBER_RST            0x1234
+
+/* Device Register status */
+#define DEVREG_SUCCESS                                  0x00
+#define DEVREG_FAILURE_OUT_OF_RESOURCE                  0x01
+#define DEVREG_FAILURE_DEVICE_ALREADY_REGISTERED        0x02
+#define DEVREG_FAILURE_INVALID_PHY_ID                   0x03
+#define DEVREG_FAILURE_PHY_ID_ALREADY_REGISTERED        0x04
+#define DEVREG_FAILURE_PORT_ID_OUT_OF_RANGE             0x05
+#define DEVREG_FAILURE_PORT_NOT_VALID_STATE             0x06
+#define DEVREG_FAILURE_DEVICE_TYPE_NOT_VALID            0x07
+
+#endif
+
diff --git a/drivers/scsi/pm8001/pm8001_init.c b/drivers/scsi/pm8001/pm8001_init.c
new file mode 100644
index 000000000000..f8c86b28f03f
--- /dev/null
+++ b/drivers/scsi/pm8001/pm8001_init.c
@@ -0,0 +1,901 @@
+/*
+ * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
+ *
+ * Copyright (c) 2008-2009 USI Co., Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ */
+
+#include <linux/slab.h>
+#include "pm8001_sas.h"
+#include "pm8001_chips.h"
+
+static struct scsi_transport_template *pm8001_stt;
+
+static const struct pm8001_chip_info pm8001_chips[] = {
+        [chip_8001] = {  8, &pm8001_8001_dispatch,},
+};
+static int pm8001_id;
+
+LIST_HEAD(hba_list);
+
+/**
+ * The main structure which LLDD must register for scsi core.
+ */
+static struct scsi_host_template pm8001_sht = {
+        .module                 = THIS_MODULE,
+        .name                   = DRV_NAME,
+        .queuecommand           = sas_queuecommand,
+        .target_alloc           = sas_target_alloc,
+        .slave_configure        = pm8001_slave_configure,
+        .slave_destroy          = sas_slave_destroy,
+        .scan_finished          = pm8001_scan_finished,
+        .scan_start             = pm8001_scan_start,
+        .change_queue_depth     = sas_change_queue_depth,
+        .change_queue_type      = sas_change_queue_type,
+        .bios_param             = sas_bios_param,
+        .can_queue              = 1,
+        .cmd_per_lun            = 1,
+        .this_id                = -1,
+        .sg_tablesize           = SG_ALL,
+        .max_sectors            = SCSI_DEFAULT_MAX_SECTORS,
+        .use_clustering         = ENABLE_CLUSTERING,
+        .eh_device_reset_handler = sas_eh_device_reset_handler,
+        .eh_bus_reset_handler   = sas_eh_bus_reset_handler,
+        .slave_alloc            = pm8001_slave_alloc,
+        .target_destroy         = sas_target_destroy,
+        .ioctl                  = sas_ioctl,
+        .shost_attrs            = pm8001_host_attrs,
+};
+
+/**
+ * Sas layer call this function to execute specific task.
+ */
+static struct sas_domain_function_template pm8001_transport_ops = {
+        .lldd_dev_found         = pm8001_dev_found,
+        .lldd_dev_gone          = pm8001_dev_gone,
+
+        .lldd_execute_task      = pm8001_queue_command,
+        .lldd_control_phy       = pm8001_phy_control,
+
+        .lldd_abort_task        = pm8001_abort_task,
+        .lldd_abort_task_set    = pm8001_abort_task_set,
+        .lldd_clear_aca         = pm8001_clear_aca,
+        .lldd_clear_task_set    = pm8001_clear_task_set,
+        .lldd_I_T_nexus_reset   = pm8001_I_T_nexus_reset,
+        .lldd_lu_reset          = pm8001_lu_reset,
+        .lldd_query_task        = pm8001_query_task,
+};
+
+/**
+ *pm8001_phy_init - initiate our adapter phys
+ *@pm8001_ha: our hba structure.
+ *@phy_id: phy id.
+ */
+static void __devinit pm8001_phy_init(struct pm8001_hba_info *pm8001_ha,
+        int phy_id)
+{
+        struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+        struct asd_sas_phy *sas_phy = &phy->sas_phy;
+        phy->phy_state = 0;
+        phy->pm8001_ha = pm8001_ha;
+        sas_phy->enabled = (phy_id < pm8001_ha->chip->n_phy) ? 1 : 0;
+        sas_phy->class = SAS;
+        sas_phy->iproto = SAS_PROTOCOL_ALL;
+        sas_phy->tproto = 0;
+        sas_phy->type = PHY_TYPE_PHYSICAL;
+        sas_phy->role = PHY_ROLE_INITIATOR;
+        sas_phy->oob_mode = OOB_NOT_CONNECTED;
+        sas_phy->linkrate = SAS_LINK_RATE_UNKNOWN;
+        sas_phy->id = phy_id;
+        sas_phy->sas_addr = &pm8001_ha->sas_addr[0];
+        sas_phy->frame_rcvd = &phy->frame_rcvd[0];
+        sas_phy->ha = (struct sas_ha_struct *)pm8001_ha->shost->hostdata;
+        sas_phy->lldd_phy = phy;
+}
+
+/**
+ *pm8001_free - free hba
+ *@pm8001_ha:   our hba structure.
+ *
+ */
+static void pm8001_free(struct pm8001_hba_info *pm8001_ha)
+{
+        int i;
+        struct pm8001_wq *wq;
+
+        if (!pm8001_ha)
+                return;
+
+        for (i = 0; i < USI_MAX_MEMCNT; i++) {
+                if (pm8001_ha->memoryMap.region[i].virt_ptr != NULL) {
+                        pci_free_consistent(pm8001_ha->pdev,
+                                pm8001_ha->memoryMap.region[i].element_size,
+                                pm8001_ha->memoryMap.region[i].virt_ptr,
+                                pm8001_ha->memoryMap.region[i].phys_addr);
+                        }
+        }
+        PM8001_CHIP_DISP->chip_iounmap(pm8001_ha);
+        if (pm8001_ha->shost)
+                scsi_host_put(pm8001_ha->shost);
+        list_for_each_entry(wq, &pm8001_ha->wq_list, entry)
+                cancel_delayed_work(&wq->work_q);
+        kfree(pm8001_ha->tags);
+        kfree(pm8001_ha);
+}
+
+#ifdef PM8001_USE_TASKLET
+static void pm8001_tasklet(unsigned long opaque)
+{
+        struct pm8001_hba_info *pm8001_ha;
+        pm8001_ha = (struct pm8001_hba_info *)opaque;;
+        if (unlikely(!pm8001_ha))
+                BUG_ON(1);
+        PM8001_CHIP_DISP->isr(pm8001_ha);
+}
+#endif
+
+
+ /**
+  * pm8001_interrupt - when HBA originate a interrupt,we should invoke this
+  * dispatcher to handle each case.
+  * @irq: irq number.
+  * @opaque: the passed general host adapter struct
+  */
+static irqreturn_t pm8001_interrupt(int irq, void *opaque)
+{
+        struct pm8001_hba_info *pm8001_ha;
+        irqreturn_t ret = IRQ_HANDLED;
+        struct sas_ha_struct *sha = opaque;
+        pm8001_ha = sha->lldd_ha;
+        if (unlikely(!pm8001_ha))
+                return IRQ_NONE;
+        if (!PM8001_CHIP_DISP->is_our_interupt(pm8001_ha))
+                return IRQ_NONE;
+#ifdef PM8001_USE_TASKLET
+        tasklet_schedule(&pm8001_ha->tasklet);
+#else
+        ret = PM8001_CHIP_DISP->isr(pm8001_ha);
+#endif
+        return ret;
+}
+
+/**
+ * pm8001_alloc - initiate our hba structure and 6 DMAs area.
+ * @pm8001_ha:our hba structure.
+ *
+ */
+static int __devinit pm8001_alloc(struct pm8001_hba_info *pm8001_ha)
+{
+        int i;
+        spin_lock_init(&pm8001_ha->lock);
+        for (i = 0; i < pm8001_ha->chip->n_phy; i++) {
+                pm8001_phy_init(pm8001_ha, i);
+                pm8001_ha->port[i].wide_port_phymap = 0;
+                pm8001_ha->port[i].port_attached = 0;
+                pm8001_ha->port[i].port_state = 0;
+                INIT_LIST_HEAD(&pm8001_ha->port[i].list);
+        }
+
+        pm8001_ha->tags = kzalloc(PM8001_MAX_CCB, GFP_KERNEL);
+        if (!pm8001_ha->tags)
+                goto err_out;
+        /* MPI Memory region 1 for AAP Event Log for fw */
+        pm8001_ha->memoryMap.region[AAP1].num_elements = 1;
+        pm8001_ha->memoryMap.region[AAP1].element_size = PM8001_EVENT_LOG_SIZE;
+        pm8001_ha->memoryMap.region[AAP1].total_len = PM8001_EVENT_LOG_SIZE;
+        pm8001_ha->memoryMap.region[AAP1].alignment = 32;
+
+        /* MPI Memory region 2 for IOP Event Log for fw */
+        pm8001_ha->memoryMap.region[IOP].num_elements = 1;
+        pm8001_ha->memoryMap.region[IOP].element_size = PM8001_EVENT_LOG_SIZE;
+        pm8001_ha->memoryMap.region[IOP].total_len = PM8001_EVENT_LOG_SIZE;
+        pm8001_ha->memoryMap.region[IOP].alignment = 32;
+
+        /* MPI Memory region 3 for consumer Index of inbound queues */
+        pm8001_ha->memoryMap.region[CI].num_elements = 1;
+        pm8001_ha->memoryMap.region[CI].element_size = 4;
+        pm8001_ha->memoryMap.region[CI].total_len = 4;
+        pm8001_ha->memoryMap.region[CI].alignment = 4;
+
+        /* MPI Memory region 4 for producer Index of outbound queues */
+        pm8001_ha->memoryMap.region[PI].num_elements = 1;
+        pm8001_ha->memoryMap.region[PI].element_size = 4;
+        pm8001_ha->memoryMap.region[PI].total_len = 4;
+        pm8001_ha->memoryMap.region[PI].alignment = 4;
+
+        /* MPI Memory region 5 inbound queues */
+        pm8001_ha->memoryMap.region[IB].num_elements = 256;
+        pm8001_ha->memoryMap.region[IB].element_size = 64;
+        pm8001_ha->memoryMap.region[IB].total_len = 256 * 64;
+        pm8001_ha->memoryMap.region[IB].alignment = 64;
+
+        /* MPI Memory region 6 inbound queues */
+        pm8001_ha->memoryMap.region[OB].num_elements = 256;
+        pm8001_ha->memoryMap.region[OB].element_size = 64;
+        pm8001_ha->memoryMap.region[OB].total_len = 256 * 64;
+        pm8001_ha->memoryMap.region[OB].alignment = 64;
+
+        /* Memory region write DMA*/
+        pm8001_ha->memoryMap.region[NVMD].num_elements = 1;
+        pm8001_ha->memoryMap.region[NVMD].element_size = 4096;
+        pm8001_ha->memoryMap.region[NVMD].total_len = 4096;
+        /* Memory region for devices*/
+        pm8001_ha->memoryMap.region[DEV_MEM].num_elements = 1;
+        pm8001_ha->memoryMap.region[DEV_MEM].element_size = PM8001_MAX_DEVICES *
+                sizeof(struct pm8001_device);
+        pm8001_ha->memoryMap.region[DEV_MEM].total_len = PM8001_MAX_DEVICES *
+                sizeof(struct pm8001_device);
+
+        /* Memory region for ccb_info*/
+        pm8001_ha->memoryMap.region[CCB_MEM].num_elements = 1;
+        pm8001_ha->memoryMap.region[CCB_MEM].element_size = PM8001_MAX_CCB *
+                sizeof(struct pm8001_ccb_info);
+        pm8001_ha->memoryMap.region[CCB_MEM].total_len = PM8001_MAX_CCB *
+                sizeof(struct pm8001_ccb_info);
+
+        for (i = 0; i < USI_MAX_MEMCNT; i++) {
+                if (pm8001_mem_alloc(pm8001_ha->pdev,
+                        &pm8001_ha->memoryMap.region[i].virt_ptr,
+                        &pm8001_ha->memoryMap.region[i].phys_addr,
+                        &pm8001_ha->memoryMap.region[i].phys_addr_hi,
+                        &pm8001_ha->memoryMap.region[i].phys_addr_lo,
+                        pm8001_ha->memoryMap.region[i].total_len,
+                        pm8001_ha->memoryMap.region[i].alignment) != 0) {
+                                PM8001_FAIL_DBG(pm8001_ha,
+                                        pm8001_printk("Mem%d alloc failed\n",
+                                        i));
+                                goto err_out;
+                }
+        }
+
+        pm8001_ha->devices = pm8001_ha->memoryMap.region[DEV_MEM].virt_ptr;
+        for (i = 0; i < PM8001_MAX_DEVICES; i++) {
+                pm8001_ha->devices[i].dev_type = NO_DEVICE;
+                pm8001_ha->devices[i].id = i;
+                pm8001_ha->devices[i].device_id = PM8001_MAX_DEVICES;
+                pm8001_ha->devices[i].running_req = 0;
+        }
+        pm8001_ha->ccb_info = pm8001_ha->memoryMap.region[CCB_MEM].virt_ptr;
+        for (i = 0; i < PM8001_MAX_CCB; i++) {
+                pm8001_ha->ccb_info[i].ccb_dma_handle =
+                        pm8001_ha->memoryMap.region[CCB_MEM].phys_addr +
+                        i * sizeof(struct pm8001_ccb_info);
+                pm8001_ha->ccb_info[i].task = NULL;
+                pm8001_ha->ccb_info[i].ccb_tag = 0xffffffff;
+                pm8001_ha->ccb_info[i].device = NULL;
+                ++pm8001_ha->tags_num;
+        }
+        pm8001_ha->flags = PM8001F_INIT_TIME;
+        /* Initialize tags */
+        pm8001_tag_init(pm8001_ha);
+        return 0;
+err_out:
+        return 1;
+}
+
+/**
+ * pm8001_ioremap - remap the pci high physical address to kernal virtual
+ * address so that we can access them.
+ * @pm8001_ha:our hba structure.
+ */
+static int pm8001_ioremap(struct pm8001_hba_info *pm8001_ha)
+{
+        u32 bar;
+        u32 logicalBar = 0;
+        struct pci_dev *pdev;
+
+        pdev = pm8001_ha->pdev;
+        /* map pci mem (PMC pci base 0-3)*/
+        for (bar = 0; bar < 6; bar++) {
+                /*
+                ** logical BARs for SPC:
+                ** bar 0 and 1 - logical BAR0
+                ** bar 2 and 3 - logical BAR1
+                ** bar4 - logical BAR2
+                ** bar5 - logical BAR3
+                ** Skip the appropriate assignments:
+                */
+                if ((bar == 1) || (bar == 3))
+                        continue;
+                if (pci_resource_flags(pdev, bar) & IORESOURCE_MEM) {
+                        pm8001_ha->io_mem[logicalBar].membase =
+                                pci_resource_start(pdev, bar);
+                        pm8001_ha->io_mem[logicalBar].membase &=
+                                (u32)PCI_BASE_ADDRESS_MEM_MASK;
+                        pm8001_ha->io_mem[logicalBar].memsize =
+                                pci_resource_len(pdev, bar);
+                        pm8001_ha->io_mem[logicalBar].memvirtaddr =
+                                ioremap(pm8001_ha->io_mem[logicalBar].membase,
+                                pm8001_ha->io_mem[logicalBar].memsize);
+                        PM8001_INIT_DBG(pm8001_ha,
+                                pm8001_printk("PCI: bar %d, logicalBar %d "
+                                "virt_addr=%lx,len=%d\n", bar, logicalBar,
+                                (unsigned long)
+                                pm8001_ha->io_mem[logicalBar].memvirtaddr,
+                                pm8001_ha->io_mem[logicalBar].memsize));
+                } else {
+                        pm8001_ha->io_mem[logicalBar].membase   = 0;
+                        pm8001_ha->io_mem[logicalBar].memsize   = 0;
+                        pm8001_ha->io_mem[logicalBar].memvirtaddr = 0;
+                }
+                logicalBar++;
+        }
+        return 0;
+}
+
+/**
+ * pm8001_pci_alloc - initialize our ha card structure
+ * @pdev: pci device.
+ * @ent: ent
+ * @shost: scsi host struct which has been initialized before.
+ */
+static struct pm8001_hba_info *__devinit
+pm8001_pci_alloc(struct pci_dev *pdev, u32 chip_id, struct Scsi_Host *shost)
+{
+        struct pm8001_hba_info *pm8001_ha;
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+
+
+        pm8001_ha = sha->lldd_ha;
+        if (!pm8001_ha)
+                return NULL;
+
+        pm8001_ha->pdev = pdev;
+        pm8001_ha->dev = &pdev->dev;
+        pm8001_ha->chip_id = chip_id;
+        pm8001_ha->chip = &pm8001_chips[pm8001_ha->chip_id];
+        pm8001_ha->irq = pdev->irq;
+        pm8001_ha->sas = sha;
+        pm8001_ha->shost = shost;
+        pm8001_ha->id = pm8001_id++;
+        INIT_LIST_HEAD(&pm8001_ha->wq_list);
+        pm8001_ha->logging_level = 0x01;
+        sprintf(pm8001_ha->name, "%s%d", DRV_NAME, pm8001_ha->id);
+#ifdef PM8001_USE_TASKLET
+        tasklet_init(&pm8001_ha->tasklet, pm8001_tasklet,
+                (unsigned long)pm8001_ha);
+#endif
+        pm8001_ioremap(pm8001_ha);
+        if (!pm8001_alloc(pm8001_ha))
+                return pm8001_ha;
+        pm8001_free(pm8001_ha);
+        return NULL;
+}
+
+/**
+ * pci_go_44 - pm8001 specified, its DMA is 44 bit rather than 64 bit
+ * @pdev: pci device.
+ */
+static int pci_go_44(struct pci_dev *pdev)
+{
+        int rc;
+
+        if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(44))) {
+                rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(44));
+                if (rc) {
+                        rc = pci_set_consistent_dma_mask(pdev,
+                                DMA_BIT_MASK(32));
+                        if (rc) {
+                                dev_printk(KERN_ERR, &pdev->dev,
+                                        "44-bit DMA enable failed\n");
+                                return rc;
+                        }
+                }
+        } else {
+                rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+                if (rc) {
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                "32-bit DMA enable failed\n");
+                        return rc;
+                }
+                rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
+                if (rc) {
+                        dev_printk(KERN_ERR, &pdev->dev,
+                                "32-bit consistent DMA enable failed\n");
+                        return rc;
+                }
+        }
+        return rc;
+}
+
+/**
+ * pm8001_prep_sas_ha_init - allocate memory in general hba struct && init them.
+ * @shost: scsi host which has been allocated outside.
+ * @chip_info: our ha struct.
+ */
+static int __devinit pm8001_prep_sas_ha_init(struct Scsi_Host * shost,
+        const struct pm8001_chip_info *chip_info)
+{
+        int phy_nr, port_nr;
+        struct asd_sas_phy **arr_phy;
+        struct asd_sas_port **arr_port;
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+
+        phy_nr = chip_info->n_phy;
+        port_nr = phy_nr;
+        memset(sha, 0x00, sizeof(*sha));
+        arr_phy = kcalloc(phy_nr, sizeof(void *), GFP_KERNEL);
+        if (!arr_phy)
+                goto exit;
+        arr_port = kcalloc(port_nr, sizeof(void *), GFP_KERNEL);
+        if (!arr_port)
+                goto exit_free2;
+
+        sha->sas_phy = arr_phy;
+        sha->sas_port = arr_port;
+        sha->lldd_ha = kzalloc(sizeof(struct pm8001_hba_info), GFP_KERNEL);
+        if (!sha->lldd_ha)
+                goto exit_free1;
+
+        shost->transportt = pm8001_stt;
+        shost->max_id = PM8001_MAX_DEVICES;
+        shost->max_lun = 8;
+        shost->max_channel = 0;
+        shost->unique_id = pm8001_id;
+        shost->max_cmd_len = 16;
+        shost->can_queue = PM8001_CAN_QUEUE;
+        shost->cmd_per_lun = 32;
+        return 0;
+exit_free1:
+        kfree(arr_port);
+exit_free2:
+        kfree(arr_phy);
+exit:
+        return -1;
+}
+
+/**
+ * pm8001_post_sas_ha_init - initialize general hba struct defined in libsas
+ * @shost: scsi host which has been allocated outside
+ * @chip_info: our ha struct.
+ */
+static void  __devinit pm8001_post_sas_ha_init(struct Scsi_Host *shost,
+        const struct pm8001_chip_info *chip_info)
+{
+        int i = 0;
+        struct pm8001_hba_info *pm8001_ha;
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+
+        pm8001_ha = sha->lldd_ha;
+        for (i = 0; i < chip_info->n_phy; i++) {
+                sha->sas_phy[i] = &pm8001_ha->phy[i].sas_phy;
+                sha->sas_port[i] = &pm8001_ha->port[i].sas_port;
+        }
+        sha->sas_ha_name = DRV_NAME;
+        sha->dev = pm8001_ha->dev;
+
+        sha->lldd_module = THIS_MODULE;
+        sha->sas_addr = &pm8001_ha->sas_addr[0];
+        sha->num_phys = chip_info->n_phy;
+        sha->lldd_max_execute_num = 1;
+        sha->lldd_queue_size = PM8001_CAN_QUEUE;
+        sha->core.shost = shost;
+}
+
+/**
+ * pm8001_init_sas_add - initialize sas address
+ * @chip_info: our ha struct.
+ *
+ * Currently we just set the fixed SAS address to our HBA,for manufacture,
+ * it should read from the EEPROM
+ */
+static void pm8001_init_sas_add(struct pm8001_hba_info *pm8001_ha)
+{
+        u8 i;
+#ifdef PM8001_READ_VPD
+        DECLARE_COMPLETION_ONSTACK(completion);
+        struct pm8001_ioctl_payload payload;
+        pm8001_ha->nvmd_completion = &completion;
+        payload.minor_function = 0;
+        payload.length = 128;
+        payload.func_specific = kzalloc(128, GFP_KERNEL);
+        PM8001_CHIP_DISP->get_nvmd_req(pm8001_ha, &payload);
+        wait_for_completion(&completion);
+        for (i = 0; i < pm8001_ha->chip->n_phy; i++) {
+                memcpy(&pm8001_ha->phy[i].dev_sas_addr, pm8001_ha->sas_addr,
+                        SAS_ADDR_SIZE);
+                PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("phy %d sas_addr = %016llx \n", i,
+                        pm8001_ha->phy[i].dev_sas_addr));
+        }
+#else
+        for (i = 0; i < pm8001_ha->chip->n_phy; i++) {
+                pm8001_ha->phy[i].dev_sas_addr = 0x50010c600047f9d0ULL;
+                pm8001_ha->phy[i].dev_sas_addr =
+                        cpu_to_be64((u64)
+                                (*(u64 *)&pm8001_ha->phy[i].dev_sas_addr));
+        }
+        memcpy(pm8001_ha->sas_addr, &pm8001_ha->phy[0].dev_sas_addr,
+                SAS_ADDR_SIZE);
+#endif
+}
+
+#ifdef PM8001_USE_MSIX
+/**
+ * pm8001_setup_msix - enable MSI-X interrupt
+ * @chip_info: our ha struct.
+ * @irq_handler: irq_handler
+ */
+static u32 pm8001_setup_msix(struct pm8001_hba_info *pm8001_ha,
+        irq_handler_t irq_handler)
+{
+        u32 i = 0, j = 0;
+        u32 number_of_intr = 1;
+        int flag = 0;
+        u32 max_entry;
+        int rc;
+        max_entry = sizeof(pm8001_ha->msix_entries) /
+                sizeof(pm8001_ha->msix_entries[0]);
+        flag |= IRQF_DISABLED;
+        for (i = 0; i < max_entry ; i++)
+                pm8001_ha->msix_entries[i].entry = i;
+        rc = pci_enable_msix(pm8001_ha->pdev, pm8001_ha->msix_entries,
+                number_of_intr);
+        pm8001_ha->number_of_intr = number_of_intr;
+        if (!rc) {
+                for (i = 0; i < number_of_intr; i++) {
+                        if (request_irq(pm8001_ha->msix_entries[i].vector,
+                                irq_handler, flag, DRV_NAME,
+                                SHOST_TO_SAS_HA(pm8001_ha->shost))) {
+                                for (j = 0; j < i; j++)
+                                        free_irq(
+                                        pm8001_ha->msix_entries[j].vector,
+                                        SHOST_TO_SAS_HA(pm8001_ha->shost));
+                                pci_disable_msix(pm8001_ha->pdev);
+                                break;
+                        }
+                }
+        }
+        return rc;
+}
+#endif
+
+/**
+ * pm8001_request_irq - register interrupt
+ * @chip_info: our ha struct.
+ */
+static u32 pm8001_request_irq(struct pm8001_hba_info *pm8001_ha)
+{
+        struct pci_dev *pdev;
+        irq_handler_t irq_handler = pm8001_interrupt;
+        int rc;
+
+        pdev = pm8001_ha->pdev;
+
+#ifdef PM8001_USE_MSIX
+        if (pci_find_capability(pdev, PCI_CAP_ID_MSIX))
+                return pm8001_setup_msix(pm8001_ha, irq_handler);
+        else
+                goto intx;
+#endif
+
+intx:
+        /* intialize the INT-X interrupt */
+        rc = request_irq(pdev->irq, irq_handler, IRQF_SHARED, DRV_NAME,
+                SHOST_TO_SAS_HA(pm8001_ha->shost));
+        return rc;
+}
+
+/**
+ * pm8001_pci_probe - probe supported device
+ * @pdev: pci device which kernel has been prepared for.
+ * @ent: pci device id
+ *
+ * This function is the main initialization function, when register a new
+ * pci driver it is invoked, all struct an hardware initilization should be done
+ * here, also, register interrupt
+ */
+static int __devinit pm8001_pci_probe(struct pci_dev *pdev,
+        const struct pci_device_id *ent)
+{
+        unsigned int rc;
+        u32     pci_reg;
+        struct pm8001_hba_info *pm8001_ha;
+        struct Scsi_Host *shost = NULL;
+        const struct pm8001_chip_info *chip;
+
+        dev_printk(KERN_INFO, &pdev->dev,
+                "pm8001: driver version %s\n", DRV_VERSION);
+        rc = pci_enable_device(pdev);
+        if (rc)
+                goto err_out_enable;
+        pci_set_master(pdev);
+        /*
+         * Enable pci slot busmaster by setting pci command register.
+         * This is required by FW for Cyclone card.
+         */
+
+        pci_read_config_dword(pdev, PCI_COMMAND, &pci_reg);
+        pci_reg |= 0x157;
+        pci_write_config_dword(pdev, PCI_COMMAND, pci_reg);
+        rc = pci_request_regions(pdev, DRV_NAME);
+        if (rc)
+                goto err_out_disable;
+        rc = pci_go_44(pdev);
+        if (rc)
+                goto err_out_regions;
+
+        shost = scsi_host_alloc(&pm8001_sht, sizeof(void *));
+        if (!shost) {
+                rc = -ENOMEM;
+                goto err_out_regions;
+        }
+        chip = &pm8001_chips[ent->driver_data];
+        SHOST_TO_SAS_HA(shost) =
+                kzalloc(sizeof(struct sas_ha_struct), GFP_KERNEL);
+        if (!SHOST_TO_SAS_HA(shost)) {
+                rc = -ENOMEM;
+                goto err_out_free_host;
+        }
+
+        rc = pm8001_prep_sas_ha_init(shost, chip);
+        if (rc) {
+                rc = -ENOMEM;
+                goto err_out_free;
+        }
+        pci_set_drvdata(pdev, SHOST_TO_SAS_HA(shost));
+        pm8001_ha = pm8001_pci_alloc(pdev, chip_8001, shost);
+        if (!pm8001_ha) {
+                rc = -ENOMEM;
+                goto err_out_free;
+        }
+        list_add_tail(&pm8001_ha->list, &hba_list);
+        PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha, 0x252acbcd);
+        rc = PM8001_CHIP_DISP->chip_init(pm8001_ha);
+        if (rc)
+                goto err_out_ha_free;
+
+        rc = scsi_add_host(shost, &pdev->dev);
+        if (rc)
+                goto err_out_ha_free;
+        rc = pm8001_request_irq(pm8001_ha);
+        if (rc)
+                goto err_out_shost;
+
+        PM8001_CHIP_DISP->interrupt_enable(pm8001_ha);
+        pm8001_init_sas_add(pm8001_ha);
+        pm8001_post_sas_ha_init(shost, chip);
+        rc = sas_register_ha(SHOST_TO_SAS_HA(shost));
+        if (rc)
+                goto err_out_shost;
+        scsi_scan_host(pm8001_ha->shost);
+        return 0;
+
+err_out_shost:
+        scsi_remove_host(pm8001_ha->shost);
+err_out_ha_free:
+        pm8001_free(pm8001_ha);
+err_out_free:
+        kfree(SHOST_TO_SAS_HA(shost));
+err_out_free_host:
+        kfree(shost);
+err_out_regions:
+        pci_release_regions(pdev);
+err_out_disable:
+        pci_disable_device(pdev);
+err_out_enable:
+        return rc;
+}
+
+static void __devexit pm8001_pci_remove(struct pci_dev *pdev)
+{
+        struct sas_ha_struct *sha = pci_get_drvdata(pdev);
+        struct pm8001_hba_info *pm8001_ha;
+        int i;
+        pm8001_ha = sha->lldd_ha;
+        pci_set_drvdata(pdev, NULL);
+        sas_unregister_ha(sha);
+        sas_remove_host(pm8001_ha->shost);
+        list_del(&pm8001_ha->list);
+        scsi_remove_host(pm8001_ha->shost);
+        PM8001_CHIP_DISP->interrupt_disable(pm8001_ha);
+        PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha, 0x252acbcd);
+
+#ifdef PM8001_USE_MSIX
+        for (i = 0; i < pm8001_ha->number_of_intr; i++)
+                synchronize_irq(pm8001_ha->msix_entries[i].vector);
+        for (i = 0; i < pm8001_ha->number_of_intr; i++)
+                free_irq(pm8001_ha->msix_entries[i].vector, sha);
+        pci_disable_msix(pdev);
+#else
+        free_irq(pm8001_ha->irq, sha);
+#endif
+#ifdef PM8001_USE_TASKLET
+        tasklet_kill(&pm8001_ha->tasklet);
+#endif
+        pm8001_free(pm8001_ha);
+        kfree(sha->sas_phy);
+        kfree(sha->sas_port);
+        kfree(sha);
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+}
+
+/**
+ * pm8001_pci_suspend - power management suspend main entry point
+ * @pdev: PCI device struct
+ * @state: PM state change to (usually PCI_D3)
+ *
+ * Returns 0 success, anything else error.
+ */
+static int pm8001_pci_suspend(struct pci_dev *pdev, pm_message_t state)
+{
+        struct sas_ha_struct *sha = pci_get_drvdata(pdev);
+        struct pm8001_hba_info *pm8001_ha;
+        int i , pos;
+        u32 device_state;
+        pm8001_ha = sha->lldd_ha;
+        flush_scheduled_work();
+        scsi_block_requests(pm8001_ha->shost);
+        pos = pci_find_capability(pdev, PCI_CAP_ID_PM);
+        if (pos == 0) {
+                printk(KERN_ERR " PCI PM not supported\n");
+                return -ENODEV;
+        }
+        PM8001_CHIP_DISP->interrupt_disable(pm8001_ha);
+        PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha, 0x252acbcd);
+#ifdef PM8001_USE_MSIX
+        for (i = 0; i < pm8001_ha->number_of_intr; i++)
+                synchronize_irq(pm8001_ha->msix_entries[i].vector);
+        for (i = 0; i < pm8001_ha->number_of_intr; i++)
+                free_irq(pm8001_ha->msix_entries[i].vector, sha);
+        pci_disable_msix(pdev);
+#else
+        free_irq(pm8001_ha->irq, sha);
+#endif
+#ifdef PM8001_USE_TASKLET
+        tasklet_kill(&pm8001_ha->tasklet);
+#endif
+        device_state = pci_choose_state(pdev, state);
+        pm8001_printk("pdev=0x%p, slot=%s, entering "
+                      "operating state [D%d]\n", pdev,
+                      pm8001_ha->name, device_state);
+        pci_save_state(pdev);
+        pci_disable_device(pdev);
+        pci_set_power_state(pdev, device_state);
+        return 0;
+}
+
+/**
+ * pm8001_pci_resume - power management resume main entry point
+ * @pdev: PCI device struct
+ *
+ * Returns 0 success, anything else error.
+ */
+static int pm8001_pci_resume(struct pci_dev *pdev)
+{
+        struct sas_ha_struct *sha = pci_get_drvdata(pdev);
+        struct pm8001_hba_info *pm8001_ha;
+        int rc;
+        u32 device_state;
+        pm8001_ha = sha->lldd_ha;
+        device_state = pdev->current_state;
+
+        pm8001_printk("pdev=0x%p, slot=%s, resuming from previous "
+                "operating state [D%d]\n", pdev, pm8001_ha->name, device_state);
+
+        pci_set_power_state(pdev, PCI_D0);
+        pci_enable_wake(pdev, PCI_D0, 0);
+        pci_restore_state(pdev);
+        rc = pci_enable_device(pdev);
+        if (rc) {
+                pm8001_printk("slot=%s Enable device failed during resume\n",
+                              pm8001_ha->name);
+                goto err_out_enable;
+        }
+
+        pci_set_master(pdev);
+        rc = pci_go_44(pdev);
+        if (rc)
+                goto err_out_disable;
+
+        PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha, 0x252acbcd);
+        rc = PM8001_CHIP_DISP->chip_init(pm8001_ha);
+        if (rc)
+                goto err_out_disable;
+        PM8001_CHIP_DISP->interrupt_disable(pm8001_ha);
+        rc = pm8001_request_irq(pm8001_ha);
+        if (rc)
+                goto err_out_disable;
+        #ifdef PM8001_USE_TASKLET
+        tasklet_init(&pm8001_ha->tasklet, pm8001_tasklet,
+                    (unsigned long)pm8001_ha);
+        #endif
+        PM8001_CHIP_DISP->interrupt_enable(pm8001_ha);
+        scsi_unblock_requests(pm8001_ha->shost);
+        return 0;
+
+err_out_disable:
+        scsi_remove_host(pm8001_ha->shost);
+        pci_disable_device(pdev);
+err_out_enable:
+        return rc;
+}
+
+static struct pci_device_id __devinitdata pm8001_pci_table[] = {
+        {
+                PCI_VDEVICE(PMC_Sierra, 0x8001), chip_8001
+        },
+        {
+                PCI_DEVICE(0x117c, 0x0042),
+                .driver_data = chip_8001
+        },
+        {} /* terminate list */
+};
+
+static struct pci_driver pm8001_pci_driver = {
+        .name           = DRV_NAME,
+        .id_table       = pm8001_pci_table,
+        .probe          = pm8001_pci_probe,
+        .remove         = __devexit_p(pm8001_pci_remove),
+        .suspend        = pm8001_pci_suspend,
+        .resume         = pm8001_pci_resume,
+};
+
+/**
+ *      pm8001_init - initialize scsi transport template
+ */
+static int __init pm8001_init(void)
+{
+        int rc;
+        pm8001_id = 0;
+        pm8001_stt = sas_domain_attach_transport(&pm8001_transport_ops);
+        if (!pm8001_stt)
+                return -ENOMEM;
+        rc = pci_register_driver(&pm8001_pci_driver);
+        if (rc)
+                goto err_out;
+        return 0;
+err_out:
+        sas_release_transport(pm8001_stt);
+        return rc;
+}
+
+static void __exit pm8001_exit(void)
+{
+        pci_unregister_driver(&pm8001_pci_driver);
+        sas_release_transport(pm8001_stt);
+}
+
+module_init(pm8001_init);
+module_exit(pm8001_exit);
+
+MODULE_AUTHOR("Jack Wang <jack_wang@usish.com>");
+MODULE_DESCRIPTION("PMC-Sierra PM8001 SAS/SATA controller driver");
+MODULE_VERSION(DRV_VERSION);
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, pm8001_pci_table);
+
diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c
new file mode 100644
index 000000000000..bff4f5139b9c
--- /dev/null
+++ b/drivers/scsi/pm8001/pm8001_sas.c
@@ -0,0 +1,1153 @@
+/*
+ * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
+ *
+ * Copyright (c) 2008-2009 USI Co., Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ */
+
+#include <linux/slab.h>
+#include "pm8001_sas.h"
+
+/**
+ * pm8001_find_tag - from sas task to find out  tag that belongs to this task
+ * @task: the task sent to the LLDD
+ * @tag: the found tag associated with the task
+ */
+static int pm8001_find_tag(struct sas_task *task, u32 *tag)
+{
+        if (task->lldd_task) {
+                struct pm8001_ccb_info *ccb;
+                ccb = task->lldd_task;
+                *tag = ccb->ccb_tag;
+                return 1;
+        }
+        return 0;
+}
+
+/**
+  * pm8001_tag_clear - clear the tags bitmap
+  * @pm8001_ha: our hba struct
+  * @tag: the found tag associated with the task
+  */
+static void pm8001_tag_clear(struct pm8001_hba_info *pm8001_ha, u32 tag)
+{
+        void *bitmap = pm8001_ha->tags;
+        clear_bit(tag, bitmap);
+}
+
+static void pm8001_tag_free(struct pm8001_hba_info *pm8001_ha, u32 tag)
+{
+        pm8001_tag_clear(pm8001_ha, tag);
+}
+
+static void pm8001_tag_set(struct pm8001_hba_info *pm8001_ha, u32 tag)
+{
+        void *bitmap = pm8001_ha->tags;
+        set_bit(tag, bitmap);
+}
+
+/**
+  * pm8001_tag_alloc - allocate a empty tag for task used.
+  * @pm8001_ha: our hba struct
+  * @tag_out: the found empty tag .
+  */
+inline int pm8001_tag_alloc(struct pm8001_hba_info *pm8001_ha, u32 *tag_out)
+{
+        unsigned int index, tag;
+        void *bitmap = pm8001_ha->tags;
+
+        index = find_first_zero_bit(bitmap, pm8001_ha->tags_num);
+        tag = index;
+        if (tag >= pm8001_ha->tags_num)
+                return -SAS_QUEUE_FULL;
+        pm8001_tag_set(pm8001_ha, tag);
+        *tag_out = tag;
+        return 0;
+}
+
+void pm8001_tag_init(struct pm8001_hba_info *pm8001_ha)
+{
+        int i;
+        for (i = 0; i < pm8001_ha->tags_num; ++i)
+                pm8001_tag_clear(pm8001_ha, i);
+}
+
+ /**
+  * pm8001_mem_alloc - allocate memory for pm8001.
+  * @pdev: pci device.
+  * @virt_addr: the allocated virtual address
+  * @pphys_addr_hi: the physical address high byte address.
+  * @pphys_addr_lo: the physical address low byte address.
+  * @mem_size: memory size.
+  */
+int pm8001_mem_alloc(struct pci_dev *pdev, void **virt_addr,
+        dma_addr_t *pphys_addr, u32 *pphys_addr_hi,
+        u32 *pphys_addr_lo, u32 mem_size, u32 align)
+{
+        caddr_t mem_virt_alloc;
+        dma_addr_t mem_dma_handle;
+        u64 phys_align;
+        u64 align_offset = 0;
+        if (align)
+                align_offset = (dma_addr_t)align - 1;
+        mem_virt_alloc =
+                pci_alloc_consistent(pdev, mem_size + align, &mem_dma_handle);
+        if (!mem_virt_alloc) {
+                pm8001_printk("memory allocation error\n");
+                return -1;
+        }
+        memset((void *)mem_virt_alloc, 0, mem_size+align);
+        *pphys_addr = mem_dma_handle;
+        phys_align = (*pphys_addr + align_offset) & ~align_offset;
+        *virt_addr = (void *)mem_virt_alloc + phys_align - *pphys_addr;
+        *pphys_addr_hi = upper_32_bits(phys_align);
+        *pphys_addr_lo = lower_32_bits(phys_align);
+        return 0;
+}
+/**
+  * pm8001_find_ha_by_dev - from domain device which come from sas layer to
+  * find out our hba struct.
+  * @dev: the domain device which from sas layer.
+  */
+static
+struct pm8001_hba_info *pm8001_find_ha_by_dev(struct domain_device *dev)
+{
+        struct sas_ha_struct *sha = dev->port->ha;
+        struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
+        return pm8001_ha;
+}
+
+/**
+  * pm8001_phy_control - this function should be registered to
+  * sas_domain_function_template to provide libsas used, note: this is just
+  * control the HBA phy rather than other expander phy if you want control
+  * other phy, you should use SMP command.
+  * @sas_phy: which phy in HBA phys.
+  * @func: the operation.
+  * @funcdata: always NULL.
+  */
+int pm8001_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func,
+        void *funcdata)
+{
+        int rc = 0, phy_id = sas_phy->id;
+        struct pm8001_hba_info *pm8001_ha = NULL;
+        struct sas_phy_linkrates *rates;
+        DECLARE_COMPLETION_ONSTACK(completion);
+        pm8001_ha = sas_phy->ha->lldd_ha;
+        pm8001_ha->phy[phy_id].enable_completion = &completion;
+        switch (func) {
+        case PHY_FUNC_SET_LINK_RATE:
+                rates = funcdata;
+                if (rates->minimum_linkrate) {
+                        pm8001_ha->phy[phy_id].minimum_linkrate =
+                                rates->minimum_linkrate;
+                }
+                if (rates->maximum_linkrate) {
+                        pm8001_ha->phy[phy_id].maximum_linkrate =
+                                rates->maximum_linkrate;
+                }
+                if (pm8001_ha->phy[phy_id].phy_state == 0) {
+                        PM8001_CHIP_DISP->phy_start_req(pm8001_ha, phy_id);
+                        wait_for_completion(&completion);
+                }
+                PM8001_CHIP_DISP->phy_ctl_req(pm8001_ha, phy_id,
+                                              PHY_LINK_RESET);
+                break;
+        case PHY_FUNC_HARD_RESET:
+                if (pm8001_ha->phy[phy_id].phy_state == 0) {
+                        PM8001_CHIP_DISP->phy_start_req(pm8001_ha, phy_id);
+                        wait_for_completion(&completion);
+                }
+                PM8001_CHIP_DISP->phy_ctl_req(pm8001_ha, phy_id,
+                                              PHY_HARD_RESET);
+                break;
+        case PHY_FUNC_LINK_RESET:
+                if (pm8001_ha->phy[phy_id].phy_state == 0) {
+                        PM8001_CHIP_DISP->phy_start_req(pm8001_ha, phy_id);
+                        wait_for_completion(&completion);
+                }
+                PM8001_CHIP_DISP->phy_ctl_req(pm8001_ha, phy_id,
+                                              PHY_LINK_RESET);
+                break;
+        case PHY_FUNC_RELEASE_SPINUP_HOLD:
+                PM8001_CHIP_DISP->phy_ctl_req(pm8001_ha, phy_id,
+                                              PHY_LINK_RESET);
+                break;
+        case PHY_FUNC_DISABLE:
+                PM8001_CHIP_DISP->phy_stop_req(pm8001_ha, phy_id);
+                break;
+        default:
+                rc = -EOPNOTSUPP;
+        }
+        msleep(300);
+        return rc;
+}
+
+int pm8001_slave_alloc(struct scsi_device *scsi_dev)
+{
+        struct domain_device *dev = sdev_to_domain_dev(scsi_dev);
+        if (dev_is_sata(dev)) {
+                /* We don't need to rescan targets
+                * if REPORT_LUNS request is failed
+                */
+                if (scsi_dev->lun > 0)
+                        return -ENXIO;
+                scsi_dev->tagged_supported = 1;
+        }
+        return sas_slave_alloc(scsi_dev);
+}
+
+/**
+  * pm8001_scan_start - we should enable all HBA phys by sending the phy_start
+  * command to HBA.
+  * @shost: the scsi host data.
+  */
+void pm8001_scan_start(struct Scsi_Host *shost)
+{
+        int i;
+        struct pm8001_hba_info *pm8001_ha;
+        struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
+        pm8001_ha = sha->lldd_ha;
+        PM8001_CHIP_DISP->sas_re_init_req(pm8001_ha);
+        for (i = 0; i < pm8001_ha->chip->n_phy; ++i)
+                PM8001_CHIP_DISP->phy_start_req(pm8001_ha, i);
+}
+
+int pm8001_scan_finished(struct Scsi_Host *shost, unsigned long time)
+{
+        /* give the phy enabling interrupt event time to come in (1s
+        * is empirically about all it takes) */
+        if (time < HZ)
+                return 0;
+        /* Wait for discovery to finish */
+        scsi_flush_work(shost);
+        return 1;
+}
+
+/**
+  * pm8001_task_prep_smp - the dispatcher function, prepare data for smp task
+  * @pm8001_ha: our hba card information
+  * @ccb: the ccb which attached to smp task
+  */
+static int pm8001_task_prep_smp(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_ccb_info *ccb)
+{
+        return PM8001_CHIP_DISP->smp_req(pm8001_ha, ccb);
+}
+
+u32 pm8001_get_ncq_tag(struct sas_task *task, u32 *tag)
+{
+        struct ata_queued_cmd *qc = task->uldd_task;
+        if (qc) {
+                if (qc->tf.command == ATA_CMD_FPDMA_WRITE ||
+                        qc->tf.command == ATA_CMD_FPDMA_READ) {
+                        *tag = qc->tag;
+                        return 1;
+                }
+        }
+        return 0;
+}
+
+/**
+  * pm8001_task_prep_ata - the dispatcher function, prepare data for sata task
+  * @pm8001_ha: our hba card information
+  * @ccb: the ccb which attached to sata task
+  */
+static int pm8001_task_prep_ata(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_ccb_info *ccb)
+{
+        return PM8001_CHIP_DISP->sata_req(pm8001_ha, ccb);
+}
+
+/**
+  * pm8001_task_prep_ssp_tm - the dispatcher function, prepare task management data
+  * @pm8001_ha: our hba card information
+  * @ccb: the ccb which attached to TM
+  * @tmf: the task management IU
+  */
+static int pm8001_task_prep_ssp_tm(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_ccb_info *ccb, struct pm8001_tmf_task *tmf)
+{
+        return PM8001_CHIP_DISP->ssp_tm_req(pm8001_ha, ccb, tmf);
+}
+
+/**
+  * pm8001_task_prep_ssp - the dispatcher function,prepare ssp data for ssp task
+  * @pm8001_ha: our hba card information
+  * @ccb: the ccb which attached to ssp task
+  */
+static int pm8001_task_prep_ssp(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_ccb_info *ccb)
+{
+        return PM8001_CHIP_DISP->ssp_io_req(pm8001_ha, ccb);
+}
+int pm8001_slave_configure(struct scsi_device *sdev)
+{
+        struct domain_device *dev = sdev_to_domain_dev(sdev);
+        int ret = sas_slave_configure(sdev);
+        if (ret)
+                return ret;
+        if (dev_is_sata(dev)) {
+        #ifdef PM8001_DISABLE_NCQ
+                struct ata_port *ap = dev->sata_dev.ap;
+                struct ata_device *adev = ap->link.device;
+                adev->flags |= ATA_DFLAG_NCQ_OFF;
+                scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, 1);
+        #endif
+        }
+        return 0;
+}
+ /* Find the local port id that's attached to this device */
+static int sas_find_local_port_id(struct domain_device *dev)
+{
+        struct domain_device *pdev = dev->parent;
+
+        /* Directly attached device */
+        if (!pdev)
+                return dev->port->id;
+        while (pdev) {
+                struct domain_device *pdev_p = pdev->parent;
+                if (!pdev_p)
+                        return pdev->port->id;
+                pdev = pdev->parent;
+        }
+        return 0;
+}
+
+/**
+  * pm8001_task_exec - queue the task(ssp, smp && ata) to the hardware.
+  * @task: the task to be execute.
+  * @num: if can_queue great than 1, the task can be queued up. for SMP task,
+  * we always execute one one time.
+  * @gfp_flags: gfp_flags.
+  * @is_tmf: if it is task management task.
+  * @tmf: the task management IU
+  */
+#define DEV_IS_GONE(pm8001_dev) \
+        ((!pm8001_dev || (pm8001_dev->dev_type == NO_DEVICE)))
+static int pm8001_task_exec(struct sas_task *task, const int num,
+        gfp_t gfp_flags, int is_tmf, struct pm8001_tmf_task *tmf)
+{
+        struct domain_device *dev = task->dev;
+        struct pm8001_hba_info *pm8001_ha;
+        struct pm8001_device *pm8001_dev;
+        struct pm8001_port *port = NULL;
+        struct sas_task *t = task;
+        struct pm8001_ccb_info *ccb;
+        u32 tag = 0xdeadbeef, rc, n_elem = 0;
+        u32 n = num;
+        unsigned long flags = 0, flags_libsas = 0;
+
+        if (!dev->port) {
+                struct task_status_struct *tsm = &t->task_status;
+                tsm->resp = SAS_TASK_UNDELIVERED;
+                tsm->stat = SAS_PHY_DOWN;
+                if (dev->dev_type != SATA_DEV)
+                        t->task_done(t);
+                return 0;
+        }
+        pm8001_ha = pm8001_find_ha_by_dev(task->dev);
+        PM8001_IO_DBG(pm8001_ha, pm8001_printk("pm8001_task_exec device \n "));
+        spin_lock_irqsave(&pm8001_ha->lock, flags);
+        do {
+                dev = t->dev;
+                pm8001_dev = dev->lldd_dev;
+                if (DEV_IS_GONE(pm8001_dev)) {
+                        if (pm8001_dev) {
+                                PM8001_IO_DBG(pm8001_ha,
+                                        pm8001_printk("device %d not ready.\n",
+                                        pm8001_dev->device_id));
+                        } else {
+                                PM8001_IO_DBG(pm8001_ha,
+                                        pm8001_printk("device %016llx not "
+                                        "ready.\n", SAS_ADDR(dev->sas_addr)));
+                        }
+                        rc = SAS_PHY_DOWN;
+                        goto out_done;
+                }
+                port = &pm8001_ha->port[sas_find_local_port_id(dev)];
+                if (!port->port_attached) {
+                        if (sas_protocol_ata(t->task_proto)) {
+                                struct task_status_struct *ts = &t->task_status;
+                                ts->resp = SAS_TASK_UNDELIVERED;
+                                ts->stat = SAS_PHY_DOWN;
+
+                                spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                                spin_unlock_irqrestore(dev->sata_dev.ap->lock,
+                                                flags_libsas);
+                                t->task_done(t);
+                                spin_lock_irqsave(dev->sata_dev.ap->lock,
+                                        flags_libsas);
+                                spin_lock_irqsave(&pm8001_ha->lock, flags);
+                                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;
+                        }
+                }
+                rc = pm8001_tag_alloc(pm8001_ha, &tag);
+                if (rc)
+                        goto err_out;
+                ccb = &pm8001_ha->ccb_info[tag];
+
+                if (!sas_protocol_ata(t->task_proto)) {
+                        if (t->num_scatter) {
+                                n_elem = dma_map_sg(pm8001_ha->dev,
+                                        t->scatter,
+                                        t->num_scatter,
+                                        t->data_dir);
+                                if (!n_elem) {
+                                        rc = -ENOMEM;
+                                        goto err_out_tag;
+                                }
+                        }
+                } else {
+                        n_elem = t->num_scatter;
+                }
+
+                t->lldd_task = ccb;
+                ccb->n_elem = n_elem;
+                ccb->ccb_tag = tag;
+                ccb->task = t;
+                switch (t->task_proto) {
+                case SAS_PROTOCOL_SMP:
+                        rc = pm8001_task_prep_smp(pm8001_ha, ccb);
+                        break;
+                case SAS_PROTOCOL_SSP:
+                        if (is_tmf)
+                                rc = pm8001_task_prep_ssp_tm(pm8001_ha,
+                                        ccb, tmf);
+                        else
+                                rc = pm8001_task_prep_ssp(pm8001_ha, ccb);
+                        break;
+                case SAS_PROTOCOL_SATA:
+                case SAS_PROTOCOL_STP:
+                case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
+                        rc = pm8001_task_prep_ata(pm8001_ha, ccb);
+                        break;
+                default:
+                        dev_printk(KERN_ERR, pm8001_ha->dev,
+                                "unknown sas_task proto: 0x%x\n",
+                                t->task_proto);
+                        rc = -EINVAL;
+                        break;
+                }
+
+                if (rc) {
+                        PM8001_IO_DBG(pm8001_ha,
+                                pm8001_printk("rc is %x\n", rc));
+                        goto err_out_tag;
+                }
+                /* 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);
+                pm8001_dev->running_req++;
+                if (n > 1)
+                        t = list_entry(t->list.next, struct sas_task, list);
+        } while (--n);
+        rc = 0;
+        goto out_done;
+
+err_out_tag:
+        pm8001_tag_free(pm8001_ha, tag);
+err_out:
+        dev_printk(KERN_ERR, pm8001_ha->dev, "pm8001 exec failed[%d]!\n", rc);
+        if (!sas_protocol_ata(t->task_proto))
+                if (n_elem)
+                        dma_unmap_sg(pm8001_ha->dev, t->scatter, n_elem,
+                                t->data_dir);
+out_done:
+        spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+        return rc;
+}
+
+/**
+  * pm8001_queue_command - register for upper layer used, all IO commands sent
+  * to HBA are from this interface.
+  * @task: the task to be execute.
+  * @num: if can_queue great than 1, the task can be queued up. for SMP task,
+  * we always execute one one time
+  * @gfp_flags: gfp_flags
+  */
+int pm8001_queue_command(struct sas_task *task, const int num,
+                gfp_t gfp_flags)
+{
+        return pm8001_task_exec(task, num, gfp_flags, 0, NULL);
+}
+
+void pm8001_ccb_free(struct pm8001_hba_info *pm8001_ha, u32 ccb_idx)
+{
+        pm8001_tag_clear(pm8001_ha, ccb_idx);
+}
+
+/**
+  * pm8001_ccb_task_free - free the sg for ssp and smp command, free the ccb.
+  * @pm8001_ha: our hba card information
+  * @ccb: the ccb which attached to ssp task
+  * @task: the task to be free.
+  * @ccb_idx: ccb index.
+  */
+void pm8001_ccb_task_free(struct pm8001_hba_info *pm8001_ha,
+        struct sas_task *task, struct pm8001_ccb_info *ccb, u32 ccb_idx)
+{
+        if (!ccb->task)
+                return;
+        if (!sas_protocol_ata(task->task_proto))
+                if (ccb->n_elem)
+                        dma_unmap_sg(pm8001_ha->dev, task->scatter,
+                                task->num_scatter, task->data_dir);
+
+        switch (task->task_proto) {
+        case SAS_PROTOCOL_SMP:
+                dma_unmap_sg(pm8001_ha->dev, &task->smp_task.smp_resp, 1,
+                        PCI_DMA_FROMDEVICE);
+                dma_unmap_sg(pm8001_ha->dev, &task->smp_task.smp_req, 1,
+                        PCI_DMA_TODEVICE);
+                break;
+
+        case SAS_PROTOCOL_SATA:
+        case SAS_PROTOCOL_STP:
+        case SAS_PROTOCOL_SSP:
+        default:
+                /* do nothing */
+                break;
+        }
+        task->lldd_task = NULL;
+        ccb->task = NULL;
+        ccb->ccb_tag = 0xFFFFFFFF;
+        pm8001_ccb_free(pm8001_ha, ccb_idx);
+}
+
+ /**
+  * pm8001_alloc_dev - find a empty pm8001_device
+  * @pm8001_ha: our hba card information
+  */
+struct pm8001_device *pm8001_alloc_dev(struct pm8001_hba_info *pm8001_ha)
+{
+        u32 dev;
+        for (dev = 0; dev < PM8001_MAX_DEVICES; dev++) {
+                if (pm8001_ha->devices[dev].dev_type == NO_DEVICE) {
+                        pm8001_ha->devices[dev].id = dev;
+                        return &pm8001_ha->devices[dev];
+                }
+        }
+        if (dev == PM8001_MAX_DEVICES) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("max support %d devices, ignore ..\n",
+                        PM8001_MAX_DEVICES));
+        }
+        return NULL;
+}
+
+static void pm8001_free_dev(struct pm8001_device *pm8001_dev)
+{
+        u32 id = pm8001_dev->id;
+        memset(pm8001_dev, 0, sizeof(*pm8001_dev));
+        pm8001_dev->id = id;
+        pm8001_dev->dev_type = NO_DEVICE;
+        pm8001_dev->device_id = PM8001_MAX_DEVICES;
+        pm8001_dev->sas_device = NULL;
+}
+
+/**
+  * pm8001_dev_found_notify - libsas notify a device is found.
+  * @dev: the device structure which sas layer used.
+  *
+  * when libsas find a sas domain device, it should tell the LLDD that
+  * device is found, and then LLDD register this device to HBA firmware
+  * by the command "OPC_INB_REG_DEV", after that the HBA will assign a
+  * device ID(according to device's sas address) and returned it to LLDD. From
+  * now on, we communicate with HBA FW with the device ID which HBA assigned
+  * rather than sas address. it is the necessary step for our HBA but it is
+  * the optional for other HBA driver.
+  */
+static int pm8001_dev_found_notify(struct domain_device *dev)
+{
+        unsigned long flags = 0;
+        int res = 0;
+        struct pm8001_hba_info *pm8001_ha = NULL;
+        struct domain_device *parent_dev = dev->parent;
+        struct pm8001_device *pm8001_device;
+        DECLARE_COMPLETION_ONSTACK(completion);
+        u32 flag = 0;
+        pm8001_ha = pm8001_find_ha_by_dev(dev);
+        spin_lock_irqsave(&pm8001_ha->lock, flags);
+
+        pm8001_device = pm8001_alloc_dev(pm8001_ha);
+        if (!pm8001_device) {
+                res = -1;
+                goto found_out;
+        }
+        pm8001_device->sas_device = dev;
+        dev->lldd_dev = pm8001_device;
+        pm8001_device->dev_type = dev->dev_type;
+        pm8001_device->dcompletion = &completion;
+        if (parent_dev && DEV_IS_EXPANDER(parent_dev->dev_type)) {
+                int phy_id;
+                struct ex_phy *phy;
+                for (phy_id = 0; phy_id < parent_dev->ex_dev.num_phys;
+                phy_id++) {
+                        phy = &parent_dev->ex_dev.ex_phy[phy_id];
+                        if (SAS_ADDR(phy->attached_sas_addr)
+                                == SAS_ADDR(dev->sas_addr)) {
+                                pm8001_device->attached_phy = phy_id;
+                                break;
+                        }
+                }
+                if (phy_id == parent_dev->ex_dev.num_phys) {
+                        PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("Error: no attached dev:%016llx"
+                        " at ex:%016llx.\n", SAS_ADDR(dev->sas_addr),
+                                SAS_ADDR(parent_dev->sas_addr)));
+                        res = -1;
+                }
+        } else {
+                if (dev->dev_type == SATA_DEV) {
+                        pm8001_device->attached_phy =
+                                dev->rphy->identify.phy_identifier;
+                                flag = 1; /* directly sata*/
+                }
+        } /*register this device to HBA*/
+        PM8001_DISC_DBG(pm8001_ha, pm8001_printk("Found device \n"));
+        PM8001_CHIP_DISP->reg_dev_req(pm8001_ha, pm8001_device, flag);
+        spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+        wait_for_completion(&completion);
+        if (dev->dev_type == SAS_END_DEV)
+                msleep(50);
+        pm8001_ha->flags |= PM8001F_RUN_TIME ;
+        return 0;
+found_out:
+        spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+        return res;
+}
+
+int pm8001_dev_found(struct domain_device *dev)
+{
+        return pm8001_dev_found_notify(dev);
+}
+
+/**
+  * pm8001_alloc_task - allocate a task structure for TMF
+  */
+static struct sas_task *pm8001_alloc_task(void)
+{
+        struct sas_task *task = kzalloc(sizeof(*task), GFP_KERNEL);
+        if (task) {
+                INIT_LIST_HEAD(&task->list);
+                spin_lock_init(&task->task_state_lock);
+                task->task_state_flags = SAS_TASK_STATE_PENDING;
+                init_timer(&task->timer);
+                init_completion(&task->completion);
+        }
+        return task;
+}
+
+static void pm8001_free_task(struct sas_task *task)
+{
+        if (task) {
+                BUG_ON(!list_empty(&task->list));
+                kfree(task);
+        }
+}
+
+static void pm8001_task_done(struct sas_task *task)
+{
+        if (!del_timer(&task->timer))
+                return;
+        complete(&task->completion);
+}
+
+static void pm8001_tmf_timedout(unsigned long data)
+{
+        struct sas_task *task = (struct sas_task *)data;
+
+        task->task_state_flags |= SAS_TASK_STATE_ABORTED;
+        complete(&task->completion);
+}
+
+#define PM8001_TASK_TIMEOUT 20
+/**
+  * pm8001_exec_internal_tmf_task - execute some task management commands.
+  * @dev: the wanted device.
+  * @tmf: which task management wanted to be take.
+  * @para_len: para_len.
+  * @parameter: ssp task parameter.
+  *
+  * when errors or exception happened, we may want to do something, for example
+  * abort the issued task which result in this execption, it is done by calling
+  * this function, note it is also with the task execute interface.
+  */
+static int pm8001_exec_internal_tmf_task(struct domain_device *dev,
+        void *parameter, u32 para_len, struct pm8001_tmf_task *tmf)
+{
+        int res, retry;
+        struct sas_task *task = NULL;
+        struct pm8001_hba_info *pm8001_ha = pm8001_find_ha_by_dev(dev);
+
+        for (retry = 0; retry < 3; retry++) {
+                task = pm8001_alloc_task();
+                if (!task)
+                        return -ENOMEM;
+
+                task->dev = dev;
+                task->task_proto = dev->tproto;
+                memcpy(&task->ssp_task, parameter, para_len);
+                task->task_done = pm8001_task_done;
+                task->timer.data = (unsigned long)task;
+                task->timer.function = pm8001_tmf_timedout;
+                task->timer.expires = jiffies + PM8001_TASK_TIMEOUT*HZ;
+                add_timer(&task->timer);
+
+                res = pm8001_task_exec(task, 1, GFP_KERNEL, 1, tmf);
+
+                if (res) {
+                        del_timer(&task->timer);
+                        PM8001_FAIL_DBG(pm8001_ha,
+                                pm8001_printk("Executing internal task "
+                                "failed\n"));
+                        goto ex_err;
+                }
+                wait_for_completion(&task->completion);
+                res = -TMF_RESP_FUNC_FAILED;
+                /* Even TMF timed out, return direct. */
+                if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
+                        if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
+                                PM8001_FAIL_DBG(pm8001_ha,
+                                        pm8001_printk("TMF task[%x]timeout.\n",
+                                        tmf->tmf));
+                                goto ex_err;
+                        }
+                }
+
+                if (task->task_status.resp == SAS_TASK_COMPLETE &&
+                        task->task_status.stat == SAM_GOOD) {
+                        res = TMF_RESP_FUNC_COMPLETE;
+                        break;
+                }
+
+                if (task->task_status.resp == SAS_TASK_COMPLETE &&
+                task->task_status.stat == SAS_DATA_UNDERRUN) {
+                        /* no error, but return the number of bytes of
+                        * underrun */
+                        res = task->task_status.residual;
+                        break;
+                }
+
+                if (task->task_status.resp == SAS_TASK_COMPLETE &&
+                        task->task_status.stat == SAS_DATA_OVERRUN) {
+                        PM8001_FAIL_DBG(pm8001_ha,
+                                pm8001_printk("Blocked task error.\n"));
+                        res = -EMSGSIZE;
+                        break;
+                } else {
+                        PM8001_EH_DBG(pm8001_ha,
+                                pm8001_printk(" Task to dev %016llx response:"
+                                "0x%x status 0x%x\n",
+                                SAS_ADDR(dev->sas_addr),
+                                task->task_status.resp,
+                                task->task_status.stat));
+                        pm8001_free_task(task);
+                        task = NULL;
+                }
+        }
+ex_err:
+        BUG_ON(retry == 3 && task != NULL);
+        if (task != NULL)
+                pm8001_free_task(task);
+        return res;
+}
+
+static int
+pm8001_exec_internal_task_abort(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_device *pm8001_dev, struct domain_device *dev, u32 flag,
+        u32 task_tag)
+{
+        int res, retry;
+        u32 ccb_tag;
+        struct pm8001_ccb_info *ccb;
+        struct sas_task *task = NULL;
+
+        for (retry = 0; retry < 3; retry++) {
+                task = pm8001_alloc_task();
+                if (!task)
+                        return -ENOMEM;
+
+                task->dev = dev;
+                task->task_proto = dev->tproto;
+                task->task_done = pm8001_task_done;
+                task->timer.data = (unsigned long)task;
+                task->timer.function = pm8001_tmf_timedout;
+                task->timer.expires = jiffies + PM8001_TASK_TIMEOUT * HZ;
+                add_timer(&task->timer);
+
+                res = pm8001_tag_alloc(pm8001_ha, &ccb_tag);
+                if (res)
+                        return res;
+                ccb = &pm8001_ha->ccb_info[ccb_tag];
+                ccb->device = pm8001_dev;
+                ccb->ccb_tag = ccb_tag;
+                ccb->task = task;
+
+                res = PM8001_CHIP_DISP->task_abort(pm8001_ha,
+                        pm8001_dev, flag, task_tag, ccb_tag);
+
+                if (res) {
+                        del_timer(&task->timer);
+                        PM8001_FAIL_DBG(pm8001_ha,
+                                pm8001_printk("Executing internal task "
+                                "failed\n"));
+                        goto ex_err;
+                }
+                wait_for_completion(&task->completion);
+                res = TMF_RESP_FUNC_FAILED;
+                /* Even TMF timed out, return direct. */
+                if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
+                        if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
+                                PM8001_FAIL_DBG(pm8001_ha,
+                                        pm8001_printk("TMF task timeout.\n"));
+                                goto ex_err;
+                        }
+                }
+
+                if (task->task_status.resp == SAS_TASK_COMPLETE &&
+                        task->task_status.stat == SAM_GOOD) {
+                        res = TMF_RESP_FUNC_COMPLETE;
+                        break;
+
+                } else {
+                        PM8001_EH_DBG(pm8001_ha,
+                                pm8001_printk(" Task to dev %016llx response: "
+                                        "0x%x status 0x%x\n",
+                                SAS_ADDR(dev->sas_addr),
+                                task->task_status.resp,
+                                task->task_status.stat));
+                        pm8001_free_task(task);
+                        task = NULL;
+                }
+        }
+ex_err:
+        BUG_ON(retry == 3 && task != NULL);
+        if (task != NULL)
+                pm8001_free_task(task);
+        return res;
+}
+
+/**
+  * pm8001_dev_gone_notify - see the comments for "pm8001_dev_found_notify"
+  * @dev: the device structure which sas layer used.
+  */
+static void pm8001_dev_gone_notify(struct domain_device *dev)
+{
+        unsigned long flags = 0;
+        u32 tag;
+        struct pm8001_hba_info *pm8001_ha;
+        struct pm8001_device *pm8001_dev = dev->lldd_dev;
+        u32 device_id = pm8001_dev->device_id;
+        pm8001_ha = pm8001_find_ha_by_dev(dev);
+        spin_lock_irqsave(&pm8001_ha->lock, flags);
+        pm8001_tag_alloc(pm8001_ha, &tag);
+        if (pm8001_dev) {
+                PM8001_DISC_DBG(pm8001_ha,
+                        pm8001_printk("found dev[%d:%x] is gone.\n",
+                        pm8001_dev->device_id, pm8001_dev->dev_type));
+                if (pm8001_dev->running_req) {
+                        spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                        pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
+                                dev, 1, 0);
+                        spin_lock_irqsave(&pm8001_ha->lock, flags);
+                }
+                PM8001_CHIP_DISP->dereg_dev_req(pm8001_ha, device_id);
+                pm8001_free_dev(pm8001_dev);
+        } else {
+                PM8001_DISC_DBG(pm8001_ha,
+                        pm8001_printk("Found dev has gone.\n"));
+        }
+        dev->lldd_dev = NULL;
+        spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+}
+
+void pm8001_dev_gone(struct domain_device *dev)
+{
+        pm8001_dev_gone_notify(dev);
+}
+
+static int pm8001_issue_ssp_tmf(struct domain_device *dev,
+        u8 *lun, struct pm8001_tmf_task *tmf)
+{
+        struct sas_ssp_task ssp_task;
+        if (!(dev->tproto & SAS_PROTOCOL_SSP))
+                return TMF_RESP_FUNC_ESUPP;
+
+        strncpy((u8 *)&ssp_task.LUN, lun, 8);
+        return pm8001_exec_internal_tmf_task(dev, &ssp_task, sizeof(ssp_task),
+                tmf);
+}
+
+/**
+  * Standard mandates link reset for ATA  (type 0) and hard reset for
+  * SSP (type 1) , only for RECOVERY
+  */
+int pm8001_I_T_nexus_reset(struct domain_device *dev)
+{
+        int rc = TMF_RESP_FUNC_FAILED;
+        struct pm8001_device *pm8001_dev;
+        struct pm8001_hba_info *pm8001_ha;
+        struct sas_phy *phy;
+        if (!dev || !dev->lldd_dev)
+                return -1;
+
+        pm8001_dev = dev->lldd_dev;
+        pm8001_ha = pm8001_find_ha_by_dev(dev);
+        phy = sas_find_local_phy(dev);
+
+        if (dev_is_sata(dev)) {
+                DECLARE_COMPLETION_ONSTACK(completion_setstate);
+                if (scsi_is_sas_phy_local(phy))
+                        return 0;
+                rc = sas_phy_reset(phy, 1);
+                msleep(2000);
+                rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
+                        dev, 1, 0);
+                pm8001_dev->setds_completion = &completion_setstate;
+                rc = PM8001_CHIP_DISP->set_dev_state_req(pm8001_ha,
+                        pm8001_dev, 0x01);
+                wait_for_completion(&completion_setstate);
+        } else{
+        rc = sas_phy_reset(phy, 1);
+        msleep(2000);
+        }
+        PM8001_EH_DBG(pm8001_ha, pm8001_printk(" for device[%x]:rc=%d\n",
+                pm8001_dev->device_id, rc));
+        return rc;
+}
+
+/* mandatory SAM-3, the task reset the specified LUN*/
+int pm8001_lu_reset(struct domain_device *dev, u8 *lun)
+{
+        int rc = TMF_RESP_FUNC_FAILED;
+        struct pm8001_tmf_task tmf_task;
+        struct pm8001_device *pm8001_dev = dev->lldd_dev;
+        struct pm8001_hba_info *pm8001_ha = pm8001_find_ha_by_dev(dev);
+        if (dev_is_sata(dev)) {
+                struct sas_phy *phy = sas_find_local_phy(dev);
+                rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
+                        dev, 1, 0);
+                rc = sas_phy_reset(phy, 1);
+                rc = PM8001_CHIP_DISP->set_dev_state_req(pm8001_ha,
+                        pm8001_dev, 0x01);
+                msleep(2000);
+        } else {
+                tmf_task.tmf = TMF_LU_RESET;
+                rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
+        }
+        /* If failed, fall-through I_T_Nexus reset */
+        PM8001_EH_DBG(pm8001_ha, pm8001_printk("for device[%x]:rc=%d\n",
+                pm8001_dev->device_id, rc));
+        return rc;
+}
+
+/* optional SAM-3 */
+int pm8001_query_task(struct sas_task *task)
+{
+        u32 tag = 0xdeadbeef;
+        int i = 0;
+        struct scsi_lun lun;
+        struct pm8001_tmf_task tmf_task;
+        int rc = TMF_RESP_FUNC_FAILED;
+        if (unlikely(!task || !task->lldd_task || !task->dev))
+                return rc;
+
+        if (task->task_proto & SAS_PROTOCOL_SSP) {
+                struct scsi_cmnd *cmnd = task->uldd_task;
+                struct domain_device *dev = task->dev;
+                struct pm8001_hba_info *pm8001_ha =
+                        pm8001_find_ha_by_dev(dev);
+
+                int_to_scsilun(cmnd->device->lun, &lun);
+                rc = pm8001_find_tag(task, &tag);
+                if (rc == 0) {
+                        rc = TMF_RESP_FUNC_FAILED;
+                        return rc;
+                }
+                PM8001_EH_DBG(pm8001_ha, pm8001_printk("Query:["));
+                for (i = 0; i < 16; i++)
+                        printk(KERN_INFO "%02x ", cmnd->cmnd[i]);
+                printk(KERN_INFO "]\n");
+                tmf_task.tmf =  TMF_QUERY_TASK;
+                tmf_task.tag_of_task_to_be_managed = tag;
+
+                rc = pm8001_issue_ssp_tmf(dev, lun.scsi_lun, &tmf_task);
+                switch (rc) {
+                /* The task is still in Lun, release it then */
+                case TMF_RESP_FUNC_SUCC:
+                        PM8001_EH_DBG(pm8001_ha,
+                                pm8001_printk("The task is still in Lun \n"));
+                /* The task is not in Lun or failed, reset the phy */
+                case TMF_RESP_FUNC_FAILED:
+                case TMF_RESP_FUNC_COMPLETE:
+                        PM8001_EH_DBG(pm8001_ha,
+                        pm8001_printk("The task is not in Lun or failed,"
+                        " reset the phy \n"));
+                        break;
+                }
+        }
+        pm8001_printk(":rc= %d\n", rc);
+        return rc;
+}
+
+/*  mandatory SAM-3, still need free task/ccb info, abord the specified task */
+int pm8001_abort_task(struct sas_task *task)
+{
+        unsigned long flags;
+        u32 tag = 0xdeadbeef;
+        u32 device_id;
+        struct domain_device *dev ;
+        struct pm8001_hba_info *pm8001_ha = NULL;
+        struct pm8001_ccb_info *ccb;
+        struct scsi_lun lun;
+        struct pm8001_device *pm8001_dev;
+        struct pm8001_tmf_task tmf_task;
+        int rc = TMF_RESP_FUNC_FAILED;
+        if (unlikely(!task || !task->lldd_task || !task->dev))
+                return rc;
+        spin_lock_irqsave(&task->task_state_lock, flags);
+        if (task->task_state_flags & SAS_TASK_STATE_DONE) {
+                spin_unlock_irqrestore(&task->task_state_lock, flags);
+                rc = TMF_RESP_FUNC_COMPLETE;
+                goto out;
+        }
+        spin_unlock_irqrestore(&task->task_state_lock, flags);
+        if (task->task_proto & SAS_PROTOCOL_SSP) {
+                struct scsi_cmnd *cmnd = task->uldd_task;
+                dev = task->dev;
+                ccb = task->lldd_task;
+                pm8001_dev = dev->lldd_dev;
+                pm8001_ha = pm8001_find_ha_by_dev(dev);
+                int_to_scsilun(cmnd->device->lun, &lun);
+                rc = pm8001_find_tag(task, &tag);
+                if (rc == 0) {
+                        printk(KERN_INFO "No such tag in %s\n", __func__);
+                        rc = TMF_RESP_FUNC_FAILED;
+                        return rc;
+                }
+                device_id = pm8001_dev->device_id;
+                PM8001_EH_DBG(pm8001_ha,
+                        pm8001_printk("abort io to deviceid= %d\n", device_id));
+                tmf_task.tmf = TMF_ABORT_TASK;
+                tmf_task.tag_of_task_to_be_managed = tag;
+                rc = pm8001_issue_ssp_tmf(dev, lun.scsi_lun, &tmf_task);
+                pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
+                        pm8001_dev->sas_device, 0, tag);
+        } else if (task->task_proto & SAS_PROTOCOL_SATA ||
+                task->task_proto & SAS_PROTOCOL_STP) {
+                dev = task->dev;
+                pm8001_dev = dev->lldd_dev;
+                pm8001_ha = pm8001_find_ha_by_dev(dev);
+                rc = pm8001_find_tag(task, &tag);
+                if (rc == 0) {
+                        printk(KERN_INFO "No such tag in %s\n", __func__);
+                        rc = TMF_RESP_FUNC_FAILED;
+                        return rc;
+                }
+                rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
+                        pm8001_dev->sas_device, 0, tag);
+        } else if (task->task_proto & SAS_PROTOCOL_SMP) {
+                /* SMP */
+                dev = task->dev;
+                pm8001_dev = dev->lldd_dev;
+                pm8001_ha = pm8001_find_ha_by_dev(dev);
+                rc = pm8001_find_tag(task, &tag);
+                if (rc == 0) {
+                        printk(KERN_INFO "No such tag in %s\n", __func__);
+                        rc = TMF_RESP_FUNC_FAILED;
+                        return rc;
+                }
+                rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev,
+                        pm8001_dev->sas_device, 0, tag);
+
+        }
+out:
+        if (rc != TMF_RESP_FUNC_COMPLETE)
+                pm8001_printk("rc= %d\n", rc);
+        return rc;
+}
+
+int pm8001_abort_task_set(struct domain_device *dev, u8 *lun)
+{
+        int rc = TMF_RESP_FUNC_FAILED;
+        struct pm8001_tmf_task tmf_task;
+
+        tmf_task.tmf = TMF_ABORT_TASK_SET;
+        rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
+        return rc;
+}
+
+int pm8001_clear_aca(struct domain_device *dev, u8 *lun)
+{
+        int rc = TMF_RESP_FUNC_FAILED;
+        struct pm8001_tmf_task tmf_task;
+
+        tmf_task.tmf = TMF_CLEAR_ACA;
+        rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
+
+        return rc;
+}
+
+int pm8001_clear_task_set(struct domain_device *dev, u8 *lun)
+{
+        int rc = TMF_RESP_FUNC_FAILED;
+        struct pm8001_tmf_task tmf_task;
+        struct pm8001_device *pm8001_dev = dev->lldd_dev;
+        struct pm8001_hba_info *pm8001_ha = pm8001_find_ha_by_dev(dev);
+
+        PM8001_EH_DBG(pm8001_ha,
+                pm8001_printk("I_T_L_Q clear task set[%x]\n",
+                pm8001_dev->device_id));
+        tmf_task.tmf = TMF_CLEAR_TASK_SET;
+        rc = pm8001_issue_ssp_tmf(dev, lun, &tmf_task);
+        return rc;
+}
+
diff --git a/drivers/scsi/pm8001/pm8001_sas.h b/drivers/scsi/pm8001/pm8001_sas.h
new file mode 100644
index 000000000000..8e38ca8cd101
--- /dev/null
+++ b/drivers/scsi/pm8001/pm8001_sas.h
@@ -0,0 +1,497 @@
+/*
+ * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
+ *
+ * Copyright (c) 2008-2009 USI Co., Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ */
+
+#ifndef _PM8001_SAS_H_
+#define _PM8001_SAS_H_
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/spinlock.h>
+#include <linux/delay.h>
+#include <linux/types.h>
+#include <linux/ctype.h>
+#include <linux/dma-mapping.h>
+#include <linux/pci.h>
+#include <linux/interrupt.h>
+#include <linux/smp_lock.h>
+#include <scsi/libsas.h>
+#include <scsi/scsi_tcq.h>
+#include <scsi/sas_ata.h>
+#include <asm/atomic.h>
+#include "pm8001_defs.h"
+
+#define DRV_NAME                "pm8001"
+#define DRV_VERSION             "0.1.36"
+#define PM8001_FAIL_LOGGING     0x01 /* Error message logging */
+#define PM8001_INIT_LOGGING     0x02 /* driver init logging */
+#define PM8001_DISC_LOGGING     0x04 /* discovery layer logging */
+#define PM8001_IO_LOGGING       0x08 /* I/O path logging */
+#define PM8001_EH_LOGGING       0x10 /* libsas EH function logging*/
+#define PM8001_IOCTL_LOGGING    0x20 /* IOCTL message logging */
+#define PM8001_MSG_LOGGING      0x40 /* misc message logging */
+#define pm8001_printk(format, arg...)   printk(KERN_INFO "%s %d:" format,\
+                                __func__, __LINE__, ## arg)
+#define PM8001_CHECK_LOGGING(HBA, LEVEL, CMD)   \
+do {                                            \
+        if (unlikely(HBA->logging_level & LEVEL))       \
+                do {                                    \
+                        CMD;                            \
+                } while (0);                            \
+} while (0);
+
+#define PM8001_EH_DBG(HBA, CMD)                 \
+        PM8001_CHECK_LOGGING(HBA, PM8001_EH_LOGGING, CMD)
+
+#define PM8001_INIT_DBG(HBA, CMD)               \
+        PM8001_CHECK_LOGGING(HBA, PM8001_INIT_LOGGING, CMD)
+
+#define PM8001_DISC_DBG(HBA, CMD)               \
+        PM8001_CHECK_LOGGING(HBA, PM8001_DISC_LOGGING, CMD)
+
+#define PM8001_IO_DBG(HBA, CMD)         \
+        PM8001_CHECK_LOGGING(HBA, PM8001_IO_LOGGING, CMD)
+
+#define PM8001_FAIL_DBG(HBA, CMD)               \
+        PM8001_CHECK_LOGGING(HBA, PM8001_FAIL_LOGGING, CMD)
+
+#define PM8001_IOCTL_DBG(HBA, CMD)              \
+        PM8001_CHECK_LOGGING(HBA, PM8001_IOCTL_LOGGING, CMD)
+
+#define PM8001_MSG_DBG(HBA, CMD)                \
+        PM8001_CHECK_LOGGING(HBA, PM8001_MSG_LOGGING, CMD)
+
+
+#define PM8001_USE_TASKLET
+#define PM8001_USE_MSIX
+#define PM8001_READ_VPD
+
+
+#define DEV_IS_EXPANDER(type)   ((type == EDGE_DEV) || (type == FANOUT_DEV))
+
+#define PM8001_NAME_LENGTH              32/* generic length of strings */
+extern struct list_head hba_list;
+extern const struct pm8001_dispatch pm8001_8001_dispatch;
+
+struct pm8001_hba_info;
+struct pm8001_ccb_info;
+struct pm8001_device;
+/* define task management IU */
+struct pm8001_tmf_task {
+        u8      tmf;
+        u32     tag_of_task_to_be_managed;
+};
+struct pm8001_ioctl_payload {
+        u32     signature;
+        u16     major_function;
+        u16     minor_function;
+        u16     length;
+        u16     status;
+        u16     offset;
+        u16     id;
+        u8      *func_specific;
+};
+
+struct pm8001_dispatch {
+        char *name;
+        int (*chip_init)(struct pm8001_hba_info *pm8001_ha);
+        int (*chip_soft_rst)(struct pm8001_hba_info *pm8001_ha, u32 signature);
+        void (*chip_rst)(struct pm8001_hba_info *pm8001_ha);
+        int (*chip_ioremap)(struct pm8001_hba_info *pm8001_ha);
+        void (*chip_iounmap)(struct pm8001_hba_info *pm8001_ha);
+        irqreturn_t (*isr)(struct pm8001_hba_info *pm8001_ha);
+        u32 (*is_our_interupt)(struct pm8001_hba_info *pm8001_ha);
+        int (*isr_process_oq)(struct pm8001_hba_info *pm8001_ha);
+        void (*interrupt_enable)(struct pm8001_hba_info *pm8001_ha);
+        void (*interrupt_disable)(struct pm8001_hba_info *pm8001_ha);
+        void (*make_prd)(struct scatterlist *scatter, int nr, void *prd);
+        int (*smp_req)(struct pm8001_hba_info *pm8001_ha,
+                struct pm8001_ccb_info *ccb);
+        int (*ssp_io_req)(struct pm8001_hba_info *pm8001_ha,
+                struct pm8001_ccb_info *ccb);
+        int (*sata_req)(struct pm8001_hba_info *pm8001_ha,
+                struct pm8001_ccb_info *ccb);
+        int (*phy_start_req)(struct pm8001_hba_info *pm8001_ha, u8 phy_id);
+        int (*phy_stop_req)(struct pm8001_hba_info *pm8001_ha, u8 phy_id);
+        int (*reg_dev_req)(struct pm8001_hba_info *pm8001_ha,
+                struct pm8001_device *pm8001_dev, u32 flag);
+        int (*dereg_dev_req)(struct pm8001_hba_info *pm8001_ha, u32 device_id);
+        int (*phy_ctl_req)(struct pm8001_hba_info *pm8001_ha,
+                u32 phy_id, u32 phy_op);
+        int (*task_abort)(struct pm8001_hba_info *pm8001_ha,
+                struct pm8001_device *pm8001_dev, u8 flag, u32 task_tag,
+                u32 cmd_tag);
+        int (*ssp_tm_req)(struct pm8001_hba_info *pm8001_ha,
+                struct pm8001_ccb_info *ccb, struct pm8001_tmf_task *tmf);
+        int (*get_nvmd_req)(struct pm8001_hba_info *pm8001_ha, void *payload);
+        int (*set_nvmd_req)(struct pm8001_hba_info *pm8001_ha, void *payload);
+        int (*fw_flash_update_req)(struct pm8001_hba_info *pm8001_ha,
+                void *payload);
+        int (*set_dev_state_req)(struct pm8001_hba_info *pm8001_ha,
+                struct pm8001_device *pm8001_dev, u32 state);
+        int (*sas_diag_start_end_req)(struct pm8001_hba_info *pm8001_ha,
+                u32 state);
+        int (*sas_diag_execute_req)(struct pm8001_hba_info *pm8001_ha,
+                u32 state);
+        int (*sas_re_init_req)(struct pm8001_hba_info *pm8001_ha);
+};
+
+struct pm8001_chip_info {
+        u32     n_phy;
+        const struct pm8001_dispatch    *dispatch;
+};
+#define PM8001_CHIP_DISP        (pm8001_ha->chip->dispatch)
+
+struct pm8001_port {
+        struct asd_sas_port     sas_port;
+        u8                      port_attached;
+        u8                      wide_port_phymap;
+        u8                      port_state;
+        struct list_head        list;
+};
+
+struct pm8001_phy {
+        struct pm8001_hba_info  *pm8001_ha;
+        struct pm8001_port      *port;
+        struct asd_sas_phy      sas_phy;
+        struct sas_identify     identify;
+        struct scsi_device      *sdev;
+        u64                     dev_sas_addr;
+        u32                     phy_type;
+        struct completion       *enable_completion;
+        u32                     frame_rcvd_size;
+        u8                      frame_rcvd[32];
+        u8                      phy_attached;
+        u8                      phy_state;
+        enum sas_linkrate       minimum_linkrate;
+        enum sas_linkrate       maximum_linkrate;
+};
+
+struct pm8001_device {
+        enum sas_dev_type       dev_type;
+        struct domain_device    *sas_device;
+        u32                     attached_phy;
+        u32                     id;
+        struct completion       *dcompletion;
+        struct completion       *setds_completion;
+        u32                     device_id;
+        u32                     running_req;
+};
+
+struct pm8001_prd_imt {
+        __le32                  len;
+        __le32                  e;
+};
+
+struct pm8001_prd {
+        __le64                  addr;           /* 64-bit buffer address */
+        struct pm8001_prd_imt   im_len;         /* 64-bit length */
+} __attribute__ ((packed));
+/*
+ * CCB(Command Control Block)
+ */
+struct pm8001_ccb_info {
+        struct list_head        entry;
+        struct sas_task         *task;
+        u32                     n_elem;
+        u32                     ccb_tag;
+        dma_addr_t              ccb_dma_handle;
+        struct pm8001_device    *device;
+        struct pm8001_prd       buf_prd[PM8001_MAX_DMA_SG];
+        struct fw_control_ex    *fw_control_context;
+};
+
+struct mpi_mem {
+        void                    *virt_ptr;
+        dma_addr_t              phys_addr;
+        u32                     phys_addr_hi;
+        u32                     phys_addr_lo;
+        u32                     total_len;
+        u32                     num_elements;
+        u32                     element_size;
+        u32                     alignment;
+};
+
+struct mpi_mem_req {
+        /* The number of element in the  mpiMemory array */
+        u32                     count;
+        /* The array of structures that define memroy regions*/
+        struct mpi_mem          region[USI_MAX_MEMCNT];
+};
+
+struct main_cfg_table {
+        u32                     signature;
+        u32                     interface_rev;
+        u32                     firmware_rev;
+        u32                     max_out_io;
+        u32                     max_sgl;
+        u32                     ctrl_cap_flag;
+        u32                     gst_offset;
+        u32                     inbound_queue_offset;
+        u32                     outbound_queue_offset;
+        u32                     inbound_q_nppd_hppd;
+        u32                     outbound_hw_event_pid0_3;
+        u32                     outbound_hw_event_pid4_7;
+        u32                     outbound_ncq_event_pid0_3;
+        u32                     outbound_ncq_event_pid4_7;
+        u32                     outbound_tgt_ITNexus_event_pid0_3;
+        u32                     outbound_tgt_ITNexus_event_pid4_7;
+        u32                     outbound_tgt_ssp_event_pid0_3;
+        u32                     outbound_tgt_ssp_event_pid4_7;
+        u32                     outbound_tgt_smp_event_pid0_3;
+        u32                     outbound_tgt_smp_event_pid4_7;
+        u32                     upper_event_log_addr;
+        u32                     lower_event_log_addr;
+        u32                     event_log_size;
+        u32                     event_log_option;
+        u32                     upper_iop_event_log_addr;
+        u32                     lower_iop_event_log_addr;
+        u32                     iop_event_log_size;
+        u32                     iop_event_log_option;
+        u32                     fatal_err_interrupt;
+        u32                     fatal_err_dump_offset0;
+        u32                     fatal_err_dump_length0;
+        u32                     fatal_err_dump_offset1;
+        u32                     fatal_err_dump_length1;
+        u32                     hda_mode_flag;
+        u32                     anolog_setup_table_offset;
+};
+struct general_status_table {
+        u32                     gst_len_mpistate;
+        u32                     iq_freeze_state0;
+        u32                     iq_freeze_state1;
+        u32                     msgu_tcnt;
+        u32                     iop_tcnt;
+        u32                     reserved;
+        u32                     phy_state[8];
+        u32                     reserved1;
+        u32                     reserved2;
+        u32                     reserved3;
+        u32                     recover_err_info[8];
+};
+struct inbound_queue_table {
+        u32                     element_pri_size_cnt;
+        u32                     upper_base_addr;
+        u32                     lower_base_addr;
+        u32                     ci_upper_base_addr;
+        u32                     ci_lower_base_addr;
+        u32                     pi_pci_bar;
+        u32                     pi_offset;
+        u32                     total_length;
+        void                    *base_virt;
+        void                    *ci_virt;
+        u32                     reserved;
+        __le32                  consumer_index;
+        u32                     producer_idx;
+};
+struct outbound_queue_table {
+        u32                     element_size_cnt;
+        u32                     upper_base_addr;
+        u32                     lower_base_addr;
+        void                    *base_virt;
+        u32                     pi_upper_base_addr;
+        u32                     pi_lower_base_addr;
+        u32                     ci_pci_bar;
+        u32                     ci_offset;
+        u32                     total_length;
+        void                    *pi_virt;
+        u32                     interrup_vec_cnt_delay;
+        u32                     dinterrup_to_pci_offset;
+        __le32                  producer_index;
+        u32                     consumer_idx;
+};
+struct pm8001_hba_memspace {
+        void __iomem            *memvirtaddr;
+        u64                     membase;
+        u32                     memsize;
+};
+struct pm8001_hba_info {
+        char                    name[PM8001_NAME_LENGTH];
+        struct list_head        list;
+        unsigned long           flags;
+        spinlock_t              lock;/* host-wide lock */
+        struct pci_dev          *pdev;/* our device */
+        struct device           *dev;
+        struct pm8001_hba_memspace io_mem[6];
+        struct mpi_mem_req      memoryMap;
+        void __iomem    *msg_unit_tbl_addr;/*Message Unit Table Addr*/
+        void __iomem    *main_cfg_tbl_addr;/*Main Config Table Addr*/
+        void __iomem    *general_stat_tbl_addr;/*General Status Table Addr*/
+        void __iomem    *inbnd_q_tbl_addr;/*Inbound Queue Config Table Addr*/
+        void __iomem    *outbnd_q_tbl_addr;/*Outbound Queue Config Table Addr*/
+        struct main_cfg_table   main_cfg_tbl;
+        struct general_status_table     gs_tbl;
+        struct inbound_queue_table      inbnd_q_tbl[PM8001_MAX_INB_NUM];
+        struct outbound_queue_table     outbnd_q_tbl[PM8001_MAX_OUTB_NUM];
+        u8                      sas_addr[SAS_ADDR_SIZE];
+        struct sas_ha_struct    *sas;/* SCSI/SAS glue */
+        struct Scsi_Host        *shost;
+        u32                     chip_id;
+        const struct pm8001_chip_info   *chip;
+        struct completion       *nvmd_completion;
+        int                     tags_num;
+        unsigned long           *tags;
+        struct pm8001_phy       phy[PM8001_MAX_PHYS];
+        struct pm8001_port      port[PM8001_MAX_PHYS];
+        u32                     id;
+        u32                     irq;
+        struct pm8001_device    *devices;
+        struct pm8001_ccb_info  *ccb_info;
+#ifdef PM8001_USE_MSIX
+        struct msix_entry       msix_entries[16];/*for msi-x interrupt*/
+        int                     number_of_intr;/*will be used in remove()*/
+#endif
+#ifdef PM8001_USE_TASKLET
+        struct tasklet_struct   tasklet;
+#endif
+        struct list_head        wq_list;
+        u32                     logging_level;
+        u32                     fw_status;
+        const struct firmware   *fw_image;
+};
+
+struct pm8001_wq {
+        struct delayed_work work_q;
+        struct pm8001_hba_info *pm8001_ha;
+        void *data;
+        int handler;
+        struct list_head entry;
+};
+
+struct pm8001_fw_image_header {
+        u8 vender_id[8];
+        u8 product_id;
+        u8 hardware_rev;
+        u8 dest_partition;
+        u8 reserved;
+        u8 fw_rev[4];
+        __be32  image_length;
+        __be32 image_crc;
+        __be32 startup_entry;
+} __attribute__((packed, aligned(4)));
+
+
+/**
+ * FW Flash Update status values
+ */
+#define FLASH_UPDATE_COMPLETE_PENDING_REBOOT    0x00
+#define FLASH_UPDATE_IN_PROGRESS                0x01
+#define FLASH_UPDATE_HDR_ERR                    0x02
+#define FLASH_UPDATE_OFFSET_ERR                 0x03
+#define FLASH_UPDATE_CRC_ERR                    0x04
+#define FLASH_UPDATE_LENGTH_ERR                 0x05
+#define FLASH_UPDATE_HW_ERR                     0x06
+#define FLASH_UPDATE_DNLD_NOT_SUPPORTED         0x10
+#define FLASH_UPDATE_DISABLED                   0x11
+
+/**
+ * brief param structure for firmware flash update.
+ */
+struct fw_flash_updata_info {
+        u32                     cur_image_offset;
+        u32                     cur_image_len;
+        u32                     total_image_len;
+        struct pm8001_prd       sgl;
+};
+
+struct fw_control_info {
+        u32                     retcode;/*ret code (status)*/
+        u32                     phase;/*ret code phase*/
+        u32                     phaseCmplt;/*percent complete for the current
+        update phase */
+        u32                     version;/*Hex encoded firmware version number*/
+        u32                     offset;/*Used for downloading firmware  */
+        u32                     len; /*len of buffer*/
+        u32                     size;/* Used in OS VPD and Trace get size
+        operations.*/
+        u32                     reserved;/* padding required for 64 bit
+        alignment */
+        u8                      buffer[1];/* Start of buffer */
+};
+struct fw_control_ex {
+        struct fw_control_info *fw_control;
+        void                    *buffer;/* keep buffer pointer to be
+        freed when the responce comes*/
+        void                    *virtAddr;/* keep virtual address of the data */
+        void                    *usrAddr;/* keep virtual address of the
+        user data */
+        dma_addr_t              phys_addr;
+        u32                     len; /* len of buffer  */
+        void                    *payload; /* pointer to IOCTL Payload */
+        u8                      inProgress;/*if 1 - the IOCTL request is in
+        progress */
+        void                    *param1;
+        void                    *param2;
+        void                    *param3;
+};
+
+/******************** function prototype *********************/
+int pm8001_tag_alloc(struct pm8001_hba_info *pm8001_ha, u32 *tag_out);
+void pm8001_tag_init(struct pm8001_hba_info *pm8001_ha);
+u32 pm8001_get_ncq_tag(struct sas_task *task, u32 *tag);
+void pm8001_ccb_free(struct pm8001_hba_info *pm8001_ha, u32 ccb_idx);
+void pm8001_ccb_task_free(struct pm8001_hba_info *pm8001_ha,
+        struct sas_task *task, struct pm8001_ccb_info *ccb, u32 ccb_idx);
+int pm8001_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func,
+        void *funcdata);
+int pm8001_slave_alloc(struct scsi_device *scsi_dev);
+int pm8001_slave_configure(struct scsi_device *sdev);
+void pm8001_scan_start(struct Scsi_Host *shost);
+int pm8001_scan_finished(struct Scsi_Host *shost, unsigned long time);
+int pm8001_queue_command(struct sas_task *task, const int num,
+        gfp_t gfp_flags);
+int pm8001_abort_task(struct sas_task *task);
+int pm8001_abort_task_set(struct domain_device *dev, u8 *lun);
+int pm8001_clear_aca(struct domain_device *dev, u8 *lun);
+int pm8001_clear_task_set(struct domain_device *dev, u8 *lun);
+int pm8001_dev_found(struct domain_device *dev);
+void pm8001_dev_gone(struct domain_device *dev);
+int pm8001_lu_reset(struct domain_device *dev, u8 *lun);
+int pm8001_I_T_nexus_reset(struct domain_device *dev);
+int pm8001_query_task(struct sas_task *task);
+int pm8001_mem_alloc(struct pci_dev *pdev, void **virt_addr,
+        dma_addr_t *pphys_addr, u32 *pphys_addr_hi, u32 *pphys_addr_lo,
+        u32 mem_size, u32 align);
+
+
+/* ctl shared API */
+extern struct device_attribute *pm8001_host_attrs[];
+
+#endif
+
diff --git a/drivers/scsi/pmcraid.c b/drivers/scsi/pmcraid.c
index 0a97bc9074bb..53aefffbaead 100644
--- a/drivers/scsi/pmcraid.c
+++ b/drivers/scsi/pmcraid.c
@@ -1,7 +1,8 @@
 /*
  * pmcraid.c -- driver for PMC Sierra MaxRAID controller adapters
  *
- * Written By: PMC Sierra Corporation
+ * Written By: Anil Ravindranath<anil_ravindranath@pmc-sierra.com>
+ *             PMC-Sierra Inc
  *
  * Copyright (C) 2008, 2009 PMC Sierra Inc
  *
@@ -40,6 +41,7 @@
 #include <linux/hdreg.h>
 #include <linux/version.h>
 #include <linux/io.h>
+#include <linux/slab.h>
 #include <asm/irq.h>
 #include <asm/processor.h>
 #include <linux/libata.h>
@@ -79,7 +81,7 @@ DECLARE_BITMAP(pmcraid_minor, PMCRAID_MAX_ADAPTERS);
 /*
  * Module parameters
  */
-MODULE_AUTHOR("PMC Sierra Corporation, anil_ravindranath@pmc-sierra.com");
+MODULE_AUTHOR("Anil Ravindranath<anil_ravindranath@pmc-sierra.com>");
 MODULE_DESCRIPTION("PMC Sierra MaxRAID Controller Driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(PMCRAID_DRIVER_VERSION);
@@ -162,10 +164,10 @@ static int pmcraid_slave_alloc(struct scsi_device *scsi_dev)
         spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
         list_for_each_entry(temp, &pinstance->used_res_q, queue) {
 
-                /* do not expose VSETs with order-ids >= 240 */
+                /* do not expose VSETs with order-ids > MAX_VSET_TARGETS */
                 if (RES_IS_VSET(temp->cfg_entry)) {
                         target = temp->cfg_entry.unique_flags1;
-                        if (target >= PMCRAID_MAX_VSET_TARGETS)
+                        if (target > PMCRAID_MAX_VSET_TARGETS)
                                 continue;
                         bus = PMCRAID_VSET_BUS_ID;
                         lun = 0;
@@ -234,7 +236,7 @@ static int pmcraid_slave_configure(struct scsi_device *scsi_dev)
                 scsi_dev->allow_restart = 1;
                 blk_queue_rq_timeout(scsi_dev->request_queue,
                                      PMCRAID_VSET_IO_TIMEOUT);
-                blk_queue_max_sectors(scsi_dev->request_queue,
+                blk_queue_max_hw_sectors(scsi_dev->request_queue,
                                       PMCRAID_VSET_MAX_SECTORS);
         }
 
@@ -278,12 +280,17 @@ static void pmcraid_slave_destroy(struct scsi_device *scsi_dev)
  * pmcraid_change_queue_depth - Change the device's queue depth
  * @scsi_dev: scsi device struct
  * @depth: depth to set
+ * @reason: calling context
  *
  * Return value
  *      actual depth set
  */
-static int pmcraid_change_queue_depth(struct scsi_device *scsi_dev, int depth)
+static int pmcraid_change_queue_depth(struct scsi_device *scsi_dev, int depth,
+                                      int reason)
 {
+        if (reason != SCSI_QDEPTH_DEFAULT)
+                return -EOPNOTSUPP;
+
         if (depth > PMCRAID_MAX_CMD_PER_LUN)
                 depth = PMCRAID_MAX_CMD_PER_LUN;
 
@@ -1205,7 +1212,7 @@ static int pmcraid_expose_resource(struct pmcraid_config_table_entry *cfgte)
         int retval = 0;
 
         if (cfgte->resource_type == RES_TYPE_VSET)
-                retval = ((cfgte->unique_flags1 & 0xFF) < 0xFE);
+                retval = ((cfgte->unique_flags1 & 0x80) == 0);
         else if (cfgte->resource_type == RES_TYPE_GSCSI)
                 retval = (RES_BUS(cfgte->resource_address) !=
                                 PMCRAID_VIRTUAL_ENCL_BUS_ID);
@@ -1356,6 +1363,7 @@ static int pmcraid_notify_aen(struct pmcraid_instance *pinstance, u8 type)
  * Return value:
  *  none
  */
+
 static void pmcraid_handle_config_change(struct pmcraid_instance *pinstance)
 {
         struct pmcraid_config_table_entry *cfg_entry;
@@ -1363,9 +1371,10 @@ static void pmcraid_handle_config_change(struct pmcraid_instance *pinstance)
         struct pmcraid_cmd *cmd;
         struct pmcraid_cmd *cfgcmd;
         struct pmcraid_resource_entry *res = NULL;
-        u32 new_entry = 1;
         unsigned long lock_flags;
         unsigned long host_lock_flags;
+        u32 new_entry = 1;
+        u32 hidden_entry = 0;
         int rc;
 
         ccn_hcam = (struct pmcraid_hcam_ccn *)pinstance->ccn.hcam;
@@ -1401,9 +1410,15 @@ static void pmcraid_handle_config_change(struct pmcraid_instance *pinstance)
         }
 
         /* If this resource is not going to be added to mid-layer, just notify
-         * applications and return
+         * applications and return. If this notification is about hiding a VSET
+         * resource, check if it was exposed already.
          */
-        if (!pmcraid_expose_resource(cfg_entry))
+        if (pinstance->ccn.hcam->notification_type ==
+            NOTIFICATION_TYPE_ENTRY_CHANGED &&
+            cfg_entry->resource_type == RES_TYPE_VSET &&
+            cfg_entry->unique_flags1 & 0x80) {
+                hidden_entry = 1;
+        } else if (!pmcraid_expose_resource(cfg_entry))
                 goto out_notify_apps;
 
         spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
@@ -1419,6 +1434,12 @@ static void pmcraid_handle_config_change(struct pmcraid_instance *pinstance)
 
         if (new_entry) {
 
+                if (hidden_entry) {
+                        spin_unlock_irqrestore(&pinstance->resource_lock,
+                                                lock_flags);
+                        goto out_notify_apps;
+                }
+
                 /* If there are more number of resources than what driver can
                  * manage, do not notify the applications about the CCN. Just
                  * ignore this notifications and re-register the same HCAM
@@ -1449,8 +1470,9 @@ static void pmcraid_handle_config_change(struct pmcraid_instance *pinstance)
                 sizeof(struct pmcraid_config_table_entry));
 
         if (pinstance->ccn.hcam->notification_type ==
-            NOTIFICATION_TYPE_ENTRY_DELETED) {
+            NOTIFICATION_TYPE_ENTRY_DELETED || hidden_entry) {
                 if (res->scsi_dev) {
+                        res->cfg_entry.unique_flags1 &= 0x7F;
                         res->change_detected = RES_CHANGE_DEL;
                         res->cfg_entry.resource_handle =
                                 PMCRAID_INVALID_RES_HANDLE;
@@ -2462,14 +2484,12 @@ static int pmcraid_error_handler(struct pmcraid_cmd *cmd)
                         sense_copied = 1;
                 }
 
-                if (RES_IS_GSCSI(res->cfg_entry)) {
+                if (RES_IS_GSCSI(res->cfg_entry))
                         pmcraid_cancel_all(cmd, sense_copied);
-                } else if (sense_copied) {
+                else if (sense_copied)
                         pmcraid_erp_done(cmd);
-                        return 0;
-                } else  {
+                else
                         pmcraid_request_sense(cmd);
-                }
 
                 return 1;
 
@@ -3342,7 +3362,7 @@ static int pmcraid_chr_fasync(int fd, struct file *filep, int mode)
  * @direction : data transfer direction
  *
  * Return value
- *  0 on sucess, non-zero error code on failure
+ *  0 on success, non-zero error code on failure
  */
 static int pmcraid_build_passthrough_ioadls(
         struct pmcraid_cmd *cmd,
@@ -3401,7 +3421,7 @@ static int pmcraid_build_passthrough_ioadls(
  * @direction: data transfer direction
  *
  * Return value
- *  0 on sucess, non-zero error code on failure
+ *  0 on success, non-zero error code on failure
  */
 static void pmcraid_release_passthrough_ioadls(
         struct pmcraid_cmd *cmd,
@@ -3429,7 +3449,7 @@ static void pmcraid_release_passthrough_ioadls(
  * @arg: pointer to pmcraid_passthrough_buffer user buffer
  *
  * Return value
- *  0 on sucess, non-zero error code on failure
+ *  0 on success, non-zero error code on failure
  */
 static long pmcraid_ioctl_passthrough(
         struct pmcraid_instance *pinstance,
diff --git a/drivers/scsi/pmcraid.h b/drivers/scsi/pmcraid.h
index 3441b3f90827..b8ad07c3449e 100644
--- a/drivers/scsi/pmcraid.h
+++ b/drivers/scsi/pmcraid.h
@@ -1,6 +1,9 @@
 /*
  * pmcraid.h -- PMC Sierra MaxRAID controller driver header file
  *
+ * Written By: Anil Ravindranath<anil_ravindranath@pmc-sierra.com>
+ *             PMC-Sierra Inc
+ *
  * Copyright (C) 2008, 2009 PMC Sierra Inc.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -106,7 +109,7 @@
 #define PMCRAID_VSET_LUN_ID                      0x0
 #define PMCRAID_PHYS_BUS_ID                      0x0
 #define PMCRAID_VIRTUAL_ENCL_BUS_ID              0x8
-#define PMCRAID_MAX_VSET_TARGETS                 240
+#define PMCRAID_MAX_VSET_TARGETS                 0x7F
 #define PMCRAID_MAX_VSET_LUNS_PER_TARGET         8
 
 #define PMCRAID_IOA_MAX_SECTORS                  32767
@@ -771,11 +774,11 @@ static struct pmcraid_ioasc_error pmcraid_ioasc_error_table[] = {
         {0x01180600, IOASC_LOG_LEVEL_MUST,
          "Recovered Error, soft media error, sector reassignment suggested"},
         {0x015D0000, IOASC_LOG_LEVEL_MUST,
-         "Recovered Error, failure prediction thresold exceeded"},
+         "Recovered Error, failure prediction threshold exceeded"},
         {0x015D9200, IOASC_LOG_LEVEL_MUST,
-         "Recovered Error, soft Cache Card Battery error thresold"},
+         "Recovered Error, soft Cache Card Battery error threshold"},
         {0x015D9200, IOASC_LOG_LEVEL_MUST,
-         "Recovered Error, soft Cache Card Battery error thresold"},
+         "Recovered Error, soft Cache Card Battery error threshold"},
         {0x02048000, IOASC_LOG_LEVEL_MUST,
          "Not Ready, IOA Reset Required"},
         {0x02408500, IOASC_LOG_LEVEL_MUST,
@@ -935,7 +938,7 @@ static struct pmcraid_ioasc_error pmcraid_ioasc_error_table[] = {
 
 /*
  * pmcraid_ioctl_header - definition of header structure that preceeds all the
- * buffers given as ioctl arguements.
+ * buffers given as ioctl arguments.
  *
  * .signature           : always ASCII string, "PMCRAID"
  * .reserved            : not used
diff --git a/drivers/scsi/ppa.c b/drivers/scsi/ppa.c
index 8aa0bd987e29..7bc2d796e403 100644
--- a/drivers/scsi/ppa.c
+++ b/drivers/scsi/ppa.c
@@ -10,6 +10,7 @@
 
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/blkdev.h>
 #include <linux/parport.h>
diff --git a/drivers/scsi/ps3rom.c b/drivers/scsi/ps3rom.c
index db90caf43f42..92ffbb510498 100644
--- a/drivers/scsi/ps3rom.c
+++ b/drivers/scsi/ps3rom.c
@@ -20,6 +20,7 @@
 
 #include <linux/cdrom.h>
 #include <linux/highmem.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index 8371d917a9a2..b8166ecfd0e3 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -17,9 +17,11 @@
 * General Public License for more details.
 *
 ******************************************************************************/
-#define QLA1280_VERSION      "3.27"
+#define QLA1280_VERSION      "3.27.1"
 /*****************************************************************************
     Revision History:
+    Rev  3.27.1, February 8, 2010, Michael Reed
+        - Retain firmware image for error recovery.
     Rev  3.27, February 10, 2009, Michael Reed
         - General code cleanup.
         - Improve error recovery.
@@ -346,7 +348,6 @@
 #include <linux/pci.h>
 #include <linux/proc_fs.h>
 #include <linux/stat.h>
-#include <linux/slab.h>
 #include <linux/pci_ids.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -538,9 +539,9 @@ __setup("qla1280=", qla1280_setup);
 /*****************************************/
 
 struct qla_boards {
-        unsigned char name[9];  /* Board ID String */
+        char *name;             /* Board ID String */
         int numPorts;           /* Number of SCSI ports */
-        char *fwname;           /* firmware name        */
+        int fw_index;           /* index into qla1280_fw_tbl for firmware */
 };
 
 /* NOTE: the last argument in each entry is used to index ql1280_board_tbl */
@@ -561,15 +562,30 @@ static struct pci_device_id qla1280_pci_tbl[] = {
 };
 MODULE_DEVICE_TABLE(pci, qla1280_pci_tbl);
 
+DEFINE_MUTEX(qla1280_firmware_mutex);
+
+struct qla_fw {
+        char *fwname;
+        const struct firmware *fw;
+};
+
+#define QL_NUM_FW_IMAGES 3
+
+struct qla_fw qla1280_fw_tbl[QL_NUM_FW_IMAGES] = {
+        {"qlogic/1040.bin",  NULL},     /* image 0 */
+        {"qlogic/1280.bin",  NULL},     /* image 1 */
+        {"qlogic/12160.bin", NULL},     /* image 2 */
+};
+
+/* NOTE: Order of boards in this table must match order in qla1280_pci_tbl */
 static struct qla_boards ql1280_board_tbl[] = {
-        /* Name ,  Number of ports, FW details */
-        {"QLA12160",    2, "qlogic/12160.bin"},
-        {"QLA1040",     1, "qlogic/1040.bin"},
-        {"QLA1080",     1, "qlogic/1280.bin"},
-        {"QLA1240",     2, "qlogic/1280.bin"},
-        {"QLA1280",     2, "qlogic/1280.bin"},
-        {"QLA10160",    1, "qlogic/12160.bin"},
-        {"        ",    0, "   "},
+        {.name = "QLA12160", .numPorts = 2, .fw_index = 2},
+        {.name = "QLA1040" , .numPorts = 1, .fw_index = 0},
+        {.name = "QLA1080" , .numPorts = 1, .fw_index = 1},
+        {.name = "QLA1240" , .numPorts = 2, .fw_index = 1},
+        {.name = "QLA1280" , .numPorts = 2, .fw_index = 1},
+        {.name = "QLA10160", .numPorts = 1, .fw_index = 2},
+        {.name = "        ", .numPorts = 0, .fw_index = -1},
 };
 
 static int qla1280_verbose = 1;
@@ -1512,6 +1528,63 @@ qla1280_initialize_adapter(struct scsi_qla_host *ha)
 }
 
 /*
+ * qla1280_request_firmware
+ *      Acquire firmware for chip.  Retain in memory
+ *      for error recovery.
+ *
+ * Input:
+ *      ha = adapter block pointer.
+ *
+ * Returns:
+ *      Pointer to firmware image or an error code
+ *      cast to pointer via ERR_PTR().
+ */
+static const struct firmware *
+qla1280_request_firmware(struct scsi_qla_host *ha)
+{
+        const struct firmware *fw;
+        int err;
+        int index;
+        char *fwname;
+
+        spin_unlock_irq(ha->host->host_lock);
+        mutex_lock(&qla1280_firmware_mutex);
+
+        index = ql1280_board_tbl[ha->devnum].fw_index;
+        fw = qla1280_fw_tbl[index].fw;
+        if (fw)
+                goto out;
+
+        fwname = qla1280_fw_tbl[index].fwname;
+        err = request_firmware(&fw, fwname, &ha->pdev->dev);
+
+        if (err) {
+                printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
+                       fwname, err);
+                fw = ERR_PTR(err);
+                goto unlock;
+        }
+        if ((fw->size % 2) || (fw->size < 6)) {
+                printk(KERN_ERR "Invalid firmware length %zu in image \"%s\"\n",
+                       fw->size, fwname);
+                release_firmware(fw);
+                fw = ERR_PTR(-EINVAL);
+                goto unlock;
+        }
+
+        qla1280_fw_tbl[index].fw = fw;
+
+ out:
+        ha->fwver1 = fw->data[0];
+        ha->fwver2 = fw->data[1];
+        ha->fwver3 = fw->data[2];
+ unlock:
+        mutex_unlock(&qla1280_firmware_mutex);
+        spin_lock_irq(ha->host->host_lock);
+        return fw;
+}
+
+/*
  * Chip diagnostics
  *      Test chip for proper operation.
  *
@@ -1634,28 +1707,18 @@ qla1280_chip_diag(struct scsi_qla_host *ha)
 static int
 qla1280_load_firmware_pio(struct scsi_qla_host *ha)
 {
+        /* enter with host_lock acquired */
+
         const struct firmware *fw;
         const __le16 *fw_data;
         uint16_t risc_address, risc_code_size;
         uint16_t mb[MAILBOX_REGISTER_COUNT], i;
-        int err;
+        int err = 0;
+
+        fw = qla1280_request_firmware(ha);
+        if (IS_ERR(fw))
+                return PTR_ERR(fw);
 
-        err = request_firmware(&fw, ql1280_board_tbl[ha->devnum].fwname,
-                               &ha->pdev->dev);
-        if (err) {
-                printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
-                       ql1280_board_tbl[ha->devnum].fwname, err);
-                return err;
-        }
-        if ((fw->size % 2) || (fw->size < 6)) {
-                printk(KERN_ERR "Bogus length %zu in image \"%s\"\n",
-                       fw->size, ql1280_board_tbl[ha->devnum].fwname);
-                err = -EINVAL;
-                goto out;
-        }
-        ha->fwver1 = fw->data[0];
-        ha->fwver2 = fw->data[1];
-        ha->fwver3 = fw->data[2];
         fw_data = (const __le16 *)&fw->data[0];
         ha->fwstart = __le16_to_cpu(fw_data[2]);
 
@@ -1673,11 +1736,10 @@ qla1280_load_firmware_pio(struct scsi_qla_host *ha)
                 if (err) {
                         printk(KERN_ERR "scsi(%li): Failed to load firmware\n",
                                         ha->host_no);
-                        goto out;
+                        break;
                 }
         }
-out:
-        release_firmware(fw);
+
         return err;
 }
 
@@ -1685,6 +1747,7 @@ out:
 static int
 qla1280_load_firmware_dma(struct scsi_qla_host *ha)
 {
+        /* enter with host_lock acquired */
         const struct firmware *fw;
         const __le16 *fw_data;
         uint16_t risc_address, risc_code_size;
@@ -1699,22 +1762,10 @@ qla1280_load_firmware_dma(struct scsi_qla_host *ha)
                 return -ENOMEM;
 #endif
 
-        err = request_firmware(&fw, ql1280_board_tbl[ha->devnum].fwname,
-                               &ha->pdev->dev);
-        if (err) {
-                printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
-                       ql1280_board_tbl[ha->devnum].fwname, err);
-                return err;
-        }
-        if ((fw->size % 2) || (fw->size < 6)) {
-                printk(KERN_ERR "Bogus length %zu in image \"%s\"\n",
-                       fw->size, ql1280_board_tbl[ha->devnum].fwname);
-                err = -EINVAL;
-                goto out;
-        }
-        ha->fwver1 = fw->data[0];
-        ha->fwver2 = fw->data[1];
-        ha->fwver3 = fw->data[2];
+        fw = qla1280_request_firmware(ha);
+        if (IS_ERR(fw))
+                return PTR_ERR(fw);
+
         fw_data = (const __le16 *)&fw->data[0];
         ha->fwstart = __le16_to_cpu(fw_data[2]);
 
@@ -1799,7 +1850,6 @@ qla1280_load_firmware_dma(struct scsi_qla_host *ha)
 #if DUMP_IT_BACK
         pci_free_consistent(ha->pdev, 8000, tbuf, p_tbuf);
 #endif
-        release_firmware(fw);
         return err;
 }
 
@@ -1838,6 +1888,7 @@ qla1280_start_firmware(struct scsi_qla_host *ha)
 static int
 qla1280_load_firmware(struct scsi_qla_host *ha)
 {
+        /* enter with host_lock taken */
         int err;
 
         err = qla1280_chip_diag(ha);
@@ -4416,7 +4467,16 @@ qla1280_init(void)
 static void __exit
 qla1280_exit(void)
 {
+        int i;
+
         pci_unregister_driver(&qla1280_pci_driver);
+        /* release any allocated firmware images */
+        for (i = 0; i < QL_NUM_FW_IMAGES; i++) {
+                if (qla1280_fw_tbl[i].fw) {
+                        release_firmware(qla1280_fw_tbl[i].fw);
+                        qla1280_fw_tbl[i].fw = NULL;
+                }
+        }
 }
 
 module_init(qla1280_init);
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index fbcb82a2f7f4..1c7ef55966fb 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -8,10 +8,13 @@
 
 #include <linux/kthread.h>
 #include <linux/vmalloc.h>
+#include <linux/slab.h>
 #include <linux/delay.h>
 
 static int qla24xx_vport_disable(struct fc_vport *, bool);
-
+static int qla84xx_reset(scsi_qla_host_t *, struct msg_echo_lb *, struct fc_bsg_job *);
+int qla84xx_reset_chip(scsi_qla_host_t *, uint16_t, uint16_t *);
+static int qla84xx_mgmt_cmd(scsi_qla_host_t *, struct msg_echo_lb *, struct fc_bsg_job *);
 /* SYSFS attributes --------------------------------------------------------- */
 
 static ssize_t
@@ -232,6 +235,9 @@ qla2x00_sysfs_write_optrom_ctl(struct kobject *kobj,
         if (off)
                 return 0;
 
+        if (unlikely(pci_channel_offline(ha->pdev)))
+                return 0;
+
         if (sscanf(buf, "%d:%x:%x", &val, &start, &size) < 1)
                 return -EINVAL;
         if (start > ha->optrom_size)
@@ -379,6 +385,9 @@ qla2x00_sysfs_read_vpd(struct kobject *kobj,
             struct device, kobj)));
         struct qla_hw_data *ha = vha->hw;
 
+        if (unlikely(pci_channel_offline(ha->pdev)))
+                return 0;
+
         if (!capable(CAP_SYS_ADMIN))
                 return 0;
 
@@ -398,6 +407,9 @@ qla2x00_sysfs_write_vpd(struct kobject *kobj,
         struct qla_hw_data *ha = vha->hw;
         uint8_t *tmp_data;
 
+        if (unlikely(pci_channel_offline(ha->pdev)))
+                return 0;
+
         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size ||
             !ha->isp_ops->write_nvram)
                 return 0;
@@ -1159,6 +1171,28 @@ qla2x00_total_isp_aborts_show(struct device *dev,
 }
 
 static ssize_t
+qla24xx_84xx_fw_version_show(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        int rval = QLA_SUCCESS;
+        uint16_t status[2] = {0, 0};
+        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
+        struct qla_hw_data *ha = vha->hw;
+
+        if (IS_QLA84XX(ha) && ha->cs84xx) {
+                if (ha->cs84xx->op_fw_version == 0) {
+                        rval = qla84xx_verify_chip(vha, status);
+        }
+
+        if ((rval == QLA_SUCCESS) && (status[0] == 0))
+                return snprintf(buf, PAGE_SIZE, "%u\n",
+                        (uint32_t)ha->cs84xx->op_fw_version);
+        }
+
+        return snprintf(buf, PAGE_SIZE, "\n");
+}
+
+static ssize_t
 qla2x00_mpi_version_show(struct device *dev, struct device_attribute *attr,
     char *buf)
 {
@@ -1238,10 +1272,15 @@ qla2x00_fw_state_show(struct device *dev, struct device_attribute *attr,
     char *buf)
 {
         scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
-        int rval;
+        int rval = QLA_FUNCTION_FAILED;
         uint16_t state[5];
 
-        rval = qla2x00_get_firmware_state(vha, state);
+        if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) ||
+                test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags))
+                DEBUG2_3_11(printk("%s(%ld): isp reset in progress.\n",
+                        __func__, vha->host_no));
+        else if (!vha->hw->flags.eeh_busy)
+                rval = qla2x00_get_firmware_state(vha, state);
         if (rval != QLA_SUCCESS)
                 memset(state, -1, sizeof(state));
 
@@ -1271,6 +1310,8 @@ static DEVICE_ATTR(optrom_fcode_version, S_IRUGO,
                    qla2x00_optrom_fcode_version_show, NULL);
 static DEVICE_ATTR(optrom_fw_version, S_IRUGO, qla2x00_optrom_fw_version_show,
                    NULL);
+static DEVICE_ATTR(84xx_fw_version, S_IRUGO, qla24xx_84xx_fw_version_show,
+                   NULL);
 static DEVICE_ATTR(total_isp_aborts, S_IRUGO, qla2x00_total_isp_aborts_show,
                    NULL);
 static DEVICE_ATTR(mpi_version, S_IRUGO, qla2x00_mpi_version_show, NULL);
@@ -1300,6 +1341,7 @@ struct device_attribute *qla2x00_host_attrs[] = {
         &dev_attr_optrom_efi_version,
         &dev_attr_optrom_fcode_version,
         &dev_attr_optrom_fw_version,
+        &dev_attr_84xx_fw_version,
         &dev_attr_total_isp_aborts,
         &dev_attr_mpi_version,
         &dev_attr_phy_version,
@@ -1452,10 +1494,13 @@ qla2x00_dev_loss_tmo_callbk(struct fc_rport *rport)
         if (!fcport)
                 return;
 
-        if (unlikely(pci_channel_offline(fcport->vha->hw->pdev)))
+        if (test_bit(ABORT_ISP_ACTIVE, &fcport->vha->dpc_flags))
+                return;
+
+        if (unlikely(pci_channel_offline(fcport->vha->hw->pdev))) {
                 qla2x00_abort_all_cmds(fcport->vha, DID_NO_CONNECT << 16);
-        else
-                qla2x00_abort_fcport_cmds(fcport);
+                return;
+        }
 
         /*
          * Transport has effectively 'deleted' the rport, clear
@@ -1475,6 +1520,9 @@ qla2x00_terminate_rport_io(struct fc_rport *rport)
         if (!fcport)
                 return;
 
+        if (test_bit(ABORT_ISP_ACTIVE, &fcport->vha->dpc_flags))
+                return;
+
         if (unlikely(pci_channel_offline(fcport->vha->hw->pdev))) {
                 qla2x00_abort_all_cmds(fcport->vha, DID_NO_CONNECT << 16);
                 return;
@@ -1488,8 +1536,6 @@ qla2x00_terminate_rport_io(struct fc_rport *rport)
                 fcport->vha->hw->isp_ops->fabric_logout(fcport->vha,
                         fcport->loop_id, fcport->d_id.b.domain,
                         fcport->d_id.b.area, fcport->d_id.b.al_pa);
-
-        qla2x00_abort_fcport_cmds(fcport);
 }
 
 static int
@@ -1515,6 +1561,12 @@ qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
         pfc_host_stat = &ha->fc_host_stat;
         memset(pfc_host_stat, -1, sizeof(struct fc_host_statistics));
 
+        if (test_bit(UNLOADING, &vha->dpc_flags))
+                goto done;
+
+        if (unlikely(pci_channel_offline(ha->pdev)))
+                goto done;
+
         stats = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &stats_dma);
         if (stats == NULL) {
                 DEBUG2_3_11(printk("%s(%ld): Failed to allocate memory.\n",
@@ -1654,7 +1706,8 @@ qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
                         fc_vport_set_state(fc_vport, FC_VPORT_LINKDOWN);
         }
 
-        if (scsi_add_host(vha->host, &fc_vport->dev)) {
+        if (scsi_add_host_with_dma(vha->host, &fc_vport->dev,
+                                   &ha->pdev->dev)) {
                 DEBUG15(printk("scsi(%ld): scsi_add_host failure for VP[%d].\n",
                         vha->host_no, vha->vp_idx));
                 goto vport_create_failed_2;
@@ -1772,6 +1825,582 @@ qla24xx_vport_disable(struct fc_vport *fc_vport, bool disable)
         return 0;
 }
 
+/* BSG support for ELS/CT pass through */
+inline srb_t *
+qla2x00_get_ctx_bsg_sp(scsi_qla_host_t *vha, fc_port_t *fcport, size_t size)
+{
+        srb_t *sp;
+        struct qla_hw_data *ha = vha->hw;
+        struct srb_bsg_ctx *ctx;
+
+        sp = mempool_alloc(ha->srb_mempool, GFP_KERNEL);
+        if (!sp)
+                goto done;
+        ctx = kzalloc(size, GFP_KERNEL);
+        if (!ctx) {
+                mempool_free(sp, ha->srb_mempool);
+                goto done;
+        }
+
+        memset(sp, 0, sizeof(*sp));
+        sp->fcport = fcport;
+        sp->ctx = ctx;
+done:
+        return sp;
+}
+
+static int
+qla2x00_process_els(struct fc_bsg_job *bsg_job)
+{
+        struct fc_rport *rport;
+        fc_port_t *fcport;
+        struct Scsi_Host *host;
+        scsi_qla_host_t *vha;
+        struct qla_hw_data *ha;
+        srb_t *sp;
+        const char *type;
+        int req_sg_cnt, rsp_sg_cnt;
+        int rval =  (DRIVER_ERROR << 16);
+        uint16_t nextlid = 0;
+        struct srb_bsg *els;
+
+        /*  Multiple SG's are not supported for ELS requests */
+        if (bsg_job->request_payload.sg_cnt > 1 ||
+                bsg_job->reply_payload.sg_cnt > 1) {
+                DEBUG2(printk(KERN_INFO
+                    "multiple SG's are not supported for ELS requests"
+                    " [request_sg_cnt: %x reply_sg_cnt: %x]\n",
+                    bsg_job->request_payload.sg_cnt,
+                    bsg_job->reply_payload.sg_cnt));
+                rval = -EPERM;
+                goto done;
+        }
+
+        /* ELS request for rport */
+        if (bsg_job->request->msgcode == FC_BSG_RPT_ELS) {
+                rport = bsg_job->rport;
+                fcport = *(fc_port_t **) rport->dd_data;
+                host = rport_to_shost(rport);
+                vha = shost_priv(host);
+                ha = vha->hw;
+                type = "FC_BSG_RPT_ELS";
+
+                /* make sure the rport is logged in,
+                 * if not perform fabric login
+                 */
+                if (qla2x00_fabric_login(vha, fcport, &nextlid)) {
+                        DEBUG2(qla_printk(KERN_WARNING, ha,
+                            "failed to login port %06X for ELS passthru\n",
+                            fcport->d_id.b24));
+                        rval = -EIO;
+                        goto done;
+                }
+        } else {
+                host = bsg_job->shost;
+                vha = shost_priv(host);
+                ha = vha->hw;
+                type = "FC_BSG_HST_ELS_NOLOGIN";
+
+                /* Allocate a dummy fcport structure, since functions
+                 * preparing the IOCB and mailbox command retrieves port
+                 * specific information from fcport structure. For Host based
+                 * ELS commands there will be no fcport structure allocated
+                 */
+                fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
+                if (!fcport) {
+                        rval = -ENOMEM;
+                        goto done;
+                }
+
+                /* Initialize all required  fields of fcport */
+                fcport->vha = vha;
+                fcport->vp_idx = vha->vp_idx;
+                fcport->d_id.b.al_pa =
+                    bsg_job->request->rqst_data.h_els.port_id[0];
+                fcport->d_id.b.area =
+                    bsg_job->request->rqst_data.h_els.port_id[1];
+                fcport->d_id.b.domain =
+                    bsg_job->request->rqst_data.h_els.port_id[2];
+                fcport->loop_id =
+                    (fcport->d_id.b.al_pa == 0xFD) ?
+                    NPH_FABRIC_CONTROLLER : NPH_F_PORT;
+        }
+
+        if (!vha->flags.online) {
+                DEBUG2(qla_printk(KERN_WARNING, ha,
+                    "host not online\n"));
+                rval = -EIO;
+                goto done;
+        }
+
+        req_sg_cnt =
+            dma_map_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
+            bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        if (!req_sg_cnt) {
+                rval = -ENOMEM;
+                goto done_free_fcport;
+        }
+        rsp_sg_cnt = dma_map_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
+            bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        if (!rsp_sg_cnt) {
+                rval = -ENOMEM;
+                goto done_free_fcport;
+        }
+
+        if ((req_sg_cnt !=  bsg_job->request_payload.sg_cnt) ||
+            (rsp_sg_cnt != bsg_job->reply_payload.sg_cnt))
+        {
+                DEBUG2(printk(KERN_INFO
+                    "dma mapping resulted in different sg counts \
+                    [request_sg_cnt: %x dma_request_sg_cnt: %x\
+                    reply_sg_cnt: %x dma_reply_sg_cnt: %x]\n",
+                    bsg_job->request_payload.sg_cnt, req_sg_cnt,
+                    bsg_job->reply_payload.sg_cnt, rsp_sg_cnt));
+                rval = -EAGAIN;
+                goto done_unmap_sg;
+        }
+
+        /* Alloc SRB structure */
+        sp = qla2x00_get_ctx_bsg_sp(vha, fcport, sizeof(struct srb_bsg));
+        if (!sp) {
+                rval = -ENOMEM;
+                goto done_unmap_sg;
+        }
+
+        els = sp->ctx;
+        els->ctx.type =
+            (bsg_job->request->msgcode == FC_BSG_RPT_ELS ?
+            SRB_ELS_CMD_RPT : SRB_ELS_CMD_HST);
+        els->bsg_job = bsg_job;
+
+        DEBUG2(qla_printk(KERN_INFO, ha,
+            "scsi(%ld:%x): bsg rqst type: %s els type: %x - loop-id=%x "
+            "portid=%02x%02x%02x.\n", vha->host_no, sp->handle, type,
+            bsg_job->request->rqst_data.h_els.command_code,
+            fcport->loop_id, fcport->d_id.b.domain, fcport->d_id.b.area,
+            fcport->d_id.b.al_pa));
+
+        rval = qla2x00_start_sp(sp);
+        if (rval != QLA_SUCCESS) {
+                kfree(sp->ctx);
+                mempool_free(sp, ha->srb_mempool);
+                rval = -EIO;
+                goto done_unmap_sg;
+        }
+        return rval;
+
+done_unmap_sg:
+        dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
+                bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        dma_unmap_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
+                bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        goto done_free_fcport;
+
+done_free_fcport:
+        if (bsg_job->request->msgcode == FC_BSG_HST_ELS_NOLOGIN)
+                kfree(fcport);
+done:
+        return rval;
+}
+
+static int
+qla2x00_process_ct(struct fc_bsg_job *bsg_job)
+{
+        srb_t *sp;
+        struct Scsi_Host *host = bsg_job->shost;
+        scsi_qla_host_t *vha = shost_priv(host);
+        struct qla_hw_data *ha = vha->hw;
+        int rval = (DRIVER_ERROR << 16);
+        int req_sg_cnt, rsp_sg_cnt;
+        uint16_t loop_id;
+        struct fc_port *fcport;
+        char  *type = "FC_BSG_HST_CT";
+        struct srb_bsg *ct;
+
+        /* pass through is supported only for ISP 4Gb or higher */
+        if (!IS_FWI2_CAPABLE(ha)) {
+                DEBUG2(qla_printk(KERN_INFO, ha,
+                    "scsi(%ld):Firmware is not capable to support FC "
+                    "CT pass thru\n", vha->host_no));
+                rval = -EPERM;
+                goto done;
+        }
+
+        req_sg_cnt =
+            dma_map_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
+            bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        if (!req_sg_cnt) {
+                rval = -ENOMEM;
+                goto done;
+        }
+
+        rsp_sg_cnt = dma_map_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
+            bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        if (!rsp_sg_cnt) {
+                rval = -ENOMEM;
+                goto done;
+        }
+
+        if ((req_sg_cnt !=  bsg_job->request_payload.sg_cnt) ||
+                (rsp_sg_cnt != bsg_job->reply_payload.sg_cnt))
+        {
+                DEBUG2(qla_printk(KERN_WARNING, ha,
+                    "dma mapping resulted in different sg counts \
+                    [request_sg_cnt: %x dma_request_sg_cnt: %x\
+                    reply_sg_cnt: %x dma_reply_sg_cnt: %x]\n",
+                    bsg_job->request_payload.sg_cnt, req_sg_cnt,
+                    bsg_job->reply_payload.sg_cnt, rsp_sg_cnt));
+                rval = -EAGAIN;
+                goto done_unmap_sg;
+        }
+
+        if (!vha->flags.online) {
+                DEBUG2(qla_printk(KERN_WARNING, ha,
+                    "host not online\n"));
+                rval = -EIO;
+                goto done_unmap_sg;
+        }
+
+        loop_id =
+            (bsg_job->request->rqst_data.h_ct.preamble_word1 & 0xFF000000)
+            >> 24;
+        switch (loop_id) {
+                case 0xFC:
+                        loop_id = cpu_to_le16(NPH_SNS);
+                        break;
+                case 0xFA:
+                        loop_id = vha->mgmt_svr_loop_id;
+                        break;
+                default:
+                        DEBUG2(qla_printk(KERN_INFO, ha,
+                            "Unknown loop id: %x\n", loop_id));
+                        rval = -EINVAL;
+                        goto done_unmap_sg;
+        }
+
+        /* Allocate a dummy fcport structure, since functions preparing the
+         * IOCB and mailbox command retrieves port specific information
+         * from fcport structure. For Host based ELS commands there will be
+         * no fcport structure allocated
+         */
+        fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
+        if (!fcport)
+        {
+                rval = -ENOMEM;
+                goto  done_unmap_sg;
+        }
+
+        /* Initialize all required  fields of fcport */
+        fcport->vha = vha;
+        fcport->vp_idx = vha->vp_idx;
+        fcport->d_id.b.al_pa = bsg_job->request->rqst_data.h_ct.port_id[0];
+        fcport->d_id.b.area = bsg_job->request->rqst_data.h_ct.port_id[1];
+        fcport->d_id.b.domain = bsg_job->request->rqst_data.h_ct.port_id[2];
+        fcport->loop_id = loop_id;
+
+        /* Alloc SRB structure */
+        sp = qla2x00_get_ctx_bsg_sp(vha, fcport, sizeof(struct srb_bsg));
+        if (!sp) {
+                rval = -ENOMEM;
+                goto done_free_fcport;
+        }
+
+        ct = sp->ctx;
+        ct->ctx.type = SRB_CT_CMD;
+        ct->bsg_job = bsg_job;
+
+        DEBUG2(qla_printk(KERN_INFO, ha,
+            "scsi(%ld:%x): bsg rqst type: %s els type: %x - loop-id=%x "
+            "portid=%02x%02x%02x.\n", vha->host_no, sp->handle, type,
+            (bsg_job->request->rqst_data.h_ct.preamble_word2 >> 16),
+            fcport->loop_id, fcport->d_id.b.domain, fcport->d_id.b.area,
+            fcport->d_id.b.al_pa));
+
+        rval = qla2x00_start_sp(sp);
+        if (rval != QLA_SUCCESS) {
+                kfree(sp->ctx);
+                mempool_free(sp, ha->srb_mempool);
+                rval = -EIO;
+                goto done_free_fcport;
+        }
+        return rval;
+
+done_free_fcport:
+        kfree(fcport);
+done_unmap_sg:
+        dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
+            bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        dma_unmap_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
+            bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+done:
+        return rval;
+}
+
+static int
+qla2x00_process_vendor_specific(struct fc_bsg_job *bsg_job)
+{
+        struct Scsi_Host *host = bsg_job->shost;
+        scsi_qla_host_t *vha = shost_priv(host);
+        struct qla_hw_data *ha = vha->hw;
+        int rval;
+        uint8_t command_sent;
+        uint32_t vendor_cmd;
+        char *type;
+        struct msg_echo_lb elreq;
+        uint16_t response[MAILBOX_REGISTER_COUNT];
+        uint8_t* fw_sts_ptr;
+        uint8_t *req_data;
+        dma_addr_t req_data_dma;
+        uint32_t req_data_len;
+        uint8_t *rsp_data;
+        dma_addr_t rsp_data_dma;
+        uint32_t rsp_data_len;
+
+        if (test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) ||
+            test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) ||
+            test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
+                rval = -EBUSY;
+                goto done;
+        }
+
+        if (!vha->flags.online) {
+                DEBUG2(qla_printk(KERN_WARNING, ha,
+                    "host not online\n"));
+                rval = -EIO;
+                goto done;
+        }
+
+        elreq.req_sg_cnt =
+            dma_map_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
+            bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        if (!elreq.req_sg_cnt) {
+                rval = -ENOMEM;
+                goto done;
+        }
+        elreq.rsp_sg_cnt =
+            dma_map_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
+            bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        if (!elreq.rsp_sg_cnt) {
+                rval = -ENOMEM;
+                goto done;
+        }
+
+        if ((elreq.req_sg_cnt !=  bsg_job->request_payload.sg_cnt) ||
+            (elreq.rsp_sg_cnt != bsg_job->reply_payload.sg_cnt))
+        {
+                DEBUG2(printk(KERN_INFO
+                    "dma mapping resulted in different sg counts \
+                    [request_sg_cnt: %x dma_request_sg_cnt: %x\
+                    reply_sg_cnt: %x dma_reply_sg_cnt: %x]\n",
+                    bsg_job->request_payload.sg_cnt, elreq.req_sg_cnt,
+                    bsg_job->reply_payload.sg_cnt, elreq.rsp_sg_cnt));
+                rval = -EAGAIN;
+                goto done_unmap_sg;
+        }
+        req_data_len = rsp_data_len = bsg_job->request_payload.payload_len;
+        req_data = dma_alloc_coherent(&ha->pdev->dev, req_data_len,
+            &req_data_dma, GFP_KERNEL);
+
+        rsp_data = dma_alloc_coherent(&ha->pdev->dev, rsp_data_len,
+            &rsp_data_dma, GFP_KERNEL);
+
+        /* Copy the request buffer in req_data now */
+        sg_copy_to_buffer(bsg_job->request_payload.sg_list,
+            bsg_job->request_payload.sg_cnt, req_data,
+            req_data_len);
+
+        elreq.send_dma = req_data_dma;
+        elreq.rcv_dma = rsp_data_dma;
+        elreq.transfer_size = req_data_len;
+
+        /* Vendor cmd : loopback or ECHO diagnostic
+         * Options:
+         *      Loopback : Either internal or external loopback
+         *      ECHO: ECHO ELS or Vendor specific FC4  link data
+         */
+        vendor_cmd = bsg_job->request->rqst_data.h_vendor.vendor_cmd[0];
+        elreq.options =
+            *(((uint32_t *)bsg_job->request->rqst_data.h_vendor.vendor_cmd)
+            + 1);
+
+        switch (bsg_job->request->rqst_data.h_vendor.vendor_cmd[0]) {
+        case QL_VND_LOOPBACK:
+                if (ha->current_topology != ISP_CFG_F) {
+                        type = "FC_BSG_HST_VENDOR_LOOPBACK";
+
+                        DEBUG2(qla_printk(KERN_INFO, ha,
+                                "scsi(%ld) bsg rqst type: %s vendor rqst type: %x options: %x.\n",
+                                vha->host_no, type, vendor_cmd, elreq.options));
+
+                        command_sent = INT_DEF_LB_LOOPBACK_CMD;
+                        rval = qla2x00_loopback_test(vha, &elreq, response);
+                        if (IS_QLA81XX(ha)) {
+                                if (response[0] == MBS_COMMAND_ERROR && response[1] == MBS_LB_RESET) {
+                                        DEBUG2(printk(KERN_ERR "%s(%ld): ABORTing "
+                                                "ISP\n", __func__, vha->host_no));
+                                        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                                        qla2xxx_wake_dpc(vha);
+                                 }
+                        }
+                } else {
+                        type = "FC_BSG_HST_VENDOR_ECHO_DIAG";
+                        DEBUG2(qla_printk(KERN_INFO, ha,
+                                "scsi(%ld) bsg rqst type: %s vendor rqst type: %x options: %x.\n",
+                                vha->host_no, type, vendor_cmd, elreq.options));
+
+                        command_sent = INT_DEF_LB_ECHO_CMD;
+                        rval = qla2x00_echo_test(vha, &elreq, response);
+                }
+                break;
+        case QLA84_RESET:
+                if (!IS_QLA84XX(vha->hw)) {
+                        rval = -EINVAL;
+                        DEBUG16(printk(
+                                "%s(%ld): 8xxx exiting.\n",
+                                __func__, vha->host_no));
+                        return rval;
+                }
+                rval = qla84xx_reset(vha, &elreq, bsg_job);
+                break;
+        case QLA84_MGMT_CMD:
+                if (!IS_QLA84XX(vha->hw)) {
+                        rval = -EINVAL;
+                        DEBUG16(printk(
+                                "%s(%ld): 8xxx exiting.\n",
+                                __func__, vha->host_no));
+                        return rval;
+                }
+                rval = qla84xx_mgmt_cmd(vha, &elreq, bsg_job);
+                break;
+        default:
+                rval = -ENOSYS;
+        }
+
+        if (rval != QLA_SUCCESS) {
+                DEBUG2(qla_printk(KERN_WARNING, ha,
+                        "scsi(%ld) Vendor request %s failed\n", vha->host_no, type));
+                rval = 0;
+                bsg_job->reply->result = (DID_ERROR << 16);
+                bsg_job->reply->reply_payload_rcv_len = 0;
+                fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
+                memcpy( fw_sts_ptr, response, sizeof(response));
+                fw_sts_ptr += sizeof(response);
+                *fw_sts_ptr = command_sent;
+        } else {
+                DEBUG2(qla_printk(KERN_WARNING, ha,
+                        "scsi(%ld) Vendor request %s completed\n", vha->host_no, type));
+                rval = bsg_job->reply->result = 0;
+                bsg_job->reply_len = sizeof(struct fc_bsg_reply) + sizeof(response) + sizeof(uint8_t);
+                bsg_job->reply->reply_payload_rcv_len = bsg_job->reply_payload.payload_len;
+                fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
+                memcpy(fw_sts_ptr, response, sizeof(response));
+                fw_sts_ptr += sizeof(response);
+                *fw_sts_ptr = command_sent;
+                sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
+                bsg_job->reply_payload.sg_cnt, rsp_data,
+                rsp_data_len);
+        }
+        bsg_job->job_done(bsg_job);
+
+done_unmap_sg:
+
+        if(req_data)
+                dma_free_coherent(&ha->pdev->dev, req_data_len,
+                        req_data, req_data_dma);
+        dma_unmap_sg(&ha->pdev->dev,
+            bsg_job->request_payload.sg_list,
+            bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        dma_unmap_sg(&ha->pdev->dev,
+            bsg_job->reply_payload.sg_list,
+            bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+
+done:
+        return rval;
+}
+
+static int
+qla24xx_bsg_request(struct fc_bsg_job *bsg_job)
+{
+        int ret = -EINVAL;
+
+        switch (bsg_job->request->msgcode) {
+                case FC_BSG_RPT_ELS:
+                case FC_BSG_HST_ELS_NOLOGIN:
+                        ret = qla2x00_process_els(bsg_job);
+                        break;
+                case FC_BSG_HST_CT:
+                        ret = qla2x00_process_ct(bsg_job);
+                        break;
+                case FC_BSG_HST_VENDOR:
+                        ret = qla2x00_process_vendor_specific(bsg_job);
+                        break;
+                case FC_BSG_HST_ADD_RPORT:
+                case FC_BSG_HST_DEL_RPORT:
+                case FC_BSG_RPT_CT:
+                default:
+                        DEBUG2(printk("qla2xxx: unsupported BSG request\n"));
+                        break;
+        }
+        return ret;
+}
+
+static int
+qla24xx_bsg_timeout(struct fc_bsg_job *bsg_job)
+{
+        scsi_qla_host_t *vha = shost_priv(bsg_job->shost);
+        struct qla_hw_data *ha = vha->hw;
+        srb_t *sp;
+        int cnt, que;
+        unsigned long flags;
+        struct req_que *req;
+        struct srb_bsg *sp_bsg;
+
+        /* find the bsg job from the active list of commands */
+        spin_lock_irqsave(&ha->hardware_lock, flags);
+        for (que = 0; que < ha->max_req_queues; que++) {
+                req = ha->req_q_map[que];
+                if (!req)
+                        continue;
+
+                for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++ ) {
+                        sp = req->outstanding_cmds[cnt];
+
+                        if (sp) {
+                                sp_bsg = (struct srb_bsg*)sp->ctx;
+
+                                if (((sp_bsg->ctx.type == SRB_CT_CMD) ||
+                                    (sp_bsg->ctx.type == SRB_ELS_CMD_RPT)
+                                    || ( sp_bsg->ctx.type == SRB_ELS_CMD_HST)) &&
+                                    (sp_bsg->bsg_job == bsg_job)) {
+                                        if (ha->isp_ops->abort_command(sp)) {
+                                                DEBUG2(qla_printk(KERN_INFO, ha,
+                                                "scsi(%ld): mbx abort_command failed\n", vha->host_no));
+                                                bsg_job->req->errors = bsg_job->reply->result = -EIO;
+                                        } else {
+                                                DEBUG2(qla_printk(KERN_INFO, ha,
+                                                "scsi(%ld): mbx abort_command success\n", vha->host_no));
+                                                bsg_job->req->errors = bsg_job->reply->result = 0;
+                                        }
+                                        goto done;
+                                }
+                        }
+                }
+        }
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
+        DEBUG2(qla_printk(KERN_INFO, ha,
+                "scsi(%ld) SRB not found to abort\n", vha->host_no));
+        bsg_job->req->errors = bsg_job->reply->result = -ENXIO;
+        return 0;
+
+done:
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
+        if (bsg_job->request->msgcode == FC_BSG_HST_CT)
+                kfree(sp->fcport);
+        kfree(sp->ctx);
+        mempool_free(sp, ha->srb_mempool);
+        return 0;
+}
+
 struct fc_function_template qla2xxx_transport_functions = {
 
         .show_host_node_name = 1,
@@ -1815,6 +2444,8 @@ struct fc_function_template qla2xxx_transport_functions = {
         .vport_create = qla24xx_vport_create,
         .vport_disable = qla24xx_vport_disable,
         .vport_delete = qla24xx_vport_delete,
+        .bsg_request = qla24xx_bsg_request,
+        .bsg_timeout = qla24xx_bsg_timeout,
 };
 
 struct fc_function_template qla2xxx_transport_vport_functions = {
@@ -1855,6 +2486,8 @@ struct fc_function_template qla2xxx_transport_vport_functions = {
         .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
         .terminate_rport_io = qla2x00_terminate_rport_io,
         .get_fc_host_stats = qla2x00_get_fc_host_stats,
+        .bsg_request = qla24xx_bsg_request,
+        .bsg_timeout = qla24xx_bsg_timeout,
 };
 
 void
@@ -1883,3 +2516,125 @@ qla2x00_init_host_attr(scsi_qla_host_t *vha)
                 speed = FC_PORTSPEED_1GBIT;
         fc_host_supported_speeds(vha->host) = speed;
 }
+static int
+qla84xx_reset(scsi_qla_host_t *ha, struct msg_echo_lb *mreq, struct fc_bsg_job *bsg_job)
+{
+        int             ret = 0;
+        int             cmd;
+        uint16_t        cmd_status;
+
+        DEBUG16(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+
+        cmd = (*((bsg_job->request->rqst_data.h_vendor.vendor_cmd) + 2))
+                        == A84_RESET_FLAG_ENABLE_DIAG_FW ?
+                                A84_ISSUE_RESET_DIAG_FW : A84_ISSUE_RESET_OP_FW;
+        ret = qla84xx_reset_chip(ha, cmd == A84_ISSUE_RESET_DIAG_FW,
+        &cmd_status);
+        return ret;
+}
+
+static int
+qla84xx_mgmt_cmd(scsi_qla_host_t *ha, struct msg_echo_lb *mreq, struct fc_bsg_job *bsg_job)
+{
+        struct access_chip_84xx *mn;
+        dma_addr_t mn_dma, mgmt_dma;
+        void *mgmt_b = NULL;
+        int ret = 0;
+        int rsp_hdr_len, len = 0;
+        struct qla84_msg_mgmt *ql84_mgmt;
+
+        ql84_mgmt = (struct qla84_msg_mgmt *) vmalloc(sizeof(struct qla84_msg_mgmt));
+        ql84_mgmt->cmd =
+                *((uint16_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 2));
+        ql84_mgmt->mgmtp.u.mem.start_addr =
+                *((uint32_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 3));
+        ql84_mgmt->len =
+                *((uint32_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 4));
+        ql84_mgmt->mgmtp.u.config.id =
+                *((uint32_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 5));
+        ql84_mgmt->mgmtp.u.config.param0 =
+                *((uint32_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 6));
+        ql84_mgmt->mgmtp.u.config.param1 =
+                *((uint32_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 7));
+        ql84_mgmt->mgmtp.u.info.type =
+                *((uint32_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 8));
+        ql84_mgmt->mgmtp.u.info.context =
+                *((uint32_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 9));
+
+        rsp_hdr_len = bsg_job->request_payload.payload_len;
+
+        mn = dma_pool_alloc(ha->hw->s_dma_pool, GFP_KERNEL, &mn_dma);
+        if (mn == NULL) {
+                DEBUG2(printk(KERN_ERR "%s: dma alloc for fw buffer "
+                "failed%lu\n", __func__, ha->host_no));
+                return -ENOMEM;
+        }
+
+        memset(mn, 0, sizeof (struct access_chip_84xx));
+
+        mn->entry_type = ACCESS_CHIP_IOCB_TYPE;
+        mn->entry_count = 1;
+
+        switch (ql84_mgmt->cmd) {
+        case QLA84_MGMT_READ_MEM:
+                mn->options = cpu_to_le16(ACO_DUMP_MEMORY);
+                mn->parameter1 = cpu_to_le32(ql84_mgmt->mgmtp.u.mem.start_addr);
+                break;
+        case QLA84_MGMT_WRITE_MEM:
+                mn->options = cpu_to_le16(ACO_LOAD_MEMORY);
+                mn->parameter1 = cpu_to_le32(ql84_mgmt->mgmtp.u.mem.start_addr);
+                break;
+        case QLA84_MGMT_CHNG_CONFIG:
+                mn->options = cpu_to_le16(ACO_CHANGE_CONFIG_PARAM);
+                mn->parameter1 = cpu_to_le32(ql84_mgmt->mgmtp.u.config.id);
+                mn->parameter2 = cpu_to_le32(ql84_mgmt->mgmtp.u.config.param0);
+                mn->parameter3 = cpu_to_le32(ql84_mgmt->mgmtp.u.config.param1);
+                break;
+        case QLA84_MGMT_GET_INFO:
+                mn->options = cpu_to_le16(ACO_REQUEST_INFO);
+                mn->parameter1 = cpu_to_le32(ql84_mgmt->mgmtp.u.info.type);
+                mn->parameter2 = cpu_to_le32(ql84_mgmt->mgmtp.u.info.context);
+                break;
+        default:
+                ret = -EIO;
+                goto exit_mgmt0;
+        }
+
+        if ((len == ql84_mgmt->len) &&
+                ql84_mgmt->cmd != QLA84_MGMT_CHNG_CONFIG) {
+                mgmt_b = dma_alloc_coherent(&ha->hw->pdev->dev, len,
+                                &mgmt_dma, GFP_KERNEL);
+                if (mgmt_b == NULL) {
+                        DEBUG2(printk(KERN_ERR "%s: dma alloc mgmt_b "
+                        "failed%lu\n", __func__, ha->host_no));
+                        ret = -ENOMEM;
+                        goto exit_mgmt0;
+                }
+                mn->total_byte_cnt = cpu_to_le32(ql84_mgmt->len);
+                mn->dseg_count = cpu_to_le16(1);
+                mn->dseg_address[0] = cpu_to_le32(LSD(mgmt_dma));
+                mn->dseg_address[1] = cpu_to_le32(MSD(mgmt_dma));
+                mn->dseg_length = cpu_to_le32(len);
+
+                if (ql84_mgmt->cmd == QLA84_MGMT_WRITE_MEM) {
+                        memcpy(mgmt_b, ql84_mgmt->payload, len);
+                }
+        }
+
+        ret = qla2x00_issue_iocb(ha, mn, mn_dma, 0);
+        if ((ret != QLA_SUCCESS) || (ql84_mgmt->cmd == QLA84_MGMT_WRITE_MEM)
+                || (ql84_mgmt->cmd == QLA84_MGMT_CHNG_CONFIG)) {
+                        if (ret != QLA_SUCCESS)
+                                DEBUG2(printk(KERN_ERR "%s(%lu): failed\n",
+                                        __func__, ha->host_no));
+        } else if ((ql84_mgmt->cmd == QLA84_MGMT_READ_MEM) ||
+                        (ql84_mgmt->cmd == QLA84_MGMT_GET_INFO)) {
+        }
+
+        if (mgmt_b)
+                dma_free_coherent(&ha->hw->pdev->dev, len, mgmt_b, mgmt_dma);
+
+exit_mgmt0:
+        dma_pool_free(ha->hw->s_dma_pool, mn, mn_dma);
+        return ret;
+}
diff --git a/drivers/scsi/qla2xxx/qla_dbg.c b/drivers/scsi/qla2xxx/qla_dbg.c
index cca8e4ab0372..cb2eca4c26d8 100644
--- a/drivers/scsi/qla2xxx/qla_dbg.c
+++ b/drivers/scsi/qla2xxx/qla_dbg.c
@@ -377,6 +377,24 @@ qla25xx_copy_mq(struct qla_hw_data *ha, void *ptr, uint32_t **last_chain)
         return ptr + sizeof(struct qla2xxx_mq_chain);
 }
 
+static void
+qla2xxx_dump_post_process(scsi_qla_host_t *vha, int rval)
+{
+        struct qla_hw_data *ha = vha->hw;
+
+        if (rval != QLA_SUCCESS) {
+                qla_printk(KERN_WARNING, ha,
+                    "Failed to dump firmware (%x)!!!\n", rval);
+                ha->fw_dumped = 0;
+        } else {
+                qla_printk(KERN_INFO, ha,
+                    "Firmware dump saved to temp buffer (%ld/%p).\n",
+                    vha->host_no, ha->fw_dump);
+                ha->fw_dumped = 1;
+                qla2x00_post_uevent_work(vha, QLA_UEVENT_CODE_FW_DUMP);
+        }
+}
+
 /**
  * qla2300_fw_dump() - Dumps binary data from the 2300 firmware.
  * @ha: HA context
@@ -530,17 +548,7 @@ qla2300_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
         if (rval == QLA_SUCCESS)
                 qla2xxx_copy_queues(ha, nxt);
 
-        if (rval != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
-                    "Failed to dump firmware (%x)!!!\n", rval);
-                ha->fw_dumped = 0;
-
-        } else {
-                qla_printk(KERN_INFO, ha,
-                    "Firmware dump saved to temp buffer (%ld/%p).\n",
-                    base_vha->host_no, ha->fw_dump);
-                ha->fw_dumped = 1;
-        }
+        qla2xxx_dump_post_process(base_vha, rval);
 
 qla2300_fw_dump_failed:
         if (!hardware_locked)
@@ -737,17 +745,7 @@ qla2100_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
         if (rval == QLA_SUCCESS)
                 qla2xxx_copy_queues(ha, &fw->risc_ram[cnt]);
 
-        if (rval != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
-                    "Failed to dump firmware (%x)!!!\n", rval);
-                ha->fw_dumped = 0;
-
-        } else {
-                qla_printk(KERN_INFO, ha,
-                    "Firmware dump saved to temp buffer (%ld/%p).\n",
-                    base_vha->host_no, ha->fw_dump);
-                ha->fw_dumped = 1;
-        }
+        qla2xxx_dump_post_process(base_vha, rval);
 
 qla2100_fw_dump_failed:
         if (!hardware_locked)
@@ -984,17 +982,7 @@ qla24xx_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
         qla24xx_copy_eft(ha, nxt);
 
 qla24xx_fw_dump_failed_0:
-        if (rval != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
-                    "Failed to dump firmware (%x)!!!\n", rval);
-                ha->fw_dumped = 0;
-
-        } else {
-                qla_printk(KERN_INFO, ha,
-                    "Firmware dump saved to temp buffer (%ld/%p).\n",
-                    base_vha->host_no, ha->fw_dump);
-                ha->fw_dumped = 1;
-        }
+        qla2xxx_dump_post_process(base_vha, rval);
 
 qla24xx_fw_dump_failed:
         if (!hardware_locked)
@@ -1305,17 +1293,7 @@ qla25xx_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
         }
 
 qla25xx_fw_dump_failed_0:
-        if (rval != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
-                    "Failed to dump firmware (%x)!!!\n", rval);
-                ha->fw_dumped = 0;
-
-        } else {
-                qla_printk(KERN_INFO, ha,
-                    "Firmware dump saved to temp buffer (%ld/%p).\n",
-                    base_vha->host_no, ha->fw_dump);
-                ha->fw_dumped = 1;
-        }
+        qla2xxx_dump_post_process(base_vha, rval);
 
 qla25xx_fw_dump_failed:
         if (!hardware_locked)
@@ -1628,17 +1606,7 @@ qla81xx_fw_dump(scsi_qla_host_t *vha, int hardware_locked)
         }
 
 qla81xx_fw_dump_failed_0:
-        if (rval != QLA_SUCCESS) {
-                qla_printk(KERN_WARNING, ha,
-                    "Failed to dump firmware (%x)!!!\n", rval);
-                ha->fw_dumped = 0;
-
-        } else {
-                qla_printk(KERN_INFO, ha,
-                    "Firmware dump saved to temp buffer (%ld/%p).\n",
-                    base_vha->host_no, ha->fw_dump);
-                ha->fw_dumped = 1;
-        }
+        qla2xxx_dump_post_process(base_vha, rval);
 
 qla81xx_fw_dump_failed:
         if (!hardware_locked)
diff --git a/drivers/scsi/qla2xxx/qla_dbg.h b/drivers/scsi/qla2xxx/qla_dbg.h
index f660dd70b72e..d6d9c86cb058 100644
--- a/drivers/scsi/qla2xxx/qla_dbg.h
+++ b/drivers/scsi/qla2xxx/qla_dbg.h
@@ -26,7 +26,7 @@
 /* #define QL_DEBUG_LEVEL_14 */ /* Output RSCN trace msgs */
 /* #define QL_DEBUG_LEVEL_15 */ /* Output NPIV trace msgs */
 /* #define QL_DEBUG_LEVEL_16 */ /* Output ISP84XX trace msgs */
-/* #define QL_DEBUG_LEVEL_17 */ /* Output MULTI-Q trace messages */
+/* #define QL_DEBUG_LEVEL_17 */ /* Output EEH trace messages */
 
 /*
 * Macros use for debugging the driver.
@@ -132,6 +132,13 @@
 #else
 #define DEBUG16(x)      do {} while (0)
 #endif
+
+#if defined(QL_DEBUG_LEVEL_17)
+#define DEBUG17(x)      do {x;} while (0)
+#else
+#define DEBUG17(x)      do {} while (0)
+#endif
+
 /*
  * Firmware Dump structure definition
  */
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index 215061861794..afa95614aaf8 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -31,6 +31,7 @@
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_transport_fc.h>
+#include <scsi/scsi_bsg_fc.h>
 
 #define QLA2XXX_DRIVER_NAME  "qla2xxx"
 
@@ -228,6 +229,27 @@ struct srb_logio {
         uint16_t flags;
 };
 
+struct srb_bsg_ctx {
+#define SRB_ELS_CMD_RPT 3
+#define SRB_ELS_CMD_HST 4
+#define SRB_CT_CMD 5
+        uint16_t type;
+};
+
+struct srb_bsg {
+        struct srb_bsg_ctx ctx;
+        struct fc_bsg_job *bsg_job;
+};
+
+struct msg_echo_lb {
+        dma_addr_t send_dma;
+        dma_addr_t rcv_dma;
+        uint16_t req_sg_cnt;
+        uint16_t rsp_sg_cnt;
+        uint16_t options;
+        uint32_t transfer_size;
+};
+
 /*
  * ISP I/O Register Set structure definitions.
  */
@@ -522,6 +544,8 @@ typedef struct {
 #define MBA_DISCARD_RND_FRAME   0x8048  /* discard RND frame due to error. */
 #define MBA_REJECTED_FCP_CMD    0x8049  /* rejected FCP_CMD. */
 
+/* ISP mailbox loopback echo diagnostic error code */
+#define MBS_LB_RESET    0x17
 /*
  * Firmware options 1, 2, 3.
  */
@@ -1570,9 +1594,6 @@ typedef struct fc_port {
         struct fc_rport *rport, *drport;
         u32 supported_classes;
 
-        unsigned long last_queue_full;
-        unsigned long last_ramp_up;
-
         uint16_t vp_idx;
 } fc_port_t;
 
@@ -1589,8 +1610,7 @@ typedef struct fc_port {
  */
 #define FCF_FABRIC_DEVICE       BIT_0
 #define FCF_LOGIN_NEEDED        BIT_1
-#define FCF_TAPE_PRESENT        BIT_2
-#define FCF_FCP2_DEVICE         BIT_3
+#define FCF_FCP2_DEVICE         BIT_2
 
 /* No loop ID flag. */
 #define FC_NO_LOOP_ID           0x1000
@@ -2123,6 +2143,7 @@ enum qla_work_type {
         QLA_EVT_ASYNC_LOGIN_DONE,
         QLA_EVT_ASYNC_LOGOUT,
         QLA_EVT_ASYNC_LOGOUT_DONE,
+        QLA_EVT_UEVENT,
 };
 
 
@@ -2146,6 +2167,10 @@ struct qla_work_evt {
 #define QLA_LOGIO_LOGIN_RETRIED BIT_0
                         u16 data[2];
                 } logio;
+                struct {
+                        u32 code;
+#define QLA_UEVENT_CODE_FW_DUMP 0
+                } uevent;
         } u;
 };
 
@@ -2229,6 +2254,13 @@ struct req_que {
         int max_q_depth;
 };
 
+/* Place holder for FW buffer parameters */
+struct qlfc_fw {
+        void *fw_buf;
+        dma_addr_t fw_dma;
+        uint32_t len;
+};
+
 /*
  * Qlogic host adapter specific data structure.
 */
@@ -2254,12 +2286,15 @@ struct qla_hw_data {
                 uint32_t        disable_serdes          :1;
                 uint32_t        gpsc_supported          :1;
                 uint32_t        npiv_supported          :1;
+                uint32_t        pci_channel_io_perm_failure     :1;
                 uint32_t        fce_enabled             :1;
                 uint32_t        fac_supported           :1;
                 uint32_t        chip_reset_done         :1;
                 uint32_t        port0                   :1;
                 uint32_t        running_gold_fw         :1;
+                uint32_t        eeh_busy                :1;
                 uint32_t        cpu_affinity_enabled    :1;
+                uint32_t        disable_msix_handshake  :1;
         } flags;
 
         /* This spinlock is used to protect "io transactions", you must
@@ -2382,6 +2417,7 @@ struct qla_hw_data {
 #define IS_QLA81XX(ha)          (IS_QLA8001(ha))
 #define IS_QLA2XXX_MIDTYPE(ha)  (IS_QLA24XX(ha) || IS_QLA84XX(ha) || \
                                 IS_QLA25XX(ha) || IS_QLA81XX(ha))
+#define IS_MSIX_NACK_CAPABLE(ha) (IS_QLA81XX(ha))
 #define IS_NOPOLLING_TYPE(ha)   ((IS_QLA25XX(ha) || IS_QLA81XX(ha)) && \
                                 (ha)->flags.msix_enabled)
 #define IS_FAC_REQUIRED(ha)     (IS_QLA81XX(ha))
@@ -2435,11 +2471,11 @@ struct qla_hw_data {
         dma_addr_t      edc_data_dma;
         uint16_t        edc_data_len;
 
-#define XGMAC_DATA_SIZE PAGE_SIZE
+#define XGMAC_DATA_SIZE 4096
         void            *xgmac_data;
         dma_addr_t      xgmac_data_dma;
 
-#define DCBX_TLV_DATA_SIZE PAGE_SIZE
+#define DCBX_TLV_DATA_SIZE 4096
         void            *dcbx_tlv;
         dma_addr_t      dcbx_tlv_dma;
 
@@ -2589,6 +2625,7 @@ struct qla_hw_data {
         struct qla_statistics qla_stats;
         struct isp_operations *isp_ops;
         struct workqueue_struct *wq;
+        struct qlfc_fw fw_buf;
 };
 
 /*
@@ -2761,4 +2798,127 @@ typedef struct scsi_qla_host {
 
 #define CMD_SP(Cmnd)            ((Cmnd)->SCp.ptr)
 
+/*
+ * BSG Vendor specific commands
+ */
+
+#define QL_VND_LOOPBACK         0x01
+#define QLA84_RESET             0x02
+#define QLA84_UPDATE_FW         0x03
+#define QLA84_MGMT_CMD          0x04
+
+/* BSG definations for interpreting CommandSent field */
+#define INT_DEF_LB_LOOPBACK_CMD         0
+#define INT_DEF_LB_ECHO_CMD             1
+
+/* BSG Vendor specific definations */
+typedef struct _A84_RESET {
+        uint16_t Flags;
+        uint16_t Reserved;
+#define A84_RESET_FLAG_ENABLE_DIAG_FW   1
+} __attribute__((packed)) A84_RESET, *PA84_RESET;
+
+#define A84_ISSUE_WRITE_TYPE_CMD        0
+#define A84_ISSUE_READ_TYPE_CMD         1
+#define A84_CLEANUP_CMD                 2
+#define A84_ISSUE_RESET_OP_FW           3
+#define A84_ISSUE_RESET_DIAG_FW         4
+#define A84_ISSUE_UPDATE_OPFW_CMD       5
+#define A84_ISSUE_UPDATE_DIAGFW_CMD     6
+
+struct qla84_mgmt_param {
+        union {
+                struct {
+                        uint32_t start_addr;
+                } mem; /* for QLA84_MGMT_READ/WRITE_MEM */
+                struct {
+                        uint32_t id;
+#define QLA84_MGMT_CONFIG_ID_UIF        1
+#define QLA84_MGMT_CONFIG_ID_FCOE_COS   2
+#define QLA84_MGMT_CONFIG_ID_PAUSE      3
+#define QLA84_MGMT_CONFIG_ID_TIMEOUTS   4
+
+                uint32_t param0;
+                uint32_t param1;
+        } config; /* for QLA84_MGMT_CHNG_CONFIG */
+
+        struct {
+                uint32_t type;
+#define QLA84_MGMT_INFO_CONFIG_LOG_DATA         1 /* Get Config Log Data */
+#define QLA84_MGMT_INFO_LOG_DATA                2 /* Get Log Data */
+#define QLA84_MGMT_INFO_PORT_STAT               3 /* Get Port Statistics */
+#define QLA84_MGMT_INFO_LIF_STAT                4 /* Get LIF Statistics  */
+#define QLA84_MGMT_INFO_ASIC_STAT               5 /* Get ASIC Statistics */
+#define QLA84_MGMT_INFO_CONFIG_PARAMS           6 /* Get Config Parameters */
+#define QLA84_MGMT_INFO_PANIC_LOG               7 /* Get Panic Log */
+
+                uint32_t context;
+/*
+* context definitions for QLA84_MGMT_INFO_CONFIG_LOG_DATA
+*/
+#define IC_LOG_DATA_LOG_ID_DEBUG_LOG                    0
+#define IC_LOG_DATA_LOG_ID_LEARN_LOG                    1
+#define IC_LOG_DATA_LOG_ID_FC_ACL_INGRESS_LOG           2
+#define IC_LOG_DATA_LOG_ID_FC_ACL_EGRESS_LOG            3
+#define IC_LOG_DATA_LOG_ID_ETHERNET_ACL_INGRESS_LOG     4
+#define IC_LOG_DATA_LOG_ID_ETHERNET_ACL_EGRESS_LOG      5
+#define IC_LOG_DATA_LOG_ID_MESSAGE_TRANSMIT_LOG         6
+#define IC_LOG_DATA_LOG_ID_MESSAGE_RECEIVE_LOG          7
+#define IC_LOG_DATA_LOG_ID_LINK_EVENT_LOG               8
+#define IC_LOG_DATA_LOG_ID_DCX_LOG                      9
+
+/*
+* context definitions for QLA84_MGMT_INFO_PORT_STAT
+*/
+#define IC_PORT_STATISTICS_PORT_NUMBER_ETHERNET_PORT0   0
+#define IC_PORT_STATISTICS_PORT_NUMBER_ETHERNET_PORT1   1
+#define IC_PORT_STATISTICS_PORT_NUMBER_NSL_PORT0        2
+#define IC_PORT_STATISTICS_PORT_NUMBER_NSL_PORT1        3
+#define IC_PORT_STATISTICS_PORT_NUMBER_FC_PORT0         4
+#define IC_PORT_STATISTICS_PORT_NUMBER_FC_PORT1         5
+
+
+/*
+* context definitions for QLA84_MGMT_INFO_LIF_STAT
+*/
+#define IC_LIF_STATISTICS_LIF_NUMBER_ETHERNET_PORT0     0
+#define IC_LIF_STATISTICS_LIF_NUMBER_ETHERNET_PORT1     1
+#define IC_LIF_STATISTICS_LIF_NUMBER_FC_PORT0           2
+#define IC_LIF_STATISTICS_LIF_NUMBER_FC_PORT1           3
+#define IC_LIF_STATISTICS_LIF_NUMBER_CPU                6
+
+                } info; /* for QLA84_MGMT_GET_INFO */
+        } u;
+};
+
+struct qla84_msg_mgmt {
+        uint16_t cmd;
+#define QLA84_MGMT_READ_MEM     0x00
+#define QLA84_MGMT_WRITE_MEM    0x01
+#define QLA84_MGMT_CHNG_CONFIG  0x02
+#define QLA84_MGMT_GET_INFO     0x03
+        uint16_t rsrvd;
+        struct qla84_mgmt_param mgmtp;/* parameters for cmd */
+        uint32_t len; /* bytes in payload following this struct */
+        uint8_t payload[0]; /* payload for cmd */
+};
+
+struct msg_update_fw {
+        /*
+        * diag_fw = 0  operational fw
+        *      otherwise diagnostic fw
+        * offset, len, fw_len are present to overcome the current limitation
+        * of 128Kb xfer size. The fw is sent in smaller chunks. Each chunk
+        * specifies the byte "offset" where it fits in the fw buffer. The
+        * number of bytes in each chunk is specified in "len". "fw_len"
+        * is the total size of fw. The first chunk should start at offset = 0.
+        * When offset+len == fw_len, the fw is written to the HBA.
+        */
+        uint32_t diag_fw;
+        uint32_t offset;/* start offset */
+        uint32_t len;   /* num bytes in cur xfer */
+        uint32_t fw_len; /* size of fw in bytes */
+        uint8_t fw_bytes[0];
+};
+
 #endif
diff --git a/drivers/scsi/qla2xxx/qla_fw.h b/drivers/scsi/qla2xxx/qla_fw.h
index 66a8da5d7d08..42c5587cc50c 100644
--- a/drivers/scsi/qla2xxx/qla_fw.h
+++ b/drivers/scsi/qla2xxx/qla_fw.h
@@ -627,6 +627,39 @@ struct els_entry_24xx {
         uint32_t rx_len;                /* Data segment 1 length. */
 };
 
+struct els_sts_entry_24xx {
+        uint8_t entry_type;             /* Entry type. */
+        uint8_t entry_count;            /* Entry count. */
+        uint8_t sys_define;             /* System Defined. */
+        uint8_t entry_status;           /* Entry Status. */
+
+        uint32_t handle;                /* System handle. */
+
+        uint16_t comp_status;
+
+        uint16_t nport_handle;          /* N_PORT handle. */
+
+        uint16_t reserved_1;
+
+        uint8_t vp_index;
+        uint8_t sof_type;
+
+        uint32_t rx_xchg_address;       /* Receive exchange address. */
+        uint16_t reserved_2;
+
+        uint8_t opcode;
+        uint8_t reserved_3;
+
+        uint8_t port_id[3];
+        uint8_t reserved_4;
+
+        uint16_t reserved_5;
+
+        uint16_t control_flags;         /* Control flags. */
+        uint32_t total_byte_count;
+        uint32_t error_subcode_1;
+        uint32_t error_subcode_2;
+};
 /*
  * ISP queue - Mailbox Command entry structure definition.
  */
@@ -1559,10 +1592,22 @@ struct nvram_81xx {
 
         /* Offset 384. */
         uint8_t reserved_21[16];
-        uint16_t reserved_22[8];
+        uint16_t reserved_22[3];
+
+        /*
+         * BIT 0 = Extended BB credits for LR
+         * BIT 1 = Virtual Fabric Enable
+         * BIT 2 = Enhanced Features Unused
+         * BIT 3-7 = Enhanced Features Reserved
+         */
+        /* Enhanced Features */
+        uint8_t enhanced_features;
+
+        uint8_t reserved_23;
+        uint16_t reserved_24[4];
 
         /* Offset 416. */
-        uint16_t reserved_23[32];
+        uint16_t reserved_25[32];
 
         /* Offset 480. */
         uint8_t model_name[16];
@@ -1570,7 +1615,7 @@ struct nvram_81xx {
         /* Offset 496. */
         uint16_t feature_mask_l;
         uint16_t feature_mask_h;
-        uint16_t reserved_24[2];
+        uint16_t reserved_26[2];
 
         uint16_t subsystem_vendor_id;
         uint16_t subsystem_device_id;
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index f3d1d1afa95b..3a89bc514e2b 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -60,6 +60,8 @@ extern int qla2x00_async_login_done(struct scsi_qla_host *, fc_port_t *,
 extern int qla2x00_async_logout_done(struct scsi_qla_host *, fc_port_t *,
     uint16_t *);
 
+extern fc_port_t *
+qla2x00_alloc_fcport(scsi_qla_host_t *, gfp_t );
 /*
  * Global Data in qla_os.c source file.
  */
@@ -72,12 +74,11 @@ extern int ql2xloginretrycount;
 extern int ql2xfdmienable;
 extern int ql2xallocfwdump;
 extern int ql2xextended_error_logging;
-extern int ql2xqfullrampup;
-extern int ql2xqfulltracking;
 extern int ql2xiidmaenable;
 extern int ql2xmaxqueues;
 extern int ql2xmultique_tag;
 extern int ql2xfwloadbin;
+extern int ql2xetsenable;
 
 extern int qla2x00_loop_reset(scsi_qla_host_t *);
 extern void qla2x00_abort_all_cmds(scsi_qla_host_t *, int);
@@ -92,10 +93,10 @@ extern int qla2x00_post_async_logout_work(struct scsi_qla_host *, fc_port_t *,
     uint16_t *);
 extern int qla2x00_post_async_logout_done_work(struct scsi_qla_host *,
     fc_port_t *, uint16_t *);
+extern int qla2x00_post_uevent_work(struct scsi_qla_host *, u32);
 
 extern int qla81xx_restart_mpi_firmware(scsi_qla_host_t *);
 
-extern void qla2x00_abort_fcport_cmds(fc_port_t *);
 extern struct scsi_qla_host *qla2x00_create_host(struct scsi_host_template *,
         struct qla_hw_data *);
 extern void qla2x00_free_host(struct scsi_qla_host *);
@@ -155,6 +156,7 @@ int qla2x00_marker(struct scsi_qla_host *, struct req_que *, struct rsp_que *,
 int __qla2x00_marker(struct scsi_qla_host *, struct req_que *, struct rsp_que *,
                                                 uint16_t, uint16_t, uint8_t);
 extern int qla2x00_start_sp(srb_t *);
+extern void qla2x00_ctx_sp_free(srb_t *);
 
 /*
  * Global Function Prototypes in qla_mbx.c source file.
@@ -246,7 +248,7 @@ qla2x00_get_id_list(scsi_qla_host_t *, void *, dma_addr_t, uint16_t *);
 
 extern int
 qla2x00_get_resource_cnts(scsi_qla_host_t *, uint16_t *, uint16_t *,
-    uint16_t *, uint16_t *, uint16_t *);
+    uint16_t *, uint16_t *, uint16_t *, uint16_t *);
 
 extern int
 qla2x00_get_fcal_position_map(scsi_qla_host_t *ha, char *pos_map);
@@ -325,6 +327,7 @@ qla2x00_read_ram_word(scsi_qla_host_t *, uint32_t, uint32_t *);
 extern int
 qla2x00_write_ram_word(scsi_qla_host_t *, uint32_t, uint32_t);
 
+extern int qla2x00_get_data_rate(scsi_qla_host_t *);
 /*
  * Global Function Prototypes in qla_isr.c source file.
  */
@@ -426,6 +429,8 @@ extern void qla2x00_free_sysfs_attr(scsi_qla_host_t *);
 extern void qla2x00_init_host_attr(scsi_qla_host_t *);
 extern void qla2x00_alloc_sysfs_attr(scsi_qla_host_t *);
 extern void qla2x00_free_sysfs_attr(scsi_qla_host_t *);
+extern int qla2x00_loopback_test(scsi_qla_host_t *, struct msg_echo_lb *, uint16_t *);
+extern int qla2x00_echo_test(scsi_qla_host_t *, struct msg_echo_lb *, uint16_t *);
 
 /*
  * Global Function Prototypes in qla_dfs.c source file.
@@ -453,6 +458,5 @@ extern void qla24xx_wrt_req_reg(struct qla_hw_data *, uint16_t, uint16_t);
 extern void qla25xx_wrt_req_reg(struct qla_hw_data *, uint16_t, uint16_t);
 extern void qla25xx_wrt_rsp_reg(struct qla_hw_data *, uint16_t, uint16_t);
 extern void qla24xx_wrt_rsp_reg(struct qla_hw_data *, uint16_t, uint16_t);
-extern struct scsi_qla_host * qla25xx_get_host(struct rsp_que *);
 
 #endif /* _QLA_GBL_H */
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 9e3eaac25596..4229bb483c5e 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -8,6 +8,7 @@
 #include "qla_gbl.h"
 
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <linux/vmalloc.h>
 
 #include "qla_devtbl.h"
@@ -62,7 +63,7 @@ qla2x00_ctx_sp_timeout(unsigned long __data)
         ctx->free(sp);
 }
 
-static void
+void
 qla2x00_ctx_sp_free(srb_t *sp)
 {
         struct srb_ctx *ctx = sp->ctx;
@@ -205,7 +206,7 @@ qla2x00_async_login_done(struct scsi_qla_host *vha, fc_port_t *fcport,
 
         switch (data[0]) {
         case MBS_COMMAND_COMPLETE:
-                if (fcport->flags & FCF_TAPE_PRESENT)
+                if (fcport->flags & FCF_FCP2_DEVICE)
                         opts |= BIT_1;
                 rval = qla2x00_get_port_database(vha, fcport, opts);
                 if (rval != QLA_SUCCESS)
@@ -269,6 +270,8 @@ qla2x00_initialize_adapter(scsi_qla_host_t *vha)
         vha->flags.online = 0;
         ha->flags.chip_reset_done = 0;
         vha->flags.reset_active = 0;
+        ha->flags.pci_channel_io_perm_failure = 0;
+        ha->flags.eeh_busy = 0;
         atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME);
         atomic_set(&vha->loop_state, LOOP_DOWN);
         vha->device_flags = DFLG_NO_CABLE;
@@ -277,7 +280,6 @@ qla2x00_initialize_adapter(scsi_qla_host_t *vha)
         vha->marker_needed = 0;
         ha->isp_abort_cnt = 0;
         ha->beacon_blink_led = 0;
-        set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
 
         set_bit(0, ha->req_qid_map);
         set_bit(0, ha->rsp_qid_map);
@@ -337,6 +339,16 @@ qla2x00_initialize_adapter(scsi_qla_host_t *vha)
         rval = qla2x00_init_rings(vha);
         ha->flags.chip_reset_done = 1;
 
+        if (rval == QLA_SUCCESS && IS_QLA84XX(ha)) {
+        /* Issue verify 84xx FW IOCB to complete 84xx initialization */
+                rval = qla84xx_init_chip(vha);
+                if (rval != QLA_SUCCESS) {
+                        qla_printk(KERN_ERR, ha,
+                                "Unable to initialize ISP84XX.\n");
+                qla84xx_put_chip(vha);
+                }
+        }
+
         return (rval);
 }
 
@@ -582,6 +594,9 @@ qla2x00_reset_chip(scsi_qla_host_t *vha)
         uint32_t        cnt;
         uint16_t        cmd;
 
+        if (unlikely(pci_channel_offline(ha->pdev)))
+                return;
+
         ha->isp_ops->disable_intrs(ha);
 
         spin_lock_irqsave(&ha->hardware_lock, flags);
@@ -787,6 +802,12 @@ void
 qla24xx_reset_chip(scsi_qla_host_t *vha)
 {
         struct qla_hw_data *ha = vha->hw;
+
+        if (pci_channel_offline(ha->pdev) &&
+            ha->flags.pci_channel_io_perm_failure) {
+                return;
+        }
+
         ha->isp_ops->disable_intrs(ha);
 
         /* Perform RISC reset. */
@@ -1203,7 +1224,7 @@ qla2x00_setup_chip(scsi_qla_host_t *vha)
                                 }
                                 qla2x00_get_resource_cnts(vha, NULL,
                                     &ha->fw_xcb_count, NULL, NULL,
-                                    &ha->max_npiv_vports);
+                                    &ha->max_npiv_vports, NULL);
 
                                 if (!fw_major_version && ql2xallocfwdump)
                                         qla2x00_alloc_fw_dump(vha);
@@ -1443,7 +1464,17 @@ qla24xx_config_rings(struct scsi_qla_host *vha)
                         icb->firmware_options_2 |=
                                 __constant_cpu_to_le32(BIT_18);
 
-                icb->firmware_options_2 &= __constant_cpu_to_le32(~BIT_22);
+                /* Use Disable MSIX Handshake mode for capable adapters */
+                if (IS_MSIX_NACK_CAPABLE(ha)) {
+                        icb->firmware_options_2 &=
+                                __constant_cpu_to_le32(~BIT_22);
+                        ha->flags.disable_msix_handshake = 1;
+                        qla_printk(KERN_INFO, ha,
+                                "MSIX Handshake Disable Mode turned on\n");
+                } else {
+                        icb->firmware_options_2 |=
+                                __constant_cpu_to_le32(BIT_22);
+                }
                 icb->firmware_options_2 |= __constant_cpu_to_le32(BIT_23);
 
                 WRT_REG_DWORD(&reg->isp25mq.req_q_in, 0);
@@ -2196,7 +2227,7 @@ qla2x00_rport_del(void *data)
  *
  * Returns a pointer to the allocated fcport, or NULL, if none available.
  */
-static fc_port_t *
+fc_port_t *
 qla2x00_alloc_fcport(scsi_qla_host_t *vha, gfp_t flags)
 {
         fc_port_t *fcport;
@@ -2257,6 +2288,8 @@ qla2x00_configure_loop(scsi_qla_host_t *vha)
         clear_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
         clear_bit(RSCN_UPDATE, &vha->dpc_flags);
 
+        qla2x00_get_data_rate(vha);
+
         /* Determine what we need to do */
         if (ha->current_topology == ISP_CFG_FL &&
             (test_bit(LOCAL_LOOP_UPDATE, &flags))) {
@@ -2704,7 +2737,7 @@ qla2x00_configure_fabric(scsi_qla_host_t *vha)
 
                 /*
                  * Logout all previous fabric devices marked lost, except
-                 * tape devices.
+                 * FCP2 devices.
                  */
                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
                         if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags))
@@ -2717,7 +2750,7 @@ qla2x00_configure_fabric(scsi_qla_host_t *vha)
                                 qla2x00_mark_device_lost(vha, fcport,
                                     ql2xplogiabsentdevice, 0);
                                 if (fcport->loop_id != FC_NO_LOOP_ID &&
-                                    (fcport->flags & FCF_TAPE_PRESENT) == 0 &&
+                                    (fcport->flags & FCF_FCP2_DEVICE) == 0 &&
                                     fcport->port_type != FCT_INITIATOR &&
                                     fcport->port_type != FCT_BROADCAST) {
                                         ha->isp_ops->fabric_logout(vha,
@@ -2878,8 +2911,13 @@ qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
                 if (qla2x00_is_reserved_id(vha, loop_id))
                         continue;
 
-                if (atomic_read(&vha->loop_down_timer) || LOOP_TRANSITION(vha))
+                if (atomic_read(&vha->loop_down_timer) ||
+                    LOOP_TRANSITION(vha)) {
+                        atomic_set(&vha->loop_down_timer, 0);
+                        set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
+                        set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
                         break;
+                }
 
                 if (swl != NULL) {
                         if (last_dev) {
@@ -2996,7 +3034,7 @@ qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
                         fcport->d_id.b24 = new_fcport->d_id.b24;
                         fcport->flags |= FCF_LOGIN_NEEDED;
                         if (fcport->loop_id != FC_NO_LOOP_ID &&
-                            (fcport->flags & FCF_TAPE_PRESENT) == 0 &&
+                            (fcport->flags & FCF_FCP2_DEVICE) == 0 &&
                             fcport->port_type != FCT_INITIATOR &&
                             fcport->port_type != FCT_BROADCAST) {
                                 ha->isp_ops->fabric_logout(vha, fcport->loop_id,
@@ -3250,9 +3288,9 @@ qla2x00_fabric_dev_login(scsi_qla_host_t *vha, fc_port_t *fcport,
 
         rval = qla2x00_fabric_login(vha, fcport, next_loopid);
         if (rval == QLA_SUCCESS) {
-                /* Send an ADISC to tape devices.*/
+                /* Send an ADISC to FCP2 devices.*/
                 opts = 0;
-                if (fcport->flags & FCF_TAPE_PRESENT)
+                if (fcport->flags & FCF_FCP2_DEVICE)
                         opts |= BIT_1;
                 rval = qla2x00_get_port_database(vha, fcport, opts);
                 if (rval != QLA_SUCCESS) {
@@ -3551,6 +3589,13 @@ qla2x00_abort_isp(scsi_qla_host_t *vha)
                 /* Requeue all commands in outstanding command list. */
                 qla2x00_abort_all_cmds(vha, DID_RESET << 16);
 
+                if (unlikely(pci_channel_offline(ha->pdev) &&
+                    ha->flags.pci_channel_io_perm_failure)) {
+                        clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
+                        status = 0;
+                        return status;
+                }
+
                 ha->isp_ops->get_flash_version(vha, req->ring);
 
                 ha->isp_ops->nvram_config(vha);
@@ -3573,6 +3618,15 @@ qla2x00_abort_isp(scsi_qla_host_t *vha)
                         ha->isp_abort_cnt = 0;
                         clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
 
+                        if (IS_QLA81XX(ha))
+                                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,
@@ -4440,6 +4494,8 @@ qla2x00_try_to_stop_firmware(scsi_qla_host_t *vha)
         int ret, retries;
         struct qla_hw_data *ha = vha->hw;
 
+        if (ha->flags.pci_channel_io_perm_failure)
+                return;
         if (!IS_FWI2_CAPABLE(ha))
                 return;
         if (!ha->fw_major_version)
@@ -4837,6 +4893,15 @@ qla81xx_nvram_config(scsi_qla_host_t *vha)
 }
 
 void
-qla81xx_update_fw_options(scsi_qla_host_t *ha)
+qla81xx_update_fw_options(scsi_qla_host_t *vha)
 {
+        struct qla_hw_data *ha = vha->hw;
+
+        if (!ql2xetsenable)
+                return;
+
+        /* Enable ETS Burst. */
+        memset(ha->fw_options, 0, sizeof(ha->fw_options));
+        ha->fw_options[2] |= BIT_9;
+        qla2x00_set_fw_options(vha, ha->fw_options);
 }
diff --git a/drivers/scsi/qla2xxx/qla_iocb.c b/drivers/scsi/qla2xxx/qla_iocb.c
index c5ccac0bef76..8299a9891bfe 100644
--- a/drivers/scsi/qla2xxx/qla_iocb.c
+++ b/drivers/scsi/qla2xxx/qla_iocb.c
@@ -1025,6 +1025,119 @@ qla2x00_logout_iocb(srb_t *sp, struct mbx_entry *mbx)
         /* Implicit: mbx->mbx10 = 0. */
 }
 
+static void
+qla24xx_els_iocb(srb_t *sp, struct els_entry_24xx *els_iocb)
+{
+        struct fc_bsg_job *bsg_job = ((struct srb_bsg*)sp->ctx)->bsg_job;
+
+        els_iocb->entry_type = ELS_IOCB_TYPE;
+        els_iocb->entry_count = 1;
+        els_iocb->sys_define = 0;
+        els_iocb->entry_status = 0;
+        els_iocb->handle = sp->handle;
+        els_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id);
+        els_iocb->tx_dsd_count = __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt);
+        els_iocb->vp_index = sp->fcport->vp_idx;
+        els_iocb->sof_type = EST_SOFI3;
+        els_iocb->rx_dsd_count = __constant_cpu_to_le16(bsg_job->reply_payload.sg_cnt);
+
+        els_iocb->opcode =(((struct srb_bsg*)sp->ctx)->ctx.type == SRB_ELS_CMD_RPT) ?
+            bsg_job->request->rqst_data.r_els.els_code : bsg_job->request->rqst_data.h_els.command_code;
+        els_iocb->port_id[0] = sp->fcport->d_id.b.al_pa;
+        els_iocb->port_id[1] = sp->fcport->d_id.b.area;
+        els_iocb->port_id[2] = sp->fcport->d_id.b.domain;
+        els_iocb->control_flags = 0;
+        els_iocb->rx_byte_count =
+            cpu_to_le32(bsg_job->reply_payload.payload_len);
+        els_iocb->tx_byte_count =
+            cpu_to_le32(bsg_job->request_payload.payload_len);
+
+        els_iocb->tx_address[0] = cpu_to_le32(LSD(sg_dma_address
+            (bsg_job->request_payload.sg_list)));
+        els_iocb->tx_address[1] = cpu_to_le32(MSD(sg_dma_address
+            (bsg_job->request_payload.sg_list)));
+        els_iocb->tx_len = cpu_to_le32(sg_dma_len
+            (bsg_job->request_payload.sg_list));
+
+        els_iocb->rx_address[0] = cpu_to_le32(LSD(sg_dma_address
+            (bsg_job->reply_payload.sg_list)));
+        els_iocb->rx_address[1] = cpu_to_le32(MSD(sg_dma_address
+            (bsg_job->reply_payload.sg_list)));
+        els_iocb->rx_len = cpu_to_le32(sg_dma_len
+            (bsg_job->reply_payload.sg_list));
+}
+
+static void
+qla24xx_ct_iocb(srb_t *sp, struct ct_entry_24xx *ct_iocb)
+{
+        uint16_t        avail_dsds;
+        uint32_t        *cur_dsd;
+        struct scatterlist *sg;
+        int index;
+        uint16_t tot_dsds;
+        scsi_qla_host_t *vha = sp->fcport->vha;
+        struct fc_bsg_job *bsg_job = ((struct srb_bsg*)sp->ctx)->bsg_job;
+        int loop_iterartion = 0;
+        int cont_iocb_prsnt = 0;
+        int entry_count = 1;
+
+        ct_iocb->entry_type = CT_IOCB_TYPE;
+        ct_iocb->entry_status = 0;
+        ct_iocb->sys_define = 0;
+        ct_iocb->handle = sp->handle;
+
+        ct_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id);
+        ct_iocb->vp_index = sp->fcport->vp_idx;
+        ct_iocb->comp_status = __constant_cpu_to_le16(0);
+
+        ct_iocb->cmd_dsd_count =
+            __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt);
+        ct_iocb->timeout = 0;
+        ct_iocb->rsp_dsd_count =
+            __constant_cpu_to_le16(bsg_job->reply_payload.sg_cnt);
+        ct_iocb->rsp_byte_count =
+            cpu_to_le32(bsg_job->reply_payload.payload_len);
+        ct_iocb->cmd_byte_count =
+            cpu_to_le32(bsg_job->request_payload.payload_len);
+        ct_iocb->dseg_0_address[0] = cpu_to_le32(LSD(sg_dma_address
+            (bsg_job->request_payload.sg_list)));
+        ct_iocb->dseg_0_address[1] = cpu_to_le32(MSD(sg_dma_address
+           (bsg_job->request_payload.sg_list)));
+        ct_iocb->dseg_0_len = cpu_to_le32(sg_dma_len
+            (bsg_job->request_payload.sg_list));
+
+        avail_dsds = 1;
+        cur_dsd = (uint32_t *)ct_iocb->dseg_1_address;
+        index = 0;
+        tot_dsds = bsg_job->reply_payload.sg_cnt;
+
+        for_each_sg(bsg_job->reply_payload.sg_list, sg, tot_dsds, index) {
+                dma_addr_t       sle_dma;
+                cont_a64_entry_t *cont_pkt;
+
+                /* Allocate additional continuation packets? */
+                if (avail_dsds == 0) {
+                        /*
+                        * Five DSDs are available in the Cont.
+                        * Type 1 IOCB.
+                               */
+                        cont_pkt = qla2x00_prep_cont_type1_iocb(vha);
+                        cur_dsd = (uint32_t *) cont_pkt->dseg_0_address;
+                        avail_dsds = 5;
+                        cont_iocb_prsnt = 1;
+                        entry_count++;
+                }
+
+                sle_dma = sg_dma_address(sg);
+                *cur_dsd++   = cpu_to_le32(LSD(sle_dma));
+                *cur_dsd++   = cpu_to_le32(MSD(sle_dma));
+                *cur_dsd++   = cpu_to_le32(sg_dma_len(sg));
+                loop_iterartion++;
+                avail_dsds--;
+        }
+        ct_iocb->entry_count = entry_count;
+}
+
 int
 qla2x00_start_sp(srb_t *sp)
 {
@@ -1052,6 +1165,13 @@ qla2x00_start_sp(srb_t *sp)
                     qla24xx_logout_iocb(sp, pkt):
                     qla2x00_logout_iocb(sp, pkt);
                 break;
+        case SRB_ELS_CMD_RPT:
+        case SRB_ELS_CMD_HST:
+                qla24xx_els_iocb(sp, pkt);
+                break;
+        case SRB_CT_CMD:
+                qla24xx_ct_iocb(sp, pkt);
+                break;
         default:
                 break;
         }
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index b20a7169aac2..db539b0c3dae 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -7,7 +7,9 @@
 #include "qla_def.h"
 
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <scsi/scsi_tcq.h>
+#include <scsi/scsi_bsg_fc.h>
 
 static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t);
 static void qla2x00_process_completed_request(struct scsi_qla_host *,
@@ -152,7 +154,7 @@ qla2300_intr_handler(int irq, void *dev_id)
         for (iter = 50; iter--; ) {
                 stat = RD_REG_DWORD(&reg->u.isp2300.host_status);
                 if (stat & HSR_RISC_PAUSED) {
-                        if (pci_channel_offline(ha->pdev))
+                        if (unlikely(pci_channel_offline(ha->pdev)))
                                 break;
 
                         hccr = RD_REG_WORD(&reg->hccr);
@@ -313,10 +315,11 @@ qla2x00_async_event(scsi_qla_host_t *vha, struct rsp_que *rsp, uint16_t *mb)
         static char     *link_speeds[] = { "1", "2", "?", "4", "8", "10" };
         char            *link_speed;
         uint16_t        handle_cnt;
-        uint16_t        cnt;
+        uint16_t        cnt, mbx;
         uint32_t        handles[5];
         struct qla_hw_data *ha = vha->hw;
         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
+        struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
         uint32_t        rscn_entry, host_pid;
         uint8_t         rscn_queue_index;
         unsigned long   flags;
@@ -395,9 +398,10 @@ skip_rio:
                 break;
 
         case MBA_SYSTEM_ERR:            /* System Error */
+                mbx = IS_QLA81XX(ha) ? RD_REG_WORD(&reg24->mailbox7) : 0;
                 qla_printk(KERN_INFO, ha,
-                    "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh.\n",
-                    mb[1], mb[2], mb[3]);
+                    "ISP System Error - mbx1=%xh mbx2=%xh mbx3=%xh "
+                    "mbx7=%xh.\n", mb[1], mb[2], mb[3], mbx);
 
                 ha->isp_ops->fw_dump(vha, 1);
 
@@ -419,9 +423,10 @@ skip_rio:
                 break;
 
         case MBA_REQ_TRANSFER_ERR:      /* Request Transfer Error */
-                DEBUG2(printk("scsi(%ld): ISP Request Transfer Error.\n",
-                    vha->host_no));
-                qla_printk(KERN_WARNING, ha, "ISP Request Transfer Error.\n");
+                DEBUG2(printk("scsi(%ld): ISP Request Transfer Error (%x).\n",
+                    vha->host_no, mb[1]));
+                qla_printk(KERN_WARNING, ha,
+                    "ISP Request Transfer Error (%x).\n", mb[1]);
 
                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                 break;
@@ -485,10 +490,13 @@ skip_rio:
                 break;
 
         case MBA_LOOP_DOWN:             /* Loop Down Event */
+                mbx = IS_QLA81XX(ha) ? RD_REG_WORD(&reg24->mailbox4) : 0;
                 DEBUG2(printk("scsi(%ld): Asynchronous LOOP DOWN "
-                    "(%x %x %x).\n", vha->host_no, mb[1], mb[2], mb[3]));
-                qla_printk(KERN_INFO, ha, "LOOP DOWN detected (%x %x %x).\n",
-                    mb[1], mb[2], mb[3]);
+                    "(%x %x %x %x).\n", vha->host_no, mb[1], mb[2], mb[3],
+                    mbx));
+                qla_printk(KERN_INFO, ha,
+                    "LOOP DOWN detected (%x %x %x %x).\n", mb[1], mb[2], mb[3],
+                    mbx);
 
                 if (atomic_read(&vha->loop_state) != LOOP_DOWN) {
                         atomic_set(&vha->loop_state, LOOP_DOWN);
@@ -613,11 +621,10 @@ skip_rio:
                  *           vp_idx does not match
                  *       Event is not global, vp_idx does not match
                  */
-                if ((mb[1] == 0xffff && (mb[3] & 0xff) != 0xff)
-                        || (mb[1] != 0xffff)) {
-                        if (vha->vp_idx != (mb[3] & 0xff))
-                                break;
-                }
+                if (IS_QLA2XXX_MIDTYPE(ha) &&
+                    ((mb[1] == 0xffff && (mb[3] & 0xff) != 0xff) ||
+                        (mb[1] != 0xffff)) && vha->vp_idx != (mb[3] & 0xff))
+                        break;
 
                 /* Global event -- port logout or port unavailable. */
                 if (mb[1] == 0xffff && mb[2] == 0x7) {
@@ -805,78 +812,6 @@ skip_rio:
                 qla2x00_alert_all_vps(rsp, mb);
 }
 
-static void
-qla2x00_adjust_sdev_qdepth_up(struct scsi_device *sdev, void *data)
-{
-        fc_port_t *fcport = data;
-        struct scsi_qla_host *vha = fcport->vha;
-        struct qla_hw_data *ha = vha->hw;
-        struct req_que *req = NULL;
-
-        if (!ql2xqfulltracking)
-                return;
-
-        req = vha->req;
-        if (!req)
-                return;
-        if (req->max_q_depth <= sdev->queue_depth)
-                return;
-
-        if (sdev->ordered_tags)
-                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG,
-                    sdev->queue_depth + 1);
-        else
-                scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG,
-                    sdev->queue_depth + 1);
-
-        fcport->last_ramp_up = jiffies;
-
-        DEBUG2(qla_printk(KERN_INFO, ha,
-            "scsi(%ld:%d:%d:%d): Queue depth adjusted-up to %d.\n",
-            fcport->vha->host_no, sdev->channel, sdev->id, sdev->lun,
-            sdev->queue_depth));
-}
-
-static void
-qla2x00_adjust_sdev_qdepth_down(struct scsi_device *sdev, void *data)
-{
-        fc_port_t *fcport = data;
-
-        if (!scsi_track_queue_full(sdev, sdev->queue_depth - 1))
-                return;
-
-        DEBUG2(qla_printk(KERN_INFO, fcport->vha->hw,
-            "scsi(%ld:%d:%d:%d): Queue depth adjusted-down to %d.\n",
-            fcport->vha->host_no, sdev->channel, sdev->id, sdev->lun,
-            sdev->queue_depth));
-}
-
-static inline void
-qla2x00_ramp_up_queue_depth(scsi_qla_host_t *vha, struct req_que *req,
-                                                                srb_t *sp)
-{
-        fc_port_t *fcport;
-        struct scsi_device *sdev;
-
-        if (!ql2xqfulltracking)
-                return;
-
-        sdev = sp->cmd->device;
-        if (sdev->queue_depth >= req->max_q_depth)
-                return;
-
-        fcport = sp->fcport;
-        if (time_before(jiffies,
-            fcport->last_ramp_up + ql2xqfullrampup * HZ))
-                return;
-        if (time_before(jiffies,
-            fcport->last_queue_full + ql2xqfullrampup * HZ))
-                return;
-
-        starget_for_each_device(sdev->sdev_target, fcport,
-            qla2x00_adjust_sdev_qdepth_up);
-}
-
 /**
  * qla2x00_process_completed_request() - Process a Fast Post response.
  * @ha: SCSI driver HA context
@@ -907,8 +842,6 @@ qla2x00_process_completed_request(struct scsi_qla_host *vha,
 
                 /* Save ISP completion status */
                 sp->cmd->result = DID_OK << 16;
-
-                qla2x00_ramp_up_queue_depth(vha, req, sp);
                 qla2x00_sp_compl(ha, sp);
         } else {
                 DEBUG2(printk("scsi(%ld) Req:%d: Invalid ISP SCSI completion"
@@ -949,7 +882,9 @@ qla2x00_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
                     index);
                 return NULL;
         }
+
         req->outstanding_cmds[index] = NULL;
+
 done:
         return sp;
 }
@@ -1050,6 +985,100 @@ done_post_logio_done_work:
 }
 
 static void
+qla24xx_els_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
+    struct sts_entry_24xx *pkt, int iocb_type)
+{
+        const char func[] = "ELS_CT_IOCB";
+        const char *type;
+        struct qla_hw_data *ha = vha->hw;
+        srb_t *sp;
+        struct srb_bsg *sp_bsg;
+        struct fc_bsg_job *bsg_job;
+        uint16_t comp_status;
+        uint32_t fw_status[3];
+        uint8_t* fw_sts_ptr;
+
+        sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
+        if (!sp)
+                return;
+        sp_bsg = (struct srb_bsg*)sp->ctx;
+        bsg_job = sp_bsg->bsg_job;
+
+        type = NULL;
+        switch (sp_bsg->ctx.type) {
+        case SRB_ELS_CMD_RPT:
+        case SRB_ELS_CMD_HST:
+                type = "els";
+                break;
+        case SRB_CT_CMD:
+                type = "ct pass-through";
+                break;
+        default:
+                qla_printk(KERN_WARNING, ha,
+                    "%s: Unrecognized SRB: (%p) type=%d.\n", func, sp,
+                    sp_bsg->ctx.type);
+                return;
+        }
+
+        comp_status = fw_status[0] = le16_to_cpu(pkt->comp_status);
+        fw_status[1] = le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_1);
+        fw_status[2] = le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_2);
+
+        /* return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
+         * fc payload  to the caller
+         */
+        bsg_job->reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
+        bsg_job->reply_len = sizeof(struct fc_bsg_reply) + sizeof(fw_status);
+
+        if (comp_status != CS_COMPLETE) {
+                if (comp_status == CS_DATA_UNDERRUN) {
+                        bsg_job->reply->result = DID_OK << 16;
+                        bsg_job->reply->reply_payload_rcv_len =
+                                le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->total_byte_count);
+
+                        DEBUG2(qla_printk(KERN_WARNING, ha,
+                            "scsi(%ld:0x%x): ELS-CT pass-through-%s error comp_status-status=0x%x "
+                            "error subcode 1=0x%x error subcode 2=0x%x total_byte = 0x%x.\n",
+                                vha->host_no, sp->handle, type, comp_status, fw_status[1], fw_status[2],
+                                le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->total_byte_count)));
+                        fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
+                        memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
+                }
+                else {
+                        DEBUG2(qla_printk(KERN_WARNING, ha,
+                            "scsi(%ld:0x%x): ELS-CT pass-through-%s error comp_status-status=0x%x "
+                            "error subcode 1=0x%x error subcode 2=0x%x.\n",
+                                vha->host_no, sp->handle, type, comp_status,
+                                le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_1),
+                                le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_2)));
+                        bsg_job->reply->result = DID_ERROR << 16;
+                        bsg_job->reply->reply_payload_rcv_len = 0;
+                        fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
+                        memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
+                }
+                DEBUG2(qla2x00_dump_buffer((uint8_t *)pkt, sizeof(*pkt)));
+        }
+        else {
+                bsg_job->reply->result =  DID_OK << 16;;
+                bsg_job->reply->reply_payload_rcv_len = bsg_job->reply_payload.payload_len;
+                bsg_job->reply_len = 0;
+        }
+
+        dma_unmap_sg(&ha->pdev->dev,
+            bsg_job->request_payload.sg_list,
+            bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        dma_unmap_sg(&ha->pdev->dev,
+            bsg_job->reply_payload.sg_list,
+            bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        if ((sp_bsg->ctx.type == SRB_ELS_CMD_HST) ||
+            (sp_bsg->ctx.type == SRB_CT_CMD))
+                kfree(sp->fcport);
+        kfree(sp->ctx);
+        mempool_free(sp, ha->srb_mempool);
+        bsg_job->job_done(bsg_job);
+}
+
+static void
 qla24xx_logio_entry(scsi_qla_host_t *vha, struct req_que *req,
     struct logio_entry_24xx *logio)
 {
@@ -1347,16 +1376,22 @@ qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
 
         sense_len = rsp_info_len = resid_len = fw_resid_len = 0;
         if (IS_FWI2_CAPABLE(ha)) {
-                sense_len = le32_to_cpu(sts24->sense_len);
-                rsp_info_len = le32_to_cpu(sts24->rsp_data_len);
-                resid_len = le32_to_cpu(sts24->rsp_residual_count);
-                fw_resid_len = le32_to_cpu(sts24->residual_len);
+                if (scsi_status & SS_SENSE_LEN_VALID)
+                        sense_len = le32_to_cpu(sts24->sense_len);
+                if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
+                        rsp_info_len = le32_to_cpu(sts24->rsp_data_len);
+                if (scsi_status & (SS_RESIDUAL_UNDER | SS_RESIDUAL_OVER))
+                        resid_len = le32_to_cpu(sts24->rsp_residual_count);
+                if (comp_status == CS_DATA_UNDERRUN)
+                        fw_resid_len = le32_to_cpu(sts24->residual_len);
                 rsp_info = sts24->data;
                 sense_data = sts24->data;
                 host_to_fcp_swap(sts24->data, sizeof(sts24->data));
         } else {
-                sense_len = le16_to_cpu(sts->req_sense_length);
-                rsp_info_len = le16_to_cpu(sts->rsp_info_len);
+                if (scsi_status & SS_SENSE_LEN_VALID)
+                        sense_len = le16_to_cpu(sts->req_sense_length);
+                if (scsi_status & SS_RESPONSE_INFO_LEN_VALID)
+                        rsp_info_len = le16_to_cpu(sts->rsp_info_len);
                 resid_len = le32_to_cpu(sts->residual_length);
                 rsp_info = sts->rsp_info;
                 sense_data = sts->req_sense_data;
@@ -1423,13 +1458,6 @@ qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
                             "scsi(%ld): QUEUE FULL status detected "
                             "0x%x-0x%x.\n", vha->host_no, comp_status,
                             scsi_status));
-
-                        /* Adjust queue depth for all luns on the port. */
-                        if (!ql2xqfulltracking)
-                                break;
-                        fcport->last_queue_full = jiffies;
-                        starget_for_each_device(cp->device->sdev_target,
-                            fcport, qla2x00_adjust_sdev_qdepth_down);
                         break;
                 }
                 if (lscsi_status != SS_CHECK_CONDITION)
@@ -1443,54 +1471,67 @@ qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
                 break;
 
         case CS_DATA_UNDERRUN:
-                resid = resid_len;
+                DEBUG2(printk(KERN_INFO
+                    "scsi(%ld:%d:%d) UNDERRUN status detected 0x%x-0x%x. "
+                    "resid=0x%x fw_resid=0x%x cdb=0x%x os_underflow=0x%x\n",
+                    vha->host_no, cp->device->id, cp->device->lun, comp_status,
+                    scsi_status, resid_len, fw_resid_len, cp->cmnd[0],
+                    cp->underflow));
+
                 /* Use F/W calculated residual length. */
-                if (IS_FWI2_CAPABLE(ha)) {
-                        if (!(scsi_status & SS_RESIDUAL_UNDER)) {
-                                lscsi_status = 0;
-                        } else if (resid != fw_resid_len) {
-                                scsi_status &= ~SS_RESIDUAL_UNDER;
-                                lscsi_status = 0;
+                resid = IS_FWI2_CAPABLE(ha) ? fw_resid_len : resid_len;
+                scsi_set_resid(cp, resid);
+                if (scsi_status & SS_RESIDUAL_UNDER) {
+                        if (IS_FWI2_CAPABLE(ha) && fw_resid_len != resid_len) {
+                                DEBUG2(printk(
+                                    "scsi(%ld:%d:%d:%d) Dropped frame(s) "
+                                    "detected (%x of %x bytes)...residual "
+                                    "length mismatch...retrying command.\n",
+                                    vha->host_no, cp->device->channel,
+                                    cp->device->id, cp->device->lun, resid,
+                                    scsi_bufflen(cp)));
+
+                                cp->result = DID_ERROR << 16 | lscsi_status;
+                                break;
                         }
-                        resid = fw_resid_len;
-                }
 
-                if (scsi_status & SS_RESIDUAL_UNDER) {
-                        scsi_set_resid(cp, resid);
-                } else {
-                        DEBUG2(printk(KERN_INFO
-                            "scsi(%ld:%d:%d) UNDERRUN status detected "
-                            "0x%x-0x%x. resid=0x%x fw_resid=0x%x cdb=0x%x "
-                            "os_underflow=0x%x\n", vha->host_no,
-                            cp->device->id, cp->device->lun, comp_status,
-                            scsi_status, resid_len, resid, cp->cmnd[0],
-                            cp->underflow));
+                        if (!lscsi_status &&
+                            ((unsigned)(scsi_bufflen(cp) - resid) <
+                            cp->underflow)) {
+                                qla_printk(KERN_INFO, ha,
+                                    "scsi(%ld:%d:%d:%d): Mid-layer underflow "
+                                    "detected (%x of %x bytes)...returning "
+                                    "error status.\n", vha->host_no,
+                                    cp->device->channel, cp->device->id,
+                                    cp->device->lun, resid, scsi_bufflen(cp));
 
+                                cp->result = DID_ERROR << 16;
+                                break;
+                        }
+                } else if (!lscsi_status) {
+                        DEBUG2(printk(
+                            "scsi(%ld:%d:%d:%d) Dropped frame(s) detected "
+                            "(%x of %x bytes)...firmware reported underrun..."
+                            "retrying command.\n", vha->host_no,
+                            cp->device->channel, cp->device->id,
+                            cp->device->lun, resid, scsi_bufflen(cp)));
+
+                        cp->result = DID_ERROR << 16;
+                        break;
                 }
 
+                cp->result = DID_OK << 16 | lscsi_status;
+
                 /*
                  * Check to see if SCSI Status is non zero. If so report SCSI
                  * Status.
                  */
                 if (lscsi_status != 0) {
-                        cp->result = DID_OK << 16 | lscsi_status;
-
                         if (lscsi_status == SAM_STAT_TASK_SET_FULL) {
                                 DEBUG2(printk(KERN_INFO
                                     "scsi(%ld): QUEUE FULL status detected "
                                     "0x%x-0x%x.\n", vha->host_no, comp_status,
                                     scsi_status));
-
-                                /*
-                                 * Adjust queue depth for all luns on the
-                                 * port.
-                                 */
-                                if (!ql2xqfulltracking)
-                                        break;
-                                fcport->last_queue_full = jiffies;
-                                starget_for_each_device(
-                                    cp->device->sdev_target, fcport,
-                                    qla2x00_adjust_sdev_qdepth_down);
                                 break;
                         }
                         if (lscsi_status != SS_CHECK_CONDITION)
@@ -1501,42 +1542,6 @@ qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
                                 break;
 
                         qla2x00_handle_sense(sp, sense_data, sense_len, rsp);
-                } else {
-                        /*
-                         * If RISC reports underrun and target does not report
-                         * it then we must have a lost frame, so tell upper
-                         * layer to retry it by reporting an error.
-                         */
-                        if (!(scsi_status & SS_RESIDUAL_UNDER)) {
-                                DEBUG2(printk("scsi(%ld:%d:%d:%d) Dropped "
-                                              "frame(s) detected (%x of %x bytes)..."
-                                              "retrying command.\n",
-                                        vha->host_no, cp->device->channel,
-                                        cp->device->id, cp->device->lun, resid,
-                                        scsi_bufflen(cp)));
-
-                                scsi_set_resid(cp, resid);
-                                cp->result = DID_ERROR << 16;
-                                break;
-                        }
-
-                        /* Handle mid-layer underflow */
-                        if ((unsigned)(scsi_bufflen(cp) - resid) <
-                            cp->underflow) {
-                                qla_printk(KERN_INFO, ha,
-                                           "scsi(%ld:%d:%d:%d): Mid-layer underflow "
-                                           "detected (%x of %x bytes)...returning "
-                                           "error status.\n", vha->host_no,
-                                           cp->device->channel, cp->device->id,
-                                           cp->device->lun, resid,
-                                           scsi_bufflen(cp));
-
-                                cp->result = DID_ERROR << 16;
-                                break;
-                        }
-
-                        /* Everybody online, looking good... */
-                        cp->result = DID_OK << 16;
                 }
                 break;
 
@@ -1841,6 +1846,13 @@ void qla24xx_process_response_queue(struct scsi_qla_host *vha,
                         qla24xx_logio_entry(vha, rsp->req,
                             (struct logio_entry_24xx *)pkt);
                         break;
+                case CT_IOCB_TYPE:
+                        qla24xx_els_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
+                        clear_bit(MBX_INTERRUPT, &vha->hw->mbx_cmd_flags);
+                        break;
+                case ELS_IOCB_TYPE:
+                        qla24xx_els_ct_entry(vha, rsp->req, pkt, ELS_IOCB_TYPE);
+                        break;
                 default:
                         /* Type Not Supported. */
                         DEBUG4(printk(KERN_WARNING
@@ -1938,12 +1950,15 @@ qla24xx_intr_handler(int irq, void *dev_id)
         reg = &ha->iobase->isp24;
         status = 0;
 
+        if (unlikely(pci_channel_offline(ha->pdev)))
+                return IRQ_HANDLED;
+
         spin_lock_irqsave(&ha->hardware_lock, flags);
         vha = pci_get_drvdata(ha->pdev);
         for (iter = 50; iter--; ) {
                 stat = RD_REG_DWORD(&reg->host_status);
                 if (stat & HSRX_RISC_PAUSED) {
-                        if (pci_channel_offline(ha->pdev))
+                        if (unlikely(pci_channel_offline(ha->pdev)))
                                 break;
 
                         hccr = RD_REG_DWORD(&reg->hccr);
@@ -2006,6 +2021,7 @@ qla24xx_msix_rsp_q(int irq, void *dev_id)
         struct rsp_que *rsp;
         struct device_reg_24xx __iomem *reg;
         struct scsi_qla_host *vha;
+        unsigned long flags;
 
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
@@ -2016,15 +2032,15 @@ qla24xx_msix_rsp_q(int irq, void *dev_id)
         ha = rsp->hw;
         reg = &ha->iobase->isp24;
 
-        spin_lock_irq(&ha->hardware_lock);
+        spin_lock_irqsave(&ha->hardware_lock, flags);
 
-        vha = qla25xx_get_host(rsp);
+        vha = pci_get_drvdata(ha->pdev);
         qla24xx_process_response_queue(vha, rsp);
-        if (!ha->mqenable) {
+        if (!ha->flags.disable_msix_handshake) {
                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
                 RD_REG_DWORD_RELAXED(&reg->hccr);
         }
-        spin_unlock_irq(&ha->hardware_lock);
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         return IRQ_HANDLED;
 }
@@ -2034,6 +2050,8 @@ qla25xx_msix_rsp_q(int irq, void *dev_id)
 {
         struct qla_hw_data *ha;
         struct rsp_que *rsp;
+        struct device_reg_24xx __iomem *reg;
+        unsigned long flags;
 
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
@@ -2043,6 +2061,14 @@ qla25xx_msix_rsp_q(int irq, void *dev_id)
         }
         ha = rsp->hw;
 
+        /* Clear the interrupt, if enabled, for this response queue */
+        if (rsp->options & ~BIT_6) {
+                reg = &ha->iobase->isp24;
+                spin_lock_irqsave(&ha->hardware_lock, flags);
+                WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
+                RD_REG_DWORD_RELAXED(&reg->hccr);
+                spin_unlock_irqrestore(&ha->hardware_lock, flags);
+        }
         queue_work_on((int) (rsp->id - 1), ha->wq, &rsp->q_work);
 
         return IRQ_HANDLED;
@@ -2059,6 +2085,7 @@ qla24xx_msix_default(int irq, void *dev_id)
         uint32_t        stat;
         uint32_t        hccr;
         uint16_t        mb[4];
+        unsigned long flags;
 
         rsp = (struct rsp_que *) dev_id;
         if (!rsp) {
@@ -2070,12 +2097,12 @@ qla24xx_msix_default(int irq, void *dev_id)
         reg = &ha->iobase->isp24;
         status = 0;
 
-        spin_lock_irq(&ha->hardware_lock);
+        spin_lock_irqsave(&ha->hardware_lock, flags);
         vha = pci_get_drvdata(ha->pdev);
         do {
                 stat = RD_REG_DWORD(&reg->host_status);
                 if (stat & HSRX_RISC_PAUSED) {
-                        if (pci_channel_offline(ha->pdev))
+                        if (unlikely(pci_channel_offline(ha->pdev)))
                                 break;
 
                         hccr = RD_REG_DWORD(&reg->hccr);
@@ -2119,14 +2146,13 @@ qla24xx_msix_default(int irq, void *dev_id)
                 }
                 WRT_REG_DWORD(&reg->hccr, HCCRX_CLR_RISC_INT);
         } while (0);
-        spin_unlock_irq(&ha->hardware_lock);
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         if (test_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags) &&
             (status & MBX_INTERRUPT) && ha->flags.mbox_int) {
                 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
                 complete(&ha->mbx_intr_comp);
         }
-
         return IRQ_HANDLED;
 }
 
@@ -2246,30 +2272,28 @@ qla2x00_request_irqs(struct qla_hw_data *ha, struct rsp_que *rsp)
 
         /* If possible, enable MSI-X. */
         if (!IS_QLA2432(ha) && !IS_QLA2532(ha) &&
-            !IS_QLA8432(ha) && !IS_QLA8001(ha))
-                goto skip_msix;
+                !IS_QLA8432(ha) && !IS_QLA8001(ha))
+                goto skip_msi;
+
+        if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
+                (ha->pdev->subsystem_device == 0x7040 ||
+                ha->pdev->subsystem_device == 0x7041 ||
+                ha->pdev->subsystem_device == 0x1705)) {
+                DEBUG2(qla_printk(KERN_WARNING, ha,
+                        "MSI-X: Unsupported ISP2432 SSVID/SSDID (0x%X,0x%X).\n",
+                        ha->pdev->subsystem_vendor,
+                        ha->pdev->subsystem_device));
+                goto skip_msi;
+        }
 
         if (IS_QLA2432(ha) && (ha->pdev->revision < QLA_MSIX_CHIP_REV_24XX ||
                 !QLA_MSIX_FW_MODE_1(ha->fw_attributes))) {
                 DEBUG2(qla_printk(KERN_WARNING, ha,
                 "MSI-X: Unsupported ISP2432 (0x%X, 0x%X).\n",
                         ha->pdev->revision, ha->fw_attributes));
-
                 goto skip_msix;
         }
 
-        if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
-            (ha->pdev->subsystem_device == 0x7040 ||
-                ha->pdev->subsystem_device == 0x7041 ||
-                ha->pdev->subsystem_device == 0x1705)) {
-                DEBUG2(qla_printk(KERN_WARNING, ha,
-                    "MSI-X: Unsupported ISP2432 SSVID/SSDID (0x%X, 0x%X).\n",
-                    ha->pdev->subsystem_vendor,
-                    ha->pdev->subsystem_device));
-
-                goto skip_msi;
-        }
-
         ret = qla24xx_enable_msix(ha, rsp);
         if (!ret) {
                 DEBUG2(qla_printk(KERN_INFO, ha,
@@ -2332,10 +2356,11 @@ qla2x00_free_irqs(scsi_qla_host_t *vha)
 
         if (ha->flags.msix_enabled)
                 qla24xx_disable_msix(ha);
-        else if (ha->flags.inta_enabled) {
+        else if (ha->flags.msi_enabled) {
                 free_irq(ha->pdev->irq, rsp);
                 pci_disable_msi(ha->pdev);
-        }
+        } else
+                free_irq(ha->pdev->irq, rsp);
 }
 
 
@@ -2357,30 +2382,3 @@ int qla25xx_request_irq(struct rsp_que *rsp)
         msix->rsp = rsp;
         return ret;
 }
-
-struct scsi_qla_host *
-qla25xx_get_host(struct rsp_que *rsp)
-{
-        srb_t *sp;
-        struct qla_hw_data *ha = rsp->hw;
-        struct scsi_qla_host *vha = NULL;
-        struct sts_entry_24xx *pkt;
-        struct req_que *req;
-        uint16_t que;
-        uint32_t handle;
-
-        pkt = (struct sts_entry_24xx *) rsp->ring_ptr;
-        que = MSW(pkt->handle);
-        handle = (uint32_t) LSW(pkt->handle);
-        req = ha->req_q_map[que];
-        if (handle < MAX_OUTSTANDING_COMMANDS) {
-                sp = req->outstanding_cmds[handle];
-                if (sp)
-                        return  sp->fcport->vha;
-                else
-                        goto base_que;
-        }
-base_que:
-        vha = pci_get_drvdata(ha->pdev);
-        return vha;
-}
diff --git a/drivers/scsi/qla2xxx/qla_mbx.c b/drivers/scsi/qla2xxx/qla_mbx.c
index b6202fe118ac..42eb7ffd5942 100644
--- a/drivers/scsi/qla2xxx/qla_mbx.c
+++ b/drivers/scsi/qla2xxx/qla_mbx.c
@@ -7,6 +7,7 @@
 #include "qla_def.h"
 
 #include <linux/delay.h>
+#include <linux/gfp.h>
 
 
 /*
@@ -56,6 +57,12 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
 
         DEBUG11(printk("%s(%ld): entered.\n", __func__, base_vha->host_no));
 
+        if (ha->flags.pci_channel_io_perm_failure) {
+                DEBUG(printk("%s(%ld): Perm failure on EEH, timeout MBX "
+                             "Exiting.\n", __func__, vha->host_no));
+                return QLA_FUNCTION_TIMEOUT;
+        }
+
         /*
          * Wait for active mailbox commands to finish by waiting at most tov
          * seconds. This is to serialize actual issuing of mailbox cmds during
@@ -154,10 +161,14 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
                         /* Check for pending interrupts. */
                         qla2x00_poll(ha->rsp_q_map[0]);
 
-                        if (command != MBC_LOAD_RISC_RAM_EXTENDED &&
-                            !ha->flags.mbox_int)
+                        if (!ha->flags.mbox_int &&
+                            !(IS_QLA2200(ha) &&
+                            command == MBC_LOAD_RISC_RAM_EXTENDED))
                                 msleep(10);
                 } /* while */
+                DEBUG17(qla_printk(KERN_WARNING, ha,
+                        "Waited %d sec\n",
+                        (uint)((jiffies - (wait_time - (mcp->tov * HZ)))/HZ)));
         }
 
         /* Check whether we timed out */
@@ -227,7 +238,8 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
 
         if (rval == QLA_FUNCTION_TIMEOUT &&
             mcp->mb[0] != MBC_GEN_SYSTEM_ERROR) {
-                if (!io_lock_on || (mcp->flags & IOCTL_CMD)) {
+                if (!io_lock_on || (mcp->flags & IOCTL_CMD) ||
+                    ha->flags.eeh_busy) {
                         /* not in dpc. schedule it for dpc to take over. */
                         DEBUG(printk("%s(%ld): timeout schedule "
                         "isp_abort_needed.\n", __func__,
@@ -237,7 +249,7 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
                         base_vha->host_no));
                         qla_printk(KERN_WARNING, ha,
                             "Mailbox command timeout occurred. Scheduling ISP "
-                            "abort.\n");
+                            "abort. eeh_busy: 0x%x\n", ha->flags.eeh_busy);
                         set_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags);
                         qla2xxx_wake_dpc(vha);
                 } else if (!abort_active) {
@@ -328,6 +340,7 @@ qla2x00_load_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t risc_addr,
         return rval;
 }
 
+#define EXTENDED_BB_CREDITS     BIT_0
 /*
  * qla2x00_execute_fw
  *     Start adapter firmware.
@@ -360,7 +373,12 @@ qla2x00_execute_fw(scsi_qla_host_t *vha, uint32_t risc_addr)
                 mcp->mb[1] = MSW(risc_addr);
                 mcp->mb[2] = LSW(risc_addr);
                 mcp->mb[3] = 0;
-                mcp->mb[4] = 0;
+                if (IS_QLA81XX(ha)) {
+                        struct nvram_81xx *nv = ha->nvram;
+                        mcp->mb[4] = (nv->enhanced_features &
+                            EXTENDED_BB_CREDITS);
+                } else
+                        mcp->mb[4] = 0;
                 mcp->out_mb |= MBX_4|MBX_3|MBX_2|MBX_1;
                 mcp->in_mb |= MBX_1;
         } else {
@@ -2006,7 +2024,7 @@ qla2x00_get_id_list(scsi_qla_host_t *vha, void *id_list, dma_addr_t id_list_dma,
 int
 qla2x00_get_resource_cnts(scsi_qla_host_t *vha, uint16_t *cur_xchg_cnt,
     uint16_t *orig_xchg_cnt, uint16_t *cur_iocb_cnt,
-    uint16_t *orig_iocb_cnt, uint16_t *max_npiv_vports)
+    uint16_t *orig_iocb_cnt, uint16_t *max_npiv_vports, uint16_t *max_fcfs)
 {
         int rval;
         mbx_cmd_t mc;
@@ -2017,6 +2035,8 @@ qla2x00_get_resource_cnts(scsi_qla_host_t *vha, uint16_t *cur_xchg_cnt,
         mcp->mb[0] = MBC_GET_RESOURCE_COUNTS;
         mcp->out_mb = MBX_0;
         mcp->in_mb = MBX_11|MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
+        if (IS_QLA81XX(vha->hw))
+                mcp->in_mb |= MBX_12;
         mcp->tov = MBX_TOV_SECONDS;
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
@@ -2027,9 +2047,10 @@ qla2x00_get_resource_cnts(scsi_qla_host_t *vha, uint16_t *cur_xchg_cnt,
                     vha->host_no, mcp->mb[0]));
         } else {
                 DEBUG11(printk("%s(%ld): done. mb1=%x mb2=%x mb3=%x mb6=%x "
-                    "mb7=%x mb10=%x mb11=%x.\n", __func__, vha->host_no,
-                    mcp->mb[1], mcp->mb[2], mcp->mb[3], mcp->mb[6], mcp->mb[7],
-                    mcp->mb[10], mcp->mb[11]));
+                    "mb7=%x mb10=%x mb11=%x mb12=%x.\n", __func__,
+                    vha->host_no, mcp->mb[1], mcp->mb[2], mcp->mb[3],
+                    mcp->mb[6], mcp->mb[7], mcp->mb[10], mcp->mb[11],
+                    mcp->mb[12]));
 
                 if (cur_xchg_cnt)
                         *cur_xchg_cnt = mcp->mb[3];
@@ -2041,6 +2062,8 @@ qla2x00_get_resource_cnts(scsi_qla_host_t *vha, uint16_t *cur_xchg_cnt,
                         *orig_iocb_cnt = mcp->mb[10];
                 if (vha->hw->flags.npiv_supported && max_npiv_vports)
                         *max_npiv_vports = mcp->mb[11];
+                if (IS_QLA81XX(vha->hw) && max_fcfs)
+                        *max_fcfs = mcp->mb[12];
         }
 
         return (rval);
@@ -2313,6 +2336,7 @@ __qla24xx_issue_tmf(char *name, uint32_t type, struct fc_port *fcport,
 {
         int             rval, rval2;
         struct tsk_mgmt_cmd *tsk;
+        struct sts_entry_24xx *sts;
         dma_addr_t      tsk_dma;
         scsi_qla_host_t *vha;
         struct qla_hw_data *ha;
@@ -2352,20 +2376,37 @@ __qla24xx_issue_tmf(char *name, uint32_t type, struct fc_port *fcport,
                     sizeof(tsk->p.tsk.lun));
         }
 
+        sts = &tsk->p.sts;
         rval = qla2x00_issue_iocb(vha, tsk, tsk_dma, 0);
         if (rval != QLA_SUCCESS) {
                 DEBUG2_3_11(printk("%s(%ld): failed to issue %s Reset IOCB "
                     "(%x).\n", __func__, vha->host_no, name, rval));
-        } else if (tsk->p.sts.entry_status != 0) {
+        } else if (sts->entry_status != 0) {
                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
                     "-- error status (%x).\n", __func__, vha->host_no,
-                    tsk->p.sts.entry_status));
+                    sts->entry_status));
                 rval = QLA_FUNCTION_FAILED;
-        } else if (tsk->p.sts.comp_status !=
+        } else if (sts->comp_status !=
             __constant_cpu_to_le16(CS_COMPLETE)) {
                 DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
                     "-- completion status (%x).\n", __func__,
-                    vha->host_no, le16_to_cpu(tsk->p.sts.comp_status)));
+                    vha->host_no, le16_to_cpu(sts->comp_status)));
+                rval = QLA_FUNCTION_FAILED;
+        } else if (!(le16_to_cpu(sts->scsi_status) &
+            SS_RESPONSE_INFO_LEN_VALID)) {
+                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
+                    "-- no response info (%x).\n", __func__, vha->host_no,
+                    le16_to_cpu(sts->scsi_status)));
+                rval = QLA_FUNCTION_FAILED;
+        } else if (le32_to_cpu(sts->rsp_data_len) < 4) {
+                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
+                    "-- not enough response info (%d).\n", __func__,
+                    vha->host_no, le32_to_cpu(sts->rsp_data_len)));
+                rval = QLA_FUNCTION_FAILED;
+        } else if (sts->data[3]) {
+                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
+                    "-- response (%x).\n", __func__,
+                    vha->host_no, sts->data[3]));
                 rval = QLA_FUNCTION_FAILED;
         }
 
@@ -2507,6 +2548,9 @@ qla2x00_enable_eft_trace(scsi_qla_host_t *vha, dma_addr_t eft_dma,
         if (!IS_FWI2_CAPABLE(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
+        if (unlikely(pci_channel_offline(vha->hw->pdev)))
+                return QLA_FUNCTION_FAILED;
+
         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
 
         mcp->mb[0] = MBC_TRACE_CONTROL;
@@ -2542,6 +2586,9 @@ qla2x00_disable_eft_trace(scsi_qla_host_t *vha)
         if (!IS_FWI2_CAPABLE(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
+        if (unlikely(pci_channel_offline(vha->hw->pdev)))
+                return QLA_FUNCTION_FAILED;
+
         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
 
         mcp->mb[0] = MBC_TRACE_CONTROL;
@@ -2572,6 +2619,9 @@ qla2x00_enable_fce_trace(scsi_qla_host_t *vha, dma_addr_t fce_dma,
         if (!IS_QLA25XX(vha->hw) && !IS_QLA81XX(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
+        if (unlikely(pci_channel_offline(vha->hw->pdev)))
+                return QLA_FUNCTION_FAILED;
+
         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
 
         mcp->mb[0] = MBC_TRACE_CONTROL;
@@ -2616,6 +2666,9 @@ qla2x00_disable_fce_trace(scsi_qla_host_t *vha, uint64_t *wr, uint64_t *rd)
         if (!IS_FWI2_CAPABLE(vha->hw))
                 return QLA_FUNCTION_FAILED;
 
+        if (unlikely(pci_channel_offline(vha->hw->pdev)))
+                return QLA_FUNCTION_FAILED;
+
         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
 
         mcp->mb[0] = MBC_TRACE_CONTROL;
@@ -2759,8 +2812,10 @@ qla24xx_report_id_acquisition(scsi_qla_host_t *vha,
                     vp_idx, MSB(stat),
                     rptid_entry->port_id[2], rptid_entry->port_id[1],
                     rptid_entry->port_id[0]));
-                if (vp_idx == 0)
-                        return;
+
+                vp = vha;
+                if (vp_idx == 0 && (MSB(stat) != 1))
+                        goto reg_needed;
 
                 if (MSB(stat) == 1) {
                         DEBUG2(printk("scsi(%ld): Could not acquire ID for "
@@ -2783,8 +2838,11 @@ qla24xx_report_id_acquisition(scsi_qla_host_t *vha,
                  * response queue. Handle it in dpc context.
                  */
                 set_bit(VP_IDX_ACQUIRED, &vp->vp_flags);
-                set_bit(VP_DPC_NEEDED, &vha->dpc_flags);
 
+reg_needed:
+                set_bit(REGISTER_FC4_NEEDED, &vp->dpc_flags);
+                set_bit(REGISTER_FDMI_NEEDED, &vp->dpc_flags);
+                set_bit(VP_DPC_NEEDED, &vha->dpc_flags);
                 qla2xxx_wake_dpc(vha);
         }
 }
@@ -3585,6 +3643,157 @@ qla2x00_read_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t *data)
 }
 
 int
+qla2x00_loopback_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq, uint16_t *mresp)
+{
+        int rval;
+        mbx_cmd_t mc;
+        mbx_cmd_t *mcp = &mc;
+        uint32_t iter_cnt = 0x1;
+
+        DEBUG11(printk("scsi(%ld): entered.\n", vha->host_no));
+
+        memset(mcp->mb, 0 , sizeof(mcp->mb));
+        mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
+        mcp->mb[1] = mreq->options | BIT_6;     // BIT_6 specifies 64 bit addressing
+
+        /* transfer count */
+        mcp->mb[10] = LSW(mreq->transfer_size);
+        mcp->mb[11] = MSW(mreq->transfer_size);
+
+        /* send data address */
+        mcp->mb[14] = LSW(mreq->send_dma);
+        mcp->mb[15] = MSW(mreq->send_dma);
+        mcp->mb[20] = LSW(MSD(mreq->send_dma));
+        mcp->mb[21] = MSW(MSD(mreq->send_dma));
+
+        /* recieve data address */
+        mcp->mb[16] = LSW(mreq->rcv_dma);
+        mcp->mb[17] = MSW(mreq->rcv_dma);
+        mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
+        mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
+
+        /* Iteration count */
+        mcp->mb[18] = LSW(iter_cnt);
+        mcp->mb[19] = MSW(iter_cnt);
+
+        mcp->out_mb = MBX_21|MBX_20|MBX_19|MBX_18|MBX_17|MBX_16|MBX_15|
+            MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
+        if (IS_QLA81XX(vha->hw))
+                mcp->out_mb |= MBX_2;
+        mcp->in_mb = MBX_19|MBX_18|MBX_3|MBX_2|MBX_1|MBX_0;
+
+        mcp->buf_size = mreq->transfer_size;
+        mcp->tov = MBX_TOV_SECONDS;
+        mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
+
+        rval = qla2x00_mailbox_command(vha, mcp);
+
+        if (rval != QLA_SUCCESS) {
+                DEBUG2(printk(KERN_WARNING
+                    "(%ld): failed=%x mb[0]=0x%x "
+                        "mb[1]=0x%x mb[2]=0x%x mb[3]=0x%x mb[18]=0x%x mb[19]=0x%x. \n", vha->host_no, rval,
+                        mcp->mb[0], mcp->mb[1], mcp->mb[2], mcp->mb[3], mcp->mb[18], mcp->mb[19]));
+        } else {
+                DEBUG2(printk(KERN_WARNING
+                    "scsi(%ld): done.\n", vha->host_no));
+        }
+
+        /* Copy mailbox information */
+        memcpy( mresp, mcp->mb, 64);
+        mresp[3] = mcp->mb[18];
+        mresp[4] = mcp->mb[19];
+        return rval;
+}
+
+int
+qla2x00_echo_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq, uint16_t *mresp)
+{
+        int rval;
+        mbx_cmd_t mc;
+        mbx_cmd_t *mcp = &mc;
+        struct qla_hw_data *ha = vha->hw;
+
+        DEBUG11(printk("scsi(%ld): entered.\n", vha->host_no));
+
+        memset(mcp->mb, 0 , sizeof(mcp->mb));
+        mcp->mb[0] = MBC_DIAGNOSTIC_ECHO;
+        mcp->mb[1] = mreq->options | BIT_6;     /* BIT_6 specifies 64bit address */
+        if (IS_QLA81XX(ha))
+                mcp->mb[1] |= BIT_15;
+        mcp->mb[2] = IS_QLA81XX(ha) ? vha->fcoe_fcf_idx : 0;
+        mcp->mb[16] = LSW(mreq->rcv_dma);
+        mcp->mb[17] = MSW(mreq->rcv_dma);
+        mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
+        mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
+
+        mcp->mb[10] = LSW(mreq->transfer_size);
+
+        mcp->mb[14] = LSW(mreq->send_dma);
+        mcp->mb[15] = MSW(mreq->send_dma);
+        mcp->mb[20] = LSW(MSD(mreq->send_dma));
+        mcp->mb[21] = MSW(MSD(mreq->send_dma));
+
+        mcp->out_mb = MBX_21|MBX_20|MBX_17|MBX_16|MBX_15|
+            MBX_14|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
+        if (IS_QLA81XX(ha))
+                mcp->out_mb |= MBX_2;
+
+        mcp->in_mb = MBX_0;
+        if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha) || IS_QLA81XX(ha))
+                mcp->in_mb |= MBX_1;
+        if (IS_QLA81XX(ha))
+                mcp->in_mb |= MBX_3;
+
+        mcp->tov = MBX_TOV_SECONDS;
+        mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
+        mcp->buf_size = mreq->transfer_size;
+
+        rval = qla2x00_mailbox_command(vha, mcp);
+
+        if (rval != QLA_SUCCESS) {
+                DEBUG2(printk(KERN_WARNING
+                    "(%ld): failed=%x mb[0]=0x%x mb[1]=0x%x.\n",
+                    vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+        } else {
+                DEBUG2(printk(KERN_WARNING
+                    "scsi(%ld): done.\n", vha->host_no));
+        }
+
+        /* Copy mailbox information */
+        memcpy( mresp, mcp->mb, 32);
+        return rval;
+}
+int
+qla84xx_reset_chip(scsi_qla_host_t *ha, uint16_t enable_diagnostic,
+    uint16_t *cmd_status)
+{
+        int rval;
+        mbx_cmd_t mc;
+        mbx_cmd_t *mcp = &mc;
+
+        DEBUG16(printk("%s(%ld): enable_diag=%d entered.\n", __func__,
+                ha->host_no, enable_diagnostic));
+
+        mcp->mb[0] = MBC_ISP84XX_RESET;
+        mcp->mb[1] = enable_diagnostic;
+        mcp->out_mb = MBX_1|MBX_0;
+        mcp->in_mb = MBX_1|MBX_0;
+        mcp->tov = MBX_TOV_SECONDS;
+        mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
+        rval = qla2x00_mailbox_command(ha, mcp);
+
+        /* Return mailbox statuses. */
+        *cmd_status = mcp->mb[0];
+        if (rval != QLA_SUCCESS)
+                DEBUG16(printk("%s(%ld): failed=%x.\n", __func__, ha->host_no,
+                        rval));
+        else
+                DEBUG16(printk("%s(%ld): done.\n", __func__, ha->host_no));
+
+        return rval;
+}
+
+int
 qla2x00_write_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t data)
 {
         int rval;
@@ -3615,3 +3824,36 @@ qla2x00_write_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t data)
 
         return rval;
 }
+
+int
+qla2x00_get_data_rate(scsi_qla_host_t *vha)
+{
+        int rval;
+        mbx_cmd_t mc;
+        mbx_cmd_t *mcp = &mc;
+        struct qla_hw_data *ha = vha->hw;
+
+        if (!IS_FWI2_CAPABLE(ha))
+                return QLA_FUNCTION_FAILED;
+
+        DEBUG11(printk(KERN_INFO "%s(%ld): entered.\n", __func__, vha->host_no));
+
+        mcp->mb[0] = MBC_DATA_RATE;
+        mcp->mb[1] = 0;
+        mcp->out_mb = MBX_1|MBX_0;
+        mcp->in_mb = MBX_2|MBX_1|MBX_0;
+        mcp->tov = MBX_TOV_SECONDS;
+        mcp->flags = 0;
+        rval = qla2x00_mailbox_command(vha, mcp);
+        if (rval != QLA_SUCCESS) {
+                DEBUG2_3_11(printk(KERN_INFO "%s(%ld): failed=%x mb[0]=%x.\n",
+                    __func__, vha->host_no, rval, mcp->mb[0]));
+        } else {
+                DEBUG11(printk(KERN_INFO
+                    "%s(%ld): done.\n", __func__, vha->host_no));
+                if (mcp->mb[1] != 0x7)
+                        ha->link_data_rate = mcp->mb[1];
+        }
+
+        return rval;
+}
diff --git a/drivers/scsi/qla2xxx/qla_mid.c b/drivers/scsi/qla2xxx/qla_mid.c
index e07b3617f019..8220e7b9799b 100644
--- a/drivers/scsi/qla2xxx/qla_mid.c
+++ b/drivers/scsi/qla2xxx/qla_mid.c
@@ -9,6 +9,7 @@
 
 #include <linux/moduleparam.h>
 #include <linux/vmalloc.h>
+#include <linux/slab.h>
 #include <linux/list.h>
 
 #include <scsi/scsi_tcq.h>
@@ -382,8 +383,6 @@ qla24xx_create_vhost(struct fc_vport *fc_vport)
         vha->mgmt_svr_loop_id = 10 + vha->vp_idx;
 
         vha->dpc_flags = 0L;
-        set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
-        set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
 
         /*
          * To fix the issue of processing a parent's RSCN for the vport before
@@ -638,11 +637,15 @@ failed:
 
 static void qla_do_work(struct work_struct *work)
 {
+        unsigned long flags;
         struct rsp_que *rsp = container_of(work, struct rsp_que, q_work);
         struct scsi_qla_host *vha;
+        struct qla_hw_data *ha = rsp->hw;
 
-        vha = qla25xx_get_host(rsp);
+        spin_lock_irqsave(&rsp->hw->hardware_lock, flags);
+        vha = pci_get_drvdata(ha->pdev);
         qla24xx_process_response_queue(vha, rsp);
+        spin_unlock_irqrestore(&rsp->hw->hardware_lock, flags);
 }
 
 /* create response queue */
@@ -698,6 +701,10 @@ qla25xx_create_rsp_que(struct qla_hw_data *ha, uint16_t options,
         /* Use alternate PCI devfn */
         if (LSB(rsp->rid))
                 options |= BIT_5;
+        /* Enable MSIX handshake mode on for uncapable adapters */
+        if (!IS_MSIX_NACK_CAPABLE(ha))
+                options |= BIT_6;
+
         rsp->options = options;
         rsp->id = que_id;
         reg = ISP_QUE_REG(ha, que_id);
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index b79fca7d461b..48c37e38ed01 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -11,6 +11,8 @@
 #include <linux/delay.h>
 #include <linux/kthread.h>
 #include <linux/mutex.h>
+#include <linux/kobject.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi_tcq.h>
 #include <scsi/scsicam.h>
@@ -77,21 +79,6 @@ module_param(ql2xmaxqdepth, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(ql2xmaxqdepth,
                 "Maximum queue depth to report for target devices.");
 
-int ql2xqfulltracking = 1;
-module_param(ql2xqfulltracking, int, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(ql2xqfulltracking,
-                "Controls whether the driver tracks queue full status "
-                "returns and dynamically adjusts a scsi device's queue "
-                "depth.  Default is 1, perform tracking.  Set to 0 to "
-                "disable dynamic tracking and adjustment of queue depth.");
-
-int ql2xqfullrampup = 120;
-module_param(ql2xqfullrampup, int, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(ql2xqfullrampup,
-                "Number of seconds to wait to begin to ramp-up the queue "
-                "depth for a device after a queue-full condition has been "
-                "detected.  Default is 120 seconds.");
-
 int ql2xiidmaenable=1;
 module_param(ql2xiidmaenable, int, S_IRUGO|S_IRUSR);
 MODULE_PARM_DESC(ql2xiidmaenable,
@@ -121,6 +108,12 @@ MODULE_PARM_DESC(ql2xfwloadbin,
                 " 1 -- load firmware from flash.\n"
                 " 0 -- use default semantics.\n");
 
+int ql2xetsenable;
+module_param(ql2xetsenable, int, S_IRUGO|S_IRUSR);
+MODULE_PARM_DESC(ql2xetsenable,
+                "Enables firmware ETS burst."
+                "Default is 0 - skip ETS enablement.");
+
 /*
  * SCSI host template entry points
  */
@@ -137,7 +130,7 @@ static int qla2xxx_eh_target_reset(struct scsi_cmnd *);
 static int qla2xxx_eh_bus_reset(struct scsi_cmnd *);
 static int qla2xxx_eh_host_reset(struct scsi_cmnd *);
 
-static int qla2x00_change_queue_depth(struct scsi_device *, int);
+static int qla2x00_change_queue_depth(struct scsi_device *, int, int);
 static int qla2x00_change_queue_type(struct scsi_device *, int);
 
 struct scsi_host_template qla2xxx_driver_template = {
@@ -489,11 +482,11 @@ qla2xxx_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
         srb_t *sp;
         int rval;
 
-        if (unlikely(pci_channel_offline(ha->pdev))) {
-                if (ha->pdev->error_state == pci_channel_io_frozen)
-                        cmd->result = DID_REQUEUE << 16;
-                else
+        if (ha->flags.eeh_busy) {
+                if (ha->flags.pci_channel_io_perm_failure)
                         cmd->result = DID_NO_CONNECT << 16;
+                else
+                        cmd->result = DID_REQUEUE << 16;
                 goto qc24_fail_command;
         }
 
@@ -566,8 +559,15 @@ qla2x00_eh_wait_on_command(struct scsi_cmnd *cmd)
 #define ABORT_POLLING_PERIOD    1000
 #define ABORT_WAIT_ITER         ((10 * 1000) / (ABORT_POLLING_PERIOD))
         unsigned long wait_iter = ABORT_WAIT_ITER;
+        scsi_qla_host_t *vha = shost_priv(cmd->device->host);
+        struct qla_hw_data *ha = vha->hw;
         int ret = QLA_SUCCESS;
 
+        if (unlikely(pci_channel_offline(ha->pdev)) || ha->flags.eeh_busy) {
+                DEBUG17(qla_printk(KERN_WARNING, ha, "return:eh_wait\n"));
+                return ret;
+        }
+
         while (CMD_SP(cmd) && wait_iter--) {
                 msleep(ABORT_POLLING_PERIOD);
         }
@@ -689,61 +689,6 @@ qla2x00_wait_for_loop_ready(scsi_qla_host_t *vha)
         return (return_status);
 }
 
-void
-qla2x00_abort_fcport_cmds(fc_port_t *fcport)
-{
-        int cnt;
-        unsigned long flags;
-        srb_t *sp;
-        scsi_qla_host_t *vha = fcport->vha;
-        struct qla_hw_data *ha = vha->hw;
-        struct req_que *req;
-
-        spin_lock_irqsave(&ha->hardware_lock, flags);
-        req = vha->req;
-        for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
-                sp = req->outstanding_cmds[cnt];
-                if (!sp)
-                        continue;
-                if (sp->fcport != fcport)
-                        continue;
-                if (sp->ctx)
-                        continue;
-
-                spin_unlock_irqrestore(&ha->hardware_lock, flags);
-                if (ha->isp_ops->abort_command(sp)) {
-                        DEBUG2(qla_printk(KERN_WARNING, ha,
-                        "Abort failed --  %lx\n",
-                        sp->cmd->serial_number));
-                } else {
-                        if (qla2x00_eh_wait_on_command(sp->cmd) !=
-                                QLA_SUCCESS)
-                                DEBUG2(qla_printk(KERN_WARNING, ha,
-                                "Abort failed while waiting --  %lx\n",
-                                sp->cmd->serial_number));
-                }
-                spin_lock_irqsave(&ha->hardware_lock, flags);
-        }
-        spin_unlock_irqrestore(&ha->hardware_lock, flags);
-}
-
-static void
-qla2x00_block_error_handler(struct scsi_cmnd *cmnd)
-{
-        struct Scsi_Host *shost = cmnd->device->host;
-        struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
-        unsigned long flags;
-
-        spin_lock_irqsave(shost->host_lock, flags);
-        while (rport->port_state == FC_PORTSTATE_BLOCKED) {
-                spin_unlock_irqrestore(shost->host_lock, flags);
-                msleep(1000);
-                spin_lock_irqsave(shost->host_lock, flags);
-        }
-        spin_unlock_irqrestore(shost->host_lock, flags);
-        return;
-}
-
 /**************************************************************************
 * qla2xxx_eh_abort
 *
@@ -773,7 +718,7 @@ qla2xxx_eh_abort(struct scsi_cmnd *cmd)
         struct req_que *req = vha->req;
         srb_t *spt;
 
-        qla2x00_block_error_handler(cmd);
+        fc_block_scsi_eh(cmd);
 
         if (!CMD_SP(cmd))
                 return SUCCESS;
@@ -904,7 +849,7 @@ __qla2xxx_eh_generic_reset(char *name, enum nexus_wait_type type,
         fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
         int err;
 
-        qla2x00_block_error_handler(cmd);
+        fc_block_scsi_eh(cmd);
 
         if (!fcport)
                 return FAILED;
@@ -984,7 +929,7 @@ qla2xxx_eh_bus_reset(struct scsi_cmnd *cmd)
         unsigned long serial;
         srb_t *sp = (srb_t *) CMD_SP(cmd);
 
-        qla2x00_block_error_handler(cmd);
+        fc_block_scsi_eh(cmd);
 
         id = cmd->device->id;
         lun = cmd->device->lun;
@@ -1047,7 +992,7 @@ qla2xxx_eh_host_reset(struct scsi_cmnd *cmd)
         srb_t *sp = (srb_t *) CMD_SP(cmd);
         scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
 
-        qla2x00_block_error_handler(cmd);
+        fc_block_scsi_eh(cmd);
 
         id = cmd->device->id;
         lun = cmd->device->lun;
@@ -1119,6 +1064,20 @@ qla2x00_loop_reset(scsi_qla_host_t *vha)
         struct fc_port *fcport;
         struct qla_hw_data *ha = vha->hw;
 
+        if (ha->flags.enable_target_reset) {
+                list_for_each_entry(fcport, &vha->vp_fcports, list) {
+                        if (fcport->port_type != FCT_TARGET)
+                                continue;
+
+                        ret = ha->isp_ops->target_reset(fcport, 0, 0);
+                        if (ret != QLA_SUCCESS) {
+                                DEBUG2_3(printk("%s(%ld): bus_reset failed: "
+                                    "target_reset=%d d_id=%x.\n", __func__,
+                                    vha->host_no, ret, fcport->d_id.b24));
+                        }
+                }
+        }
+
         if (ha->flags.enable_lip_full_login && !IS_QLA81XX(ha)) {
                 ret = qla2x00_full_login_lip(vha);
                 if (ret != QLA_SUCCESS) {
@@ -1141,19 +1100,6 @@ qla2x00_loop_reset(scsi_qla_host_t *vha)
                         qla2x00_wait_for_loop_ready(vha);
         }
 
-        if (ha->flags.enable_target_reset) {
-                list_for_each_entry(fcport, &vha->vp_fcports, list) {
-                        if (fcport->port_type != FCT_TARGET)
-                                continue;
-
-                        ret = ha->isp_ops->target_reset(fcport, 0, 0);
-                        if (ret != QLA_SUCCESS) {
-                                DEBUG2_3(printk("%s(%ld): bus_reset failed: "
-                                    "target_reset=%d d_id=%x.\n", __func__,
-                                    vha->host_no, ret, fcport->d_id.b24));
-                        }
-                }
-        }
         /* Issue marker command only when we are going to start the I/O */
         vha->marker_needed = 1;
 
@@ -1184,8 +1130,19 @@ qla2x00_abort_all_cmds(scsi_qla_host_t *vha, int res)
                                         qla2x00_sp_compl(ha, sp);
                                 } else {
                                         ctx = sp->ctx;
-                                        del_timer_sync(&ctx->timer);
-                                        ctx->free(sp);
+                                        if (ctx->type == SRB_LOGIN_CMD || ctx->type == SRB_LOGOUT_CMD) {
+                                                del_timer_sync(&ctx->timer);
+                                                ctx->free(sp);
+                                        } else {
+                                                struct srb_bsg* sp_bsg = (struct srb_bsg*)sp->ctx;
+                                                if (sp_bsg->bsg_job->request->msgcode == FC_BSG_HST_CT)
+                                                        kfree(sp->fcport);
+                                                sp_bsg->bsg_job->req->errors = 0;
+                                                sp_bsg->bsg_job->reply->result = res;
+                                                sp_bsg->bsg_job->job_done(sp_bsg->bsg_job);
+                                                kfree(sp->ctx);
+                                                mempool_free(sp, ha->srb_mempool);
+                                        }
                                 }
                         }
                 }
@@ -1212,7 +1169,6 @@ qla2xxx_slave_configure(struct scsi_device *sdev)
         scsi_qla_host_t *vha = shost_priv(sdev->host);
         struct qla_hw_data *ha = vha->hw;
         struct fc_rport *rport = starget_to_rport(sdev->sdev_target);
-        fc_port_t *fcport = *(fc_port_t **)rport->dd_data;
         struct req_que *req = vha->req;
 
         if (sdev->tagged_supported)
@@ -1221,8 +1177,6 @@ qla2xxx_slave_configure(struct scsi_device *sdev)
                 scsi_deactivate_tcq(sdev, req->max_q_depth);
 
         rport->dev_loss_tmo = ha->port_down_retry_count;
-        if (sdev->type == TYPE_TAPE)
-                fcport->flags |= FCF_TAPE_PRESENT;
 
         return 0;
 }
@@ -1233,10 +1187,61 @@ qla2xxx_slave_destroy(struct scsi_device *sdev)
         sdev->hostdata = NULL;
 }
 
+static void qla2x00_handle_queue_full(struct scsi_device *sdev, int qdepth)
+{
+        fc_port_t *fcport = (struct fc_port *) sdev->hostdata;
+
+        if (!scsi_track_queue_full(sdev, qdepth))
+                return;
+
+        DEBUG2(qla_printk(KERN_INFO, fcport->vha->hw,
+                "scsi(%ld:%d:%d:%d): Queue depth adjusted-down to %d.\n",
+                fcport->vha->host_no, sdev->channel, sdev->id, sdev->lun,
+                sdev->queue_depth));
+}
+
+static void qla2x00_adjust_sdev_qdepth_up(struct scsi_device *sdev, int qdepth)
+{
+        fc_port_t *fcport = sdev->hostdata;
+        struct scsi_qla_host *vha = fcport->vha;
+        struct qla_hw_data *ha = vha->hw;
+        struct req_que *req = NULL;
+
+        req = vha->req;
+        if (!req)
+                return;
+
+        if (req->max_q_depth <= sdev->queue_depth || req->max_q_depth < qdepth)
+                return;
+
+        if (sdev->ordered_tags)
+                scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, qdepth);
+        else
+                scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, qdepth);
+
+        DEBUG2(qla_printk(KERN_INFO, ha,
+               "scsi(%ld:%d:%d:%d): Queue depth adjusted-up to %d.\n",
+               fcport->vha->host_no, sdev->channel, sdev->id, sdev->lun,
+               sdev->queue_depth));
+}
+
 static int
-qla2x00_change_queue_depth(struct scsi_device *sdev, int qdepth)
+qla2x00_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
 {
-        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+        switch (reason) {
+        case SCSI_QDEPTH_DEFAULT:
+                scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
+                break;
+        case SCSI_QDEPTH_QFULL:
+                qla2x00_handle_queue_full(sdev, qdepth);
+                break;
+        case SCSI_QDEPTH_RAMP_UP:
+                qla2x00_adjust_sdev_qdepth_up(sdev, qdepth);
+                break;
+        default:
+                return -EOPNOTSUPP;
+        }
+
         return sdev->queue_depth;
 }
 
@@ -1672,9 +1677,11 @@ skip_pio:
 
         /* Determine queue resources */
         ha->max_req_queues = ha->max_rsp_queues = 1;
-        if ((ql2xmaxqueues <= 1 || ql2xmultique_tag < 1) &&
+        if ((ql2xmaxqueues <= 1 && !ql2xmultique_tag) ||
+                (ql2xmaxqueues > 1 && ql2xmultique_tag) ||
                 (!IS_QLA25XX(ha) && !IS_QLA81XX(ha)))
                 goto mqiobase_exit;
+
         ha->mqiobase = ioremap(pci_resource_start(ha->pdev, 3),
                         pci_resource_len(ha->pdev, 3));
         if (ha->mqiobase) {
@@ -1790,6 +1797,12 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
 
         /* Set ISP-type information. */
         qla2x00_set_isp_flags(ha);
+
+        /* Set EEH reset type to fundamental if required by hba */
+        if ( IS_QLA24XX(ha) || IS_QLA25XX(ha) || IS_QLA81XX(ha)) {
+                pdev->needs_freset = 1;
+        }
+
         /* Configure PCI I/O space */
         ret = qla2x00_iospace_config(ha);
         if (ret)
@@ -1939,11 +1952,15 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         host->max_channel = MAX_BUSES - 1;
         host->max_lun = MAX_LUNS;
         host->transportt = qla2xxx_transport_template;
+        sht->vendor_id = (SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_QLOGIC);
 
         /* Set up the irqs */
         ret = qla2x00_request_irqs(ha, rsp);
         if (ret)
                 goto probe_init_failed;
+
+        pci_save_state(pdev);
+
         /* Alloc arrays of request and response ring ptrs */
 que_init:
         if (!qla2x00_alloc_queues(ha)) {
@@ -2016,13 +2033,13 @@ skip_dpc:
         DEBUG2(printk("DEBUG: detect hba %ld at address = %p\n",
             base_vha->host_no, ha));
 
-        base_vha->flags.init_done = 1;
-        base_vha->flags.online = 1;
-
         ret = scsi_add_host(host, &pdev->dev);
         if (ret)
                 goto probe_failed;
 
+        base_vha->flags.init_done = 1;
+        base_vha->flags.online = 1;
+
         ha->isp_ops->enable_intrs(ha);
 
         scsi_scan_host(host);
@@ -2145,6 +2162,8 @@ qla2x00_remove_one(struct pci_dev *pdev)
         kfree(ha);
         ha = NULL;
 
+        pci_disable_pcie_error_reporting(pdev);
+
         pci_disable_device(pdev);
         pci_set_drvdata(pdev, NULL);
 }
@@ -2154,6 +2173,24 @@ qla2x00_free_device(scsi_qla_host_t *vha)
 {
         struct qla_hw_data *ha = vha->hw;
 
+        qla2x00_abort_all_cmds(vha, DID_NO_CONNECT << 16);
+
+        /* Disable timer */
+        if (vha->timer_active)
+                qla2x00_stop_timer(vha);
+
+        /* Kill the kernel thread for this host */
+        if (ha->dpc_thread) {
+                struct task_struct *t = ha->dpc_thread;
+
+                /*
+                 * qla2xxx_wake_dpc checks for ->dpc_thread
+                 * so we need to zero it out.
+                 */
+                ha->dpc_thread = NULL;
+                kthread_stop(t);
+        }
+
         qla25xx_delete_queues(vha);
 
         if (ha->flags.fce_enabled)
@@ -2165,6 +2202,8 @@ qla2x00_free_device(scsi_qla_host_t *vha)
         /* Stop currently executing firmware. */
         qla2x00_try_to_stop_firmware(vha);
 
+        vha->flags.online = 0;
+
         /* turn-off interrupts on the card */
         if (ha->interrupts_on)
                 ha->isp_ops->disable_intrs(ha);
@@ -2653,6 +2692,37 @@ qla2x00_post_async_work(login_done, QLA_EVT_ASYNC_LOGIN_DONE);
 qla2x00_post_async_work(logout, QLA_EVT_ASYNC_LOGOUT);
 qla2x00_post_async_work(logout_done, QLA_EVT_ASYNC_LOGOUT_DONE);
 
+int
+qla2x00_post_uevent_work(struct scsi_qla_host *vha, u32 code)
+{
+        struct qla_work_evt *e;
+
+        e = qla2x00_alloc_work(vha, QLA_EVT_UEVENT);
+        if (!e)
+                return QLA_FUNCTION_FAILED;
+
+        e->u.uevent.code = code;
+        return qla2x00_post_work(vha, e);
+}
+
+static void
+qla2x00_uevent_emit(struct scsi_qla_host *vha, u32 code)
+{
+        char event_string[40];
+        char *envp[] = { event_string, NULL };
+
+        switch (code) {
+        case QLA_UEVENT_CODE_FW_DUMP:
+                snprintf(event_string, sizeof(event_string), "FW_DUMP=%ld",
+                    vha->host_no);
+                break;
+        default:
+                /* do nothing */
+                break;
+        }
+        kobject_uevent_env(&vha->hw->pdev->dev.kobj, KOBJ_CHANGE, envp);
+}
+
 void
 qla2x00_do_work(struct scsi_qla_host *vha)
 {
@@ -2690,6 +2760,9 @@ qla2x00_do_work(struct scsi_qla_host *vha)
                         qla2x00_async_logout_done(vha, e->u.logio.fcport,
                             e->u.logio.data);
                         break;
+                case QLA_EVT_UEVENT:
+                        qla2x00_uevent_emit(vha, e->u.uevent.code);
+                        break;
                 }
                 if (e->flags & QLA_EVT_FLAG_FREE)
                         kfree(e);
@@ -2717,7 +2790,7 @@ void qla2x00_relogin(struct scsi_qla_host *vha)
 
                         fcport->login_retry--;
                         if (fcport->flags & FCF_FABRIC_DEVICE) {
-                                if (fcport->flags & FCF_TAPE_PRESENT)
+                                if (fcport->flags & FCF_FCP2_DEVICE)
                                         ha->isp_ops->fabric_logout(vha,
                                                         fcport->loop_id,
                                                         fcport->d_id.b.domain,
@@ -2805,6 +2878,13 @@ qla2x00_do_dpc(void *data)
                 if (!base_vha->flags.init_done)
                         continue;
 
+                if (ha->flags.eeh_busy) {
+                        DEBUG17(qla_printk(KERN_WARNING, ha,
+                            "qla2x00_do_dpc: dpc_flags: %lx\n",
+                            base_vha->dpc_flags));
+                        continue;
+                }
+
                 DEBUG3(printk("scsi(%ld): DPC handler\n", base_vha->host_no));
 
                 ha->dpc_active = 1;
@@ -2995,8 +3075,13 @@ qla2x00_timer(scsi_qla_host_t *vha)
         int             index;
         srb_t           *sp;
         int             t;
+        uint16_t        w;
         struct qla_hw_data *ha = vha->hw;
         struct req_que *req;
+
+        /* Hardware read to raise pending EEH errors during mailbox waits. */
+        if (!pci_channel_offline(ha->pdev))
+                pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w);
         /*
          * Ports - Port down timer.
          *
@@ -3041,7 +3126,10 @@ qla2x00_timer(scsi_qla_host_t *vha)
                         if (!IS_QLA2100(ha) && vha->link_down_timeout)
                                 atomic_set(&vha->loop_state, LOOP_DEAD);
 
-                        /* Schedule an ISP abort to return any tape commands. */
+                        /*
+                         * Schedule an ISP abort to return any FCP2-device
+                         * commands.
+                         */
                         /* NPIV - scan physical port only */
                         if (!vha->vp_idx) {
                                 spin_lock_irqsave(&ha->hardware_lock,
@@ -3058,7 +3146,7 @@ qla2x00_timer(scsi_qla_host_t *vha)
                                         if (sp->ctx)
                                                 continue;
                                         sfcp = sp->fcport;
-                                        if (!(sfcp->flags & FCF_TAPE_PRESENT))
+                                        if (!(sfcp->flags & FCF_FCP2_DEVICE))
                                                 continue;
 
                                         set_bit(ISP_ABORT_NEEDED,
@@ -3198,16 +3286,24 @@ qla2x00_release_firmware(void)
 static pci_ers_result_t
 qla2xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
 {
-        scsi_qla_host_t *base_vha = pci_get_drvdata(pdev);
+        scsi_qla_host_t *vha = pci_get_drvdata(pdev);
+        struct qla_hw_data *ha = vha->hw;
+
+        DEBUG2(qla_printk(KERN_WARNING, ha, "error_detected:state %x\n",
+            state));
 
         switch (state) {
         case pci_channel_io_normal:
+                ha->flags.eeh_busy = 0;
                 return PCI_ERS_RESULT_CAN_RECOVER;
         case pci_channel_io_frozen:
+                ha->flags.eeh_busy = 1;
+                qla2x00_free_irqs(vha);
                 pci_disable_device(pdev);
                 return PCI_ERS_RESULT_NEED_RESET;
         case pci_channel_io_perm_failure:
-                qla2x00_abort_all_cmds(base_vha, DID_NO_CONNECT << 16);
+                ha->flags.pci_channel_io_perm_failure = 1;
+                qla2x00_abort_all_cmds(vha, DID_NO_CONNECT << 16);
                 return PCI_ERS_RESULT_DISCONNECT;
         }
         return PCI_ERS_RESULT_NEED_RESET;
@@ -3256,7 +3352,23 @@ qla2xxx_pci_slot_reset(struct pci_dev *pdev)
         pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT;
         scsi_qla_host_t *base_vha = pci_get_drvdata(pdev);
         struct qla_hw_data *ha = base_vha->hw;
-        int rc;
+        struct rsp_que *rsp;
+        int rc, retries = 10;
+
+        DEBUG17(qla_printk(KERN_WARNING, ha, "slot_reset\n"));
+
+        /* Workaround: qla2xxx driver which access hardware earlier
+         * needs error state to be pci_channel_io_online.
+         * Otherwise mailbox command timesout.
+         */
+        pdev->error_state = pci_channel_io_normal;
+
+        pci_restore_state(pdev);
+
+        /* pci_restore_state() clears the saved_state flag of the device
+         * save restored state which resets saved_state flag
+         */
+        pci_save_state(pdev);
 
         if (ha->mem_only)
                 rc = pci_enable_device_mem(pdev);
@@ -3266,19 +3378,29 @@ qla2xxx_pci_slot_reset(struct pci_dev *pdev)
         if (rc) {
                 qla_printk(KERN_WARNING, ha,
                     "Can't re-enable PCI device after reset.\n");
-
                 return ret;
         }
-        pci_set_master(pdev);
+
+        rsp = ha->rsp_q_map[0];
+        if (qla2x00_request_irqs(ha, rsp))
+                return ret;
 
         if (ha->isp_ops->pci_config(base_vha))
                 return ret;
 
+        while (ha->flags.mbox_busy && retries--)
+                msleep(1000);
+
         set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
         if (qla2x00_abort_isp(base_vha) == QLA_SUCCESS)
                 ret =  PCI_ERS_RESULT_RECOVERED;
         clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
 
+        pci_cleanup_aer_uncorrect_error_status(pdev);
+
+        DEBUG17(qla_printk(KERN_WARNING, ha,
+            "slot_reset-return:ret=%x\n", ret));
+
         return ret;
 }
 
@@ -3289,13 +3411,16 @@ qla2xxx_pci_resume(struct pci_dev *pdev)
         struct qla_hw_data *ha = base_vha->hw;
         int ret;
 
+        DEBUG17(qla_printk(KERN_WARNING, ha, "pci_resume\n"));
+
         ret = qla2x00_wait_for_hba_online(base_vha);
         if (ret != QLA_SUCCESS) {
                 qla_printk(KERN_ERR, ha,
                     "the device failed to resume I/O "
                     "from slot/link_reset");
         }
-        pci_cleanup_aer_uncorrect_error_status(pdev);
+
+        ha->flags.eeh_busy = 0;
 }
 
 static struct pci_error_handlers qla2xxx_err_handler = {
@@ -3408,4 +3533,3 @@ MODULE_FIRMWARE(FW_FILE_ISP2300);
 MODULE_FIRMWARE(FW_FILE_ISP2322);
 MODULE_FIRMWARE(FW_FILE_ISP24XX);
 MODULE_FIRMWARE(FW_FILE_ISP25XX);
-MODULE_FIRMWARE(FW_FILE_ISP81XX);
diff --git a/drivers/scsi/qla2xxx/qla_sup.c b/drivers/scsi/qla2xxx/qla_sup.c
index 010e69b29afe..8b3de4e54c28 100644
--- a/drivers/scsi/qla2xxx/qla_sup.c
+++ b/drivers/scsi/qla2xxx/qla_sup.c
@@ -7,6 +7,7 @@
 #include "qla_def.h"
 
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <asm/uaccess.h>
 
@@ -2292,11 +2293,14 @@ qla25xx_read_optrom_data(struct scsi_qla_host *vha, uint8_t *buf,
         uint32_t faddr, left, burst;
         struct qla_hw_data *ha = vha->hw;
 
+        if (IS_QLA25XX(ha) || IS_QLA81XX(ha))
+                goto try_fast;
         if (offset & 0xfff)
                 goto slow_read;
         if (length < OPTROM_BURST_SIZE)
                 goto slow_read;
 
+try_fast:
         optrom = dma_alloc_coherent(&ha->pdev->dev, OPTROM_BURST_SIZE,
             &optrom_dma, GFP_KERNEL);
         if (!optrom) {
diff --git a/drivers/scsi/qla2xxx/qla_version.h b/drivers/scsi/qla2xxx/qla_version.h
index ac107a2c34a4..109068df933f 100644
--- a/drivers/scsi/qla2xxx/qla_version.h
+++ b/drivers/scsi/qla2xxx/qla_version.h
@@ -7,9 +7,9 @@
 /*
  * Driver version
  */
-#define QLA2XXX_VERSION      "8.03.01-k6"
+#define QLA2XXX_VERSION      "8.03.02-k2"
 
 #define QLA_DRIVER_MAJOR_VER    8
 #define QLA_DRIVER_MINOR_VER    3
-#define QLA_DRIVER_PATCH_VER    1
-#define QLA_DRIVER_BETA_VER     0
+#define QLA_DRIVER_PATCH_VER    2
+#define QLA_DRIVER_BETA_VER     2
diff --git a/drivers/scsi/qla4xxx/ql4_init.c b/drivers/scsi/qla4xxx/ql4_init.c
index af8c3233e8ae..92329a461c68 100644
--- a/drivers/scsi/qla4xxx/ql4_init.c
+++ b/drivers/scsi/qla4xxx/ql4_init.c
@@ -844,10 +844,10 @@ static int qla4xxx_config_nvram(struct scsi_qla_host *ha)
         DEBUG2(printk("scsi%ld: %s: Get EEProm parameters \n", ha->host_no,
                       __func__));
         if (ql4xxx_lock_flash(ha) != QLA_SUCCESS)
-                return (QLA_ERROR);
+                return QLA_ERROR;
         if (ql4xxx_lock_nvram(ha) != QLA_SUCCESS) {
                 ql4xxx_unlock_flash(ha);
-                return (QLA_ERROR);
+                return QLA_ERROR;
         }
 
         /* Get EEPRom Parameters from NVRAM and validate */
@@ -858,20 +858,18 @@ static int qla4xxx_config_nvram(struct scsi_qla_host *ha)
                         rd_nvram_word(ha, eeprom_ext_hw_conf_offset(ha));
                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
         } else {
-                /*
-                 * QLogic adapters should always have a valid NVRAM.
-                 * If not valid, do not load.
-                 */
                 dev_warn(&ha->pdev->dev,
                            "scsi%ld: %s: EEProm checksum invalid.  "
                            "Please update your EEPROM\n", ha->host_no,
                            __func__);
 
-                /* set defaults */
+                /* Attempt to set defaults */
                 if (is_qla4010(ha))
                         extHwConfig.Asuint32_t = 0x1912;
                 else if (is_qla4022(ha) | is_qla4032(ha))
                         extHwConfig.Asuint32_t = 0x0023;
+                else
+                        return QLA_ERROR;
         }
         DEBUG(printk("scsi%ld: %s: Setting extHwConfig to 0xFFFF%04x\n",
                      ha->host_no, __func__, extHwConfig.Asuint32_t));
@@ -884,7 +882,7 @@ static int qla4xxx_config_nvram(struct scsi_qla_host *ha)
         ql4xxx_unlock_nvram(ha);
         ql4xxx_unlock_flash(ha);
 
-        return (QLA_SUCCESS);
+        return QLA_SUCCESS;
 }
 
 static void qla4x00_pci_config(struct scsi_qla_host *ha)
diff --git a/drivers/scsi/qla4xxx/ql4_mbx.c b/drivers/scsi/qla4xxx/ql4_mbx.c
index 09d6d4b76f39..caeb7d10ae04 100644
--- a/drivers/scsi/qla4xxx/ql4_mbx.c
+++ b/drivers/scsi/qla4xxx/ql4_mbx.c
@@ -467,7 +467,7 @@ int qla4xxx_get_fwddb_entry(struct scsi_qla_host *ha,
         if (conn_err_detail)
                 *conn_err_detail = mbox_sts[5];
         if (tcp_source_port_num)
-                *tcp_source_port_num = (uint16_t) mbox_sts[6] >> 16;
+                *tcp_source_port_num = (uint16_t) (mbox_sts[6] >> 16);
         if (connection_id)
                 *connection_id = (uint16_t) mbox_sts[6] & 0x00FF;
         status = QLA_SUCCESS;
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index 83c8b5e4fc8b..2ccad36bee9f 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -5,6 +5,7 @@
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
 #include <linux/moduleparam.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi_tcq.h>
 #include <scsi/scsicam.h>
diff --git a/drivers/scsi/qlogicpti.c b/drivers/scsi/qlogicpti.c
index fa34b92850a6..aa406497eebc 100644
--- a/drivers/scsi/qlogicpti.c
+++ b/drivers/scsi/qlogicpti.c
@@ -16,7 +16,7 @@
 #include <linux/delay.h>
 #include <linux/types.h>
 #include <linux/string.h>
-#include <linux/slab.h>
+#include <linux/gfp.h>
 #include <linux/blkdev.h>
 #include <linux/proc_fs.h>
 #include <linux/stat.h>
@@ -738,7 +738,7 @@ static int __devinit qpti_register_irq(struct qlogicpti *qpti)
          * sanely maintain.
          */
         if (request_irq(qpti->irq, qpti_intr,
-                        IRQF_SHARED, "Qlogic/PTI", qpti))
+                        IRQF_SHARED, "QlogicPTI", qpti))
                 goto fail;
 
         printk("qlogicpti%d: IRQ %d ", qpti->qpti_id, qpti->irq);
diff --git a/drivers/scsi/qlogicpti.h b/drivers/scsi/qlogicpti.h
index 9c053bbaa877..e3c74d1ee2db 100644
--- a/drivers/scsi/qlogicpti.h
+++ b/drivers/scsi/qlogicpti.h
@@ -43,7 +43,7 @@
  * determined for each queue request anew.
  */
 #define QLOGICPTI_REQ_QUEUE_LEN 255     /* must be power of two - 1 */
-#define QLOGICPTI_MAX_SG(ql)    (4 + ((ql) > 0) ? 7*((ql) - 1) : 0)
+#define QLOGICPTI_MAX_SG(ql)    (4 + (((ql) > 0) ? 7*((ql) - 1) : 0))
 
 /* mailbox command complete status codes */
 #define MBOX_COMMAND_COMPLETE           0x4000
diff --git a/drivers/scsi/raid_class.c b/drivers/scsi/raid_class.c
index 8e5c169b03fb..2c146b44d95f 100644
--- a/drivers/scsi/raid_class.c
+++ b/drivers/scsi/raid_class.c
@@ -63,6 +63,7 @@ static int raid_match(struct attribute_container *cont, struct device *dev)
          * emulated RAID devices, so start with SCSI */
         struct raid_internal *i = ac_to_raid_internal(cont);
 
+#if defined(CONFIG_SCSI) || defined(CONFIG_SCSI_MODULE)
         if (scsi_is_sdev_device(dev)) {
                 struct scsi_device *sdev = to_scsi_device(dev);
 
@@ -71,6 +72,7 @@ static int raid_match(struct attribute_container *cont, struct device *dev)
 
                 return i->f->is_raid(dev);
         }
+#endif
         /* FIXME: look at other subsystems too */
         return 0;
 }
@@ -149,6 +151,7 @@ static struct {
         { RAID_LEVEL_0, "raid0" },
         { RAID_LEVEL_1, "raid1" },
         { RAID_LEVEL_10, "raid10" },
+        { RAID_LEVEL_1E, "raid1e" },
         { RAID_LEVEL_3, "raid3" },
         { RAID_LEVEL_4, "raid4" },
         { RAID_LEVEL_5, "raid5" },
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index dd098cad337b..1c08f6164658 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -940,10 +940,16 @@ EXPORT_SYMBOL(scsi_adjust_queue_depth);
  */
 int scsi_track_queue_full(struct scsi_device *sdev, int depth)
 {
-        if ((jiffies >> 4) == sdev->last_queue_full_time)
+
+        /*
+         * Don't let QUEUE_FULLs on the same
+         * jiffies count, they could all be from
+         * same event.
+         */
+        if ((jiffies >> 4) == (sdev->last_queue_full_time >> 4))
                 return 0;
 
-        sdev->last_queue_full_time = (jiffies >> 4);
+        sdev->last_queue_full_time = jiffies;
         if (sdev->last_queue_full_depth != depth) {
                 sdev->last_queue_full_count = 1;
                 sdev->last_queue_full_depth = depth;
@@ -1012,6 +1018,8 @@ static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
  * scsi_get_vpd_page - Get Vital Product Data from a SCSI device
  * @sdev: The device to ask
  * @page: Which Vital Product Data to return
+ * @buf: where to store the VPD
+ * @buf_len: number of bytes in the VPD buffer area
  *
  * SCSI devices may optionally supply Vital Product Data.  Each 'page'
  * of VPD is defined in the appropriate SCSI document (eg SPC, SBC).
@@ -1020,55 +1028,39 @@ static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
  * responsible for calling kfree() on this pointer when it is no longer
  * needed.  If we cannot retrieve the VPD page this routine returns %NULL.
  */
-unsigned char *scsi_get_vpd_page(struct scsi_device *sdev, u8 page)
+int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
+                      int buf_len)
 {
         int i, result;
-        unsigned int len;
-        const unsigned int init_vpd_len = 255;
-        unsigned char *buf = kmalloc(init_vpd_len, GFP_KERNEL);
-
-        if (!buf)
-                return NULL;
 
         /* Ask for all the pages supported by this device */
-        result = scsi_vpd_inquiry(sdev, buf, 0, init_vpd_len);
+        result = scsi_vpd_inquiry(sdev, buf, 0, buf_len);
         if (result)
                 goto fail;
 
         /* If the user actually wanted this page, we can skip the rest */
         if (page == 0)
-                return buf;
+                return -EINVAL;
 
-        for (i = 0; i < buf[3]; i++)
+        for (i = 0; i < min((int)buf[3], buf_len - 4); i++)
                 if (buf[i + 4] == page)
                         goto found;
+
+        if (i < buf[3] && i > buf_len)
+                /* ran off the end of the buffer, give us benefit of doubt */
+                goto found;
         /* The device claims it doesn't support the requested page */
         goto fail;
 
  found:
-        result = scsi_vpd_inquiry(sdev, buf, page, 255);
-        if (result)
-                goto fail;
-
-        /*
-         * Some pages are longer than 255 bytes.  The actual length of
-         * the page is returned in the header.
-         */
-        len = ((buf[2] << 8) | buf[3]) + 4;
-        if (len <= init_vpd_len)
-                return buf;
-
-        kfree(buf);
-        buf = kmalloc(len, GFP_KERNEL);
-        result = scsi_vpd_inquiry(sdev, buf, page, len);
+        result = scsi_vpd_inquiry(sdev, buf, page, buf_len);
         if (result)
                 goto fail;
 
-        return buf;
+        return 0;
 
  fail:
-        kfree(buf);
-        return NULL;
+        return -EINVAL;
 }
 EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
 
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index c4103bef41b5..3a5bfd10b2cb 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -30,6 +30,7 @@
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/timer.h>
+#include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/string.h>
 #include <linux/genhd.h>
@@ -44,6 +45,8 @@
 
 #include <net/checksum.h>
 
+#include <asm/unaligned.h>
+
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
@@ -105,6 +108,10 @@ static const char * scsi_debug_version_date = "20070104";
 #define DEF_ATO 1
 #define DEF_PHYSBLK_EXP 0
 #define DEF_LOWEST_ALIGNED 0
+#define DEF_UNMAP_MAX_BLOCKS 0
+#define DEF_UNMAP_MAX_DESC 0
+#define DEF_UNMAP_GRANULARITY 0
+#define DEF_UNMAP_ALIGNMENT 0
 
 /* bit mask values for scsi_debug_opts */
 #define SCSI_DEBUG_OPT_NOISE   1
@@ -162,6 +169,10 @@ static int scsi_debug_guard = DEF_GUARD;
 static int scsi_debug_ato = DEF_ATO;
 static int scsi_debug_physblk_exp = DEF_PHYSBLK_EXP;
 static int scsi_debug_lowest_aligned = DEF_LOWEST_ALIGNED;
+static int scsi_debug_unmap_max_desc = DEF_UNMAP_MAX_DESC;
+static int scsi_debug_unmap_max_blocks = DEF_UNMAP_MAX_BLOCKS;
+static int scsi_debug_unmap_granularity = DEF_UNMAP_GRANULARITY;
+static int scsi_debug_unmap_alignment = DEF_UNMAP_ALIGNMENT;
 
 static int scsi_debug_cmnd_count = 0;
 
@@ -223,7 +234,9 @@ static struct sdebug_queued_cmd queued_arr[SCSI_DEBUG_CANQUEUE];
 
 static unsigned char * fake_storep;     /* ramdisk storage */
 static unsigned char *dif_storep;       /* protection info */
+static void *map_storep;                /* provisioning map */
 
+static unsigned long map_size;
 static int num_aborts = 0;
 static int num_dev_resets = 0;
 static int num_bus_resets = 0;
@@ -317,6 +330,7 @@ static void get_data_transfer_info(unsigned char *cmd,
                         (u32)cmd[28] << 24;
                 break;
 
+        case WRITE_SAME_16:
         case WRITE_16:
         case READ_16:
                 *lba = (u64)cmd[9] | (u64)cmd[8] << 8 |
@@ -335,6 +349,7 @@ static void get_data_transfer_info(unsigned char *cmd,
                 *num = (u32)cmd[9] | (u32)cmd[8] << 8 | (u32)cmd[7] << 16 |
                         (u32)cmd[6] << 24;
                 break;
+        case WRITE_SAME:
         case WRITE_10:
         case READ_10:
         case XDWRITEREAD_10:
@@ -671,10 +686,12 @@ static int inquiry_evpd_89(unsigned char * arr)
 }
 
 
+/* Block limits VPD page (SBC-3) */
 static unsigned char vpdb0_data[] = {
-        /* from 4th byte */ 0,0,0,4,
-        0,0,0x4,0,
-        0,0,0,64,
+        /* from 4th byte */ 0,0,0,4, 0,0,0x4,0, 0,0,0,64,
+        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 };
 
 static int inquiry_evpd_b0(unsigned char * arr)
@@ -691,14 +708,40 @@ static int inquiry_evpd_b0(unsigned char * arr)
                 arr[6] = (sdebug_store_sectors >> 8) & 0xff;
                 arr[7] = sdebug_store_sectors & 0xff;
         }
+
+        if (scsi_debug_unmap_max_desc) {
+                unsigned int blocks;
+
+                if (scsi_debug_unmap_max_blocks)
+                        blocks = scsi_debug_unmap_max_blocks;
+                else
+                        blocks = 0xffffffff;
+
+                put_unaligned_be32(blocks, &arr[16]);
+                put_unaligned_be32(scsi_debug_unmap_max_desc, &arr[20]);
+        }
+
+        if (scsi_debug_unmap_alignment) {
+                put_unaligned_be32(scsi_debug_unmap_alignment, &arr[28]);
+                arr[28] |= 0x80; /* UGAVALID */
+        }
+
+        if (scsi_debug_unmap_granularity) {
+                put_unaligned_be32(scsi_debug_unmap_granularity, &arr[24]);
+                return 0x3c; /* Mandatory page length for thin provisioning */
+        }
+
         return sizeof(vpdb0_data);
 }
 
+/* Block device characteristics VPD page (SBC-3) */
 static int inquiry_evpd_b1(unsigned char *arr)
 {
         memset(arr, 0, 0x3c);
         arr[0] = 0;
-        arr[1] = 1;
+        arr[1] = 1;     /* non rotating medium (e.g. solid state) */
+        arr[2] = 0;
+        arr[3] = 5;     /* less than 1.8" */
 
         return 0x3c;
 }
@@ -914,7 +957,8 @@ static int resp_start_stop(struct scsi_cmnd * scp,
 static sector_t get_sdebug_capacity(void)
 {
         if (scsi_debug_virtual_gb > 0)
-                return 2048 * 1024 * (sector_t)scsi_debug_virtual_gb;
+                return (sector_t)scsi_debug_virtual_gb *
+                        (1073741824 / scsi_debug_sector_size);
         else
                 return sdebug_store_sectors;
 }
@@ -974,6 +1018,10 @@ static int resp_readcap16(struct scsi_cmnd * scp,
         arr[11] = scsi_debug_sector_size & 0xff;
         arr[13] = scsi_debug_physblk_exp & 0xf;
         arr[14] = (scsi_debug_lowest_aligned >> 8) & 0x3f;
+
+        if (scsi_debug_unmap_granularity)
+                arr[14] |= 0x80; /* TPE */
+
         arr[15] = scsi_debug_lowest_aligned & 0xff;
 
         if (scsi_debug_dif) {
@@ -1887,6 +1935,70 @@ out:
         return ret;
 }
 
+static unsigned int map_state(sector_t lba, unsigned int *num)
+{
+        unsigned int granularity, alignment, mapped;
+        sector_t block, next, end;
+
+        granularity = scsi_debug_unmap_granularity;
+        alignment = granularity - scsi_debug_unmap_alignment;
+        block = lba + alignment;
+        do_div(block, granularity);
+
+        mapped = test_bit(block, map_storep);
+
+        if (mapped)
+                next = find_next_zero_bit(map_storep, map_size, block);
+        else
+                next = find_next_bit(map_storep, map_size, block);
+
+        end = next * granularity - scsi_debug_unmap_alignment;
+        *num = end - lba;
+
+        return mapped;
+}
+
+static void map_region(sector_t lba, unsigned int len)
+{
+        unsigned int granularity, alignment;
+        sector_t end = lba + len;
+
+        granularity = scsi_debug_unmap_granularity;
+        alignment = granularity - scsi_debug_unmap_alignment;
+
+        while (lba < end) {
+                sector_t block, rem;
+
+                block = lba + alignment;
+                rem = do_div(block, granularity);
+
+                set_bit(block, map_storep);
+
+                lba += granularity - rem;
+        }
+}
+
+static void unmap_region(sector_t lba, unsigned int len)
+{
+        unsigned int granularity, alignment;
+        sector_t end = lba + len;
+
+        granularity = scsi_debug_unmap_granularity;
+        alignment = granularity - scsi_debug_unmap_alignment;
+
+        while (lba < end) {
+                sector_t block, rem;
+
+                block = lba + alignment;
+                rem = do_div(block, granularity);
+
+                if (rem == 0 && lba + granularity <= end)
+                        clear_bit(block, map_storep);
+
+                lba += granularity - rem;
+        }
+}
+
 static int resp_write(struct scsi_cmnd *SCpnt, unsigned long long lba,
                       unsigned int num, struct sdebug_dev_info *devip,
                       u32 ei_lba)
@@ -1910,6 +2022,8 @@ static int resp_write(struct scsi_cmnd *SCpnt, unsigned long long lba,
 
         write_lock_irqsave(&atomic_rw, iflags);
         ret = do_device_access(SCpnt, devip, lba, num, 1);
+        if (scsi_debug_unmap_granularity)
+                map_region(lba, num);
         write_unlock_irqrestore(&atomic_rw, iflags);
         if (-1 == ret)
                 return (DID_ERROR << 16);
@@ -1917,9 +2031,143 @@ static int resp_write(struct scsi_cmnd *SCpnt, unsigned long long lba,
                  (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
                 printk(KERN_INFO "scsi_debug: write: cdb indicated=%u, "
                        " IO sent=%d bytes\n", num * scsi_debug_sector_size, ret);
+
+        return 0;
+}
+
+static int resp_write_same(struct scsi_cmnd *scmd, unsigned long long lba,
+                      unsigned int num, struct sdebug_dev_info *devip,
+                           u32 ei_lba, unsigned int unmap)
+{
+        unsigned long iflags;
+        unsigned long long i;
+        int ret;
+
+        ret = check_device_access_params(devip, lba, num);
+        if (ret)
+                return ret;
+
+        write_lock_irqsave(&atomic_rw, iflags);
+
+        if (unmap && scsi_debug_unmap_granularity) {
+                unmap_region(lba, num);
+                goto out;
+        }
+
+        /* Else fetch one logical block */
+        ret = fetch_to_dev_buffer(scmd,
+                                  fake_storep + (lba * scsi_debug_sector_size),
+                                  scsi_debug_sector_size);
+
+        if (-1 == ret) {
+                write_unlock_irqrestore(&atomic_rw, iflags);
+                return (DID_ERROR << 16);
+        } else if ((ret < (num * scsi_debug_sector_size)) &&
+                 (SCSI_DEBUG_OPT_NOISE & scsi_debug_opts))
+                printk(KERN_INFO "scsi_debug: write same: cdb indicated=%u, "
+                       " IO sent=%d bytes\n", num * scsi_debug_sector_size, ret);
+
+        /* Copy first sector to remaining blocks */
+        for (i = 1 ; i < num ; i++)
+                memcpy(fake_storep + ((lba + i) * scsi_debug_sector_size),
+                       fake_storep + (lba * scsi_debug_sector_size),
+                       scsi_debug_sector_size);
+
+        if (scsi_debug_unmap_granularity)
+                map_region(lba, num);
+out:
+        write_unlock_irqrestore(&atomic_rw, iflags);
+
         return 0;
 }
 
+struct unmap_block_desc {
+        __be64  lba;
+        __be32  blocks;
+        __be32  __reserved;
+};
+
+static int resp_unmap(struct scsi_cmnd * scmd, struct sdebug_dev_info * devip)
+{
+        unsigned char *buf;
+        struct unmap_block_desc *desc;
+        unsigned int i, payload_len, descriptors;
+        int ret;
+
+        ret = check_readiness(scmd, 1, devip);
+        if (ret)
+                return ret;
+
+        payload_len = get_unaligned_be16(&scmd->cmnd[7]);
+        BUG_ON(scsi_bufflen(scmd) != payload_len);
+
+        descriptors = (payload_len - 8) / 16;
+
+        buf = kmalloc(scsi_bufflen(scmd), GFP_ATOMIC);
+        if (!buf)
+                return check_condition_result;
+
+        scsi_sg_copy_to_buffer(scmd, buf, scsi_bufflen(scmd));
+
+        BUG_ON(get_unaligned_be16(&buf[0]) != payload_len - 2);
+        BUG_ON(get_unaligned_be16(&buf[2]) != descriptors * 16);
+
+        desc = (void *)&buf[8];
+
+        for (i = 0 ; i < descriptors ; i++) {
+                unsigned long long lba = get_unaligned_be64(&desc[i].lba);
+                unsigned int num = get_unaligned_be32(&desc[i].blocks);
+
+                ret = check_device_access_params(devip, lba, num);
+                if (ret)
+                        goto out;
+
+                unmap_region(lba, num);
+        }
+
+        ret = 0;
+
+out:
+        kfree(buf);
+
+        return ret;
+}
+
+#define SDEBUG_GET_LBA_STATUS_LEN 32
+
+static int resp_get_lba_status(struct scsi_cmnd * scmd,
+                               struct sdebug_dev_info * devip)
+{
+        unsigned long long lba;
+        unsigned int alloc_len, mapped, num;
+        unsigned char arr[SDEBUG_GET_LBA_STATUS_LEN];
+        int ret;
+
+        ret = check_readiness(scmd, 1, devip);
+        if (ret)
+                return ret;
+
+        lba = get_unaligned_be64(&scmd->cmnd[2]);
+        alloc_len = get_unaligned_be32(&scmd->cmnd[10]);
+
+        if (alloc_len < 24)
+                return 0;
+
+        ret = check_device_access_params(devip, lba, 1);
+        if (ret)
+                return ret;
+
+        mapped = map_state(lba, &num);
+
+        memset(arr, 0, SDEBUG_GET_LBA_STATUS_LEN);
+        put_unaligned_be32(16, &arr[0]);        /* Parameter Data Length */
+        put_unaligned_be64(lba, &arr[8]);       /* LBA */
+        put_unaligned_be32(num, &arr[16]);      /* Number of blocks */
+        arr[20] = !mapped;                      /* mapped = 0, unmapped = 1 */
+
+        return fill_from_dev_buffer(scmd, arr, SDEBUG_GET_LBA_STATUS_LEN);
+}
+
 #define SDEBUG_RLUN_ARR_SZ 256
 
 static int resp_report_luns(struct scsi_cmnd * scp,
@@ -2430,6 +2678,10 @@ module_param_named(guard, scsi_debug_guard, int, S_IRUGO);
 module_param_named(ato, scsi_debug_ato, int, S_IRUGO);
 module_param_named(physblk_exp, scsi_debug_physblk_exp, int, S_IRUGO);
 module_param_named(lowest_aligned, scsi_debug_lowest_aligned, int, S_IRUGO);
+module_param_named(unmap_max_blocks, scsi_debug_unmap_max_blocks, int, S_IRUGO);
+module_param_named(unmap_max_desc, scsi_debug_unmap_max_desc, int, S_IRUGO);
+module_param_named(unmap_granularity, scsi_debug_unmap_granularity, int, S_IRUGO);
+module_param_named(unmap_alignment, scsi_debug_unmap_alignment, int, S_IRUGO);
 
 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
 MODULE_DESCRIPTION("SCSI debug adapter driver");
@@ -2458,6 +2710,10 @@ MODULE_PARM_DESC(dix, "data integrity extensions mask (def=0)");
 MODULE_PARM_DESC(dif, "data integrity field type: 0-3 (def=0)");
 MODULE_PARM_DESC(guard, "protection checksum: 0=crc, 1=ip (def=0)");
 MODULE_PARM_DESC(ato, "application tag ownership: 0=disk 1=host (def=1)");
+MODULE_PARM_DESC(unmap_max_blocks, "max # of blocks can be unmapped in one cmd (def=0)");
+MODULE_PARM_DESC(unmap_max_desc, "max # of ranges that can be unmapped in one cmd (def=0)");
+MODULE_PARM_DESC(unmap_granularity, "thin provisioning granularity in blocks (def=0)");
+MODULE_PARM_DESC(unmap_alignment, "lowest aligned thin provisioning lba (def=0)");
 
 static char sdebug_info[256];
 
@@ -2816,6 +3072,23 @@ static ssize_t sdebug_ato_show(struct device_driver *ddp, char *buf)
 }
 DRIVER_ATTR(ato, S_IRUGO, sdebug_ato_show, NULL);
 
+static ssize_t sdebug_map_show(struct device_driver *ddp, char *buf)
+{
+        ssize_t count;
+
+        if (scsi_debug_unmap_granularity == 0)
+                return scnprintf(buf, PAGE_SIZE, "0-%u\n",
+                                 sdebug_store_sectors);
+
+        count = bitmap_scnlistprintf(buf, PAGE_SIZE, map_storep, map_size);
+
+        buf[count++] = '\n';
+        buf[count++] = 0;
+
+        return count;
+}
+DRIVER_ATTR(map, S_IRUGO, sdebug_map_show, NULL);
+
 
 /* Note: The following function creates attribute files in the
    /sys/bus/pseudo/drivers/scsi_debug directory. The advantage of these
@@ -2847,11 +3120,13 @@ static int do_create_driverfs_files(void)
         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_dif);
         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_guard);
         ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_ato);
+        ret |= driver_create_file(&sdebug_driverfs_driver, &driver_attr_map);
         return ret;
 }
 
 static void do_remove_driverfs_files(void)
 {
+        driver_remove_file(&sdebug_driverfs_driver, &driver_attr_map);
         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_ato);
         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_guard);
         driver_remove_file(&sdebug_driverfs_driver, &driver_attr_dif);
@@ -2989,6 +3264,36 @@ static int __init scsi_debug_init(void)
                 memset(dif_storep, 0xff, dif_size);
         }
 
+        if (scsi_debug_unmap_granularity) {
+                unsigned int map_bytes;
+
+                if (scsi_debug_unmap_granularity < scsi_debug_unmap_alignment) {
+                        printk(KERN_ERR
+                               "%s: ERR: unmap_granularity < unmap_alignment\n",
+                               __func__);
+                        return -EINVAL;
+                }
+
+                map_size = (sdebug_store_sectors / scsi_debug_unmap_granularity);
+                map_bytes = map_size >> 3;
+                map_storep = vmalloc(map_bytes);
+
+                printk(KERN_INFO "scsi_debug_init: %lu provisioning blocks\n",
+                       map_size);
+
+                if (map_storep == NULL) {
+                        printk(KERN_ERR "scsi_debug_init: out of mem. (MAP)\n");
+                        ret = -ENOMEM;
+                        goto free_vm;
+                }
+
+                memset(map_storep, 0x0, map_bytes);
+
+                /* Map first 1KB for partition table */
+                if (scsi_debug_num_parts)
+                        map_region(0, 2);
+        }
+
         ret = device_register(&pseudo_primary);
         if (ret < 0) {
                 printk(KERN_WARNING "scsi_debug: device_register error: %d\n",
@@ -3041,6 +3346,8 @@ bus_unreg:
 dev_unreg:
         device_unregister(&pseudo_primary);
 free_vm:
+        if (map_storep)
+                vfree(map_storep);
         if (dif_storep)
                 vfree(dif_storep);
         vfree(fake_storep);
@@ -3167,6 +3474,7 @@ int scsi_debug_queuecommand(struct scsi_cmnd *SCpnt, done_funct_t done)
         int inj_dif = 0;
         int inj_dix = 0;
         int delay_override = 0;
+        int unmap = 0;
 
         scsi_set_resid(SCpnt, 0);
         if ((SCSI_DEBUG_OPT_NOISE & scsi_debug_opts) && cmd) {
@@ -3272,13 +3580,21 @@ int scsi_debug_queuecommand(struct scsi_cmnd *SCpnt, done_funct_t done)
                 errsts = resp_readcap(SCpnt, devip);
                 break;
         case SERVICE_ACTION_IN:
-                if (SAI_READ_CAPACITY_16 != cmd[1]) {
+                if (cmd[1] == SAI_READ_CAPACITY_16)
+                        errsts = resp_readcap16(SCpnt, devip);
+                else if (cmd[1] == SAI_GET_LBA_STATUS) {
+
+                        if (scsi_debug_unmap_max_desc == 0) {
+                                mk_sense_buffer(devip, ILLEGAL_REQUEST,
+                                                INVALID_COMMAND_OPCODE, 0);
+                                errsts = check_condition_result;
+                        } else
+                                errsts = resp_get_lba_status(SCpnt, devip);
+                } else {
                         mk_sense_buffer(devip, ILLEGAL_REQUEST,
                                         INVALID_OPCODE, 0);
                         errsts = check_condition_result;
-                        break;
                 }
-                errsts = resp_readcap16(SCpnt, devip);
                 break;
         case MAINTENANCE_IN:
                 if (MI_REPORT_TARGET_PGS != cmd[1]) {
@@ -3378,6 +3694,29 @@ write:
                         errsts = illegal_condition_result;
                 }
                 break;
+        case WRITE_SAME_16:
+                if (cmd[1] & 0x8)
+                        unmap = 1;
+                /* fall through */
+        case WRITE_SAME:
+                errsts = check_readiness(SCpnt, 0, devip);
+                if (errsts)
+                        break;
+                get_data_transfer_info(cmd, &lba, &num, &ei_lba);
+                errsts = resp_write_same(SCpnt, lba, num, devip, ei_lba, unmap);
+                break;
+        case UNMAP:
+                errsts = check_readiness(SCpnt, 0, devip);
+                if (errsts)
+                        break;
+
+                if (scsi_debug_unmap_max_desc == 0) {
+                        mk_sense_buffer(devip, ILLEGAL_REQUEST,
+                                        INVALID_COMMAND_OPCODE, 0);
+                        errsts = check_condition_result;
+                } else
+                        errsts = resp_unmap(SCpnt, devip);
+                break;
         case MODE_SENSE:
         case MODE_SENSE_10:
                 errsts = resp_mode_sense(SCpnt, target, devip);
diff --git a/drivers/scsi/scsi_devinfo.c b/drivers/scsi/scsi_devinfo.c
index 93c2622cb969..43fad4c09beb 100644
--- a/drivers/scsi/scsi_devinfo.c
+++ b/drivers/scsi/scsi_devinfo.c
@@ -6,6 +6,7 @@
 #include <linux/moduleparam.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_devinfo.h>
@@ -168,11 +169,10 @@ static struct {
         {"Generic", "USB SD Reader", "1.00", BLIST_FORCELUN | BLIST_INQUIRY_36},
         {"Generic", "USB Storage-SMC", "0180", BLIST_FORCELUN | BLIST_INQUIRY_36},
         {"Generic", "USB Storage-SMC", "0207", BLIST_FORCELUN | BLIST_INQUIRY_36},
-        {"HITACHI", "DF400", "*", BLIST_SPARSELUN},
-        {"HITACHI", "DF500", "*", BLIST_SPARSELUN},
-        {"HITACHI", "DF600", "*", BLIST_SPARSELUN},
-        {"HITACHI", "DISK-SUBSYSTEM", "*", BLIST_ATTACH_PQ3 | BLIST_SPARSELUN | BLIST_LARGELUN},
-        {"HITACHI", "OPEN-E", "*", BLIST_ATTACH_PQ3 | BLIST_SPARSELUN | BLIST_LARGELUN},
+        {"HITACHI", "DF400", "*", BLIST_REPORTLUN2},
+        {"HITACHI", "DF500", "*", BLIST_REPORTLUN2},
+        {"HITACHI", "DISK-SUBSYSTEM", "*", BLIST_REPORTLUN2},
+        {"HITACHI", "OPEN-", "*", BLIST_REPORTLUN2},
         {"HITACHI", "OP-C-", "*", BLIST_SPARSELUN | BLIST_LARGELUN},
         {"HITACHI", "3380-", "*", BLIST_SPARSELUN | BLIST_LARGELUN},
         {"HITACHI", "3390-", "*", BLIST_SPARSELUN | BLIST_LARGELUN},
@@ -454,7 +454,7 @@ int scsi_get_device_flags(struct scsi_device *sdev,
 
 
 /**
- * get_device_flags_keyed - get device specific flags from the dynamic device list.
+ * scsi_get_device_flags_keyed - get device specific flags from the dynamic device list
  * @sdev:       &scsi_device to get flags for
  * @vendor:     vendor name
  * @model:      model name
@@ -685,7 +685,7 @@ MODULE_PARM_DESC(default_dev_flags,
                  "scsi default device flag integer value");
 
 /**
- * scsi_dev_info_list_delete - called from scsi.c:exit_scsi to remove the scsi_dev_info_list.
+ * scsi_exit_devinfo - remove /proc/scsi/device_info & the scsi_dev_info_list
  **/
 void scsi_exit_devinfo(void)
 {
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 1b0060b791e8..7ad53fa42766 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -16,6 +16,7 @@
 
 #include <linux/module.h>
 #include <linux/sched.h>
+#include <linux/gfp.h>
 #include <linux/timer.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
@@ -301,7 +302,20 @@ static int scsi_check_sense(struct scsi_cmnd *scmd)
                 if (scmd->device->allow_restart &&
                     (sshdr.asc == 0x04) && (sshdr.ascq == 0x02))
                         return FAILED;
-                return SUCCESS;
+
+                if (blk_barrier_rq(scmd->request))
+                        /*
+                         * barrier requests should always retry on UA
+                         * otherwise block will get a spurious error
+                         */
+                        return NEEDS_RETRY;
+                else
+                        /*
+                         * for normal (non barrier) commands, pass the
+                         * UA upwards for a determination in the
+                         * completion functions
+                         */
+                        return SUCCESS;
 
                 /* these three are not supported */
         case COPY_ABORTED:
@@ -331,6 +345,64 @@ static int scsi_check_sense(struct scsi_cmnd *scmd)
         }
 }
 
+static void scsi_handle_queue_ramp_up(struct scsi_device *sdev)
+{
+        struct scsi_host_template *sht = sdev->host->hostt;
+        struct scsi_device *tmp_sdev;
+
+        if (!sht->change_queue_depth ||
+            sdev->queue_depth >= sdev->max_queue_depth)
+                return;
+
+        if (time_before(jiffies,
+            sdev->last_queue_ramp_up + sdev->queue_ramp_up_period))
+                return;
+
+        if (time_before(jiffies,
+            sdev->last_queue_full_time + sdev->queue_ramp_up_period))
+                return;
+
+        /*
+         * Walk all devices of a target and do
+         * ramp up on them.
+         */
+        shost_for_each_device(tmp_sdev, sdev->host) {
+                if (tmp_sdev->channel != sdev->channel ||
+                    tmp_sdev->id != sdev->id ||
+                    tmp_sdev->queue_depth == sdev->max_queue_depth)
+                        continue;
+                /*
+                 * call back into LLD to increase queue_depth by one
+                 * with ramp up reason code.
+                 */
+                sht->change_queue_depth(tmp_sdev, tmp_sdev->queue_depth + 1,
+                                        SCSI_QDEPTH_RAMP_UP);
+                sdev->last_queue_ramp_up = jiffies;
+        }
+}
+
+static void scsi_handle_queue_full(struct scsi_device *sdev)
+{
+        struct scsi_host_template *sht = sdev->host->hostt;
+        struct scsi_device *tmp_sdev;
+
+        if (!sht->change_queue_depth)
+                return;
+
+        shost_for_each_device(tmp_sdev, sdev->host) {
+                if (tmp_sdev->channel != sdev->channel ||
+                    tmp_sdev->id != sdev->id)
+                        continue;
+                /*
+                 * We do not know the number of commands that were at
+                 * the device when we got the queue full so we start
+                 * from the highest possible value and work our way down.
+                 */
+                sht->change_queue_depth(tmp_sdev, tmp_sdev->queue_depth - 1,
+                                        SCSI_QDEPTH_QFULL);
+        }
+}
+
 /**
  * scsi_eh_completed_normally - Disposition a eh cmd on return from LLD.
  * @scmd:       SCSI cmd to examine.
@@ -371,6 +443,7 @@ static int scsi_eh_completed_normally(struct scsi_cmnd *scmd)
          */
         switch (status_byte(scmd->result)) {
         case GOOD:
+                scsi_handle_queue_ramp_up(scmd->device);
         case COMMAND_TERMINATED:
                 return SUCCESS;
         case CHECK_CONDITION:
@@ -387,8 +460,10 @@ static int scsi_eh_completed_normally(struct scsi_cmnd *scmd)
                  * let issuer deal with this, it could be just fine
                  */
                 return SUCCESS;
-        case BUSY:
         case QUEUE_FULL:
+                scsi_handle_queue_full(scmd->device);
+                /* fall through */
+        case BUSY:
         default:
                 return FAILED;
         }
@@ -1387,6 +1462,7 @@ int scsi_decide_disposition(struct scsi_cmnd *scmd)
          */
         switch (status_byte(scmd->result)) {
         case QUEUE_FULL:
+                scsi_handle_queue_full(scmd->device);
                 /*
                  * the case of trying to send too many commands to a
                  * tagged queueing device.
@@ -1400,6 +1476,7 @@ int scsi_decide_disposition(struct scsi_cmnd *scmd)
                  */
                 return ADD_TO_MLQUEUE;
         case GOOD:
+                scsi_handle_queue_ramp_up(scmd->device);
         case COMMAND_TERMINATED:
                 return SUCCESS;
         case TASK_ABORTED:
diff --git a/drivers/scsi/scsi_ioctl.c b/drivers/scsi/scsi_ioctl.c
index b98f763931c5..d9564fb04f62 100644
--- a/drivers/scsi/scsi_ioctl.c
+++ b/drivers/scsi/scsi_ioctl.c
@@ -308,6 +308,9 @@ int scsi_nonblockable_ioctl(struct scsi_device *sdev, int cmd,
                 case SG_SCSI_RESET_DEVICE:
                         val = SCSI_TRY_RESET_DEVICE;
                         break;
+                case SG_SCSI_RESET_TARGET:
+                        val = SCSI_TRY_RESET_TARGET;
+                        break;
                 case SG_SCSI_RESET_BUS:
                         val = SCSI_TRY_RESET_BUS;
                         break;
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 5987da857103..1646fe7cbd4b 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -749,9 +749,9 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                          */
                         req->next_rq->resid_len = scsi_in(cmd)->resid;
 
+                        scsi_release_buffers(cmd);
                         blk_end_request_all(req, 0);
 
-                        scsi_release_buffers(cmd);
                         scsi_next_command(cmd);
                         return;
                 }
@@ -773,8 +773,14 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
          * we already took a copy of the original into rq->errors which
          * is what gets returned to the user
          */
-        if (sense_valid && sshdr.sense_key == RECOVERED_ERROR) {
-                if (!(req->cmd_flags & REQ_QUIET))
+        if (sense_valid && (sshdr.sense_key == RECOVERED_ERROR)) {
+                /* if ATA PASS-THROUGH INFORMATION AVAILABLE skip
+                 * print since caller wants ATA registers. Only occurs on
+                 * SCSI ATA PASS_THROUGH commands when CK_COND=1
+                 */
+                if ((sshdr.asc == 0x0) && (sshdr.ascq == 0x1d))
+                        ;
+                else if (!(req->cmd_flags & REQ_QUIET))
                         scsi_print_sense("", cmd);
                 result = 0;
                 /* BLOCK_PC may have set error */
@@ -859,6 +865,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                                 case 0x07: /* operation in progress */
                                 case 0x08: /* Long write in progress */
                                 case 0x09: /* self test in progress */
+                                case 0x14: /* space allocation in progress */
                                         action = ACTION_DELAYED_RETRY;
                                         break;
                                 default:
@@ -898,7 +905,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                                 scsi_print_sense("", cmd);
                         scsi_print_command(cmd);
                 }
-                if (blk_end_request_err(req, -EIO))
+                if (blk_end_request_err(req, error))
                         scsi_requeue_command(q, cmd);
                 else
                         scsi_next_command(cmd);
@@ -1359,9 +1366,9 @@ static int scsi_lld_busy(struct request_queue *q)
 static void scsi_kill_request(struct request *req, struct request_queue *q)
 {
         struct scsi_cmnd *cmd = req->special;
-        struct scsi_device *sdev = cmd->device;
-        struct scsi_target *starget = scsi_target(sdev);
-        struct Scsi_Host *shost = sdev->host;
+        struct scsi_device *sdev;
+        struct scsi_target *starget;
+        struct Scsi_Host *shost;
 
         blk_start_request(req);
 
@@ -1371,6 +1378,9 @@ static void scsi_kill_request(struct request *req, struct request_queue *q)
                 BUG();
         }
 
+        sdev = cmd->device;
+        starget = scsi_target(sdev);
+        shost = sdev->host;
         scsi_init_cmd_errh(cmd);
         cmd->result = DID_NO_CONNECT << 16;
         atomic_inc(&cmd->device->iorequest_cnt);
@@ -1620,10 +1630,10 @@ struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost,
         /*
          * this limit is imposed by hardware restrictions
          */
-        blk_queue_max_hw_segments(q, shost->sg_tablesize);
-        blk_queue_max_phys_segments(q, SCSI_MAX_SG_CHAIN_SEGMENTS);
+        blk_queue_max_segments(q, min_t(unsigned short, shost->sg_tablesize,
+                                        SCSI_MAX_SG_CHAIN_SEGMENTS));
 
-        blk_queue_max_sectors(q, shost->max_sectors);
+        blk_queue_max_hw_sectors(q, shost->max_sectors);
         blk_queue_bounce_limit(q, scsi_calculate_bounce_limit(shost));
         blk_queue_segment_boundary(q, shost->dma_boundary);
         dma_set_seg_boundary(dev, shost->dma_boundary);
diff --git a/drivers/scsi/scsi_lib_dma.c b/drivers/scsi/scsi_lib_dma.c
index ac6855cd2657..dcd128583b89 100644
--- a/drivers/scsi/scsi_lib_dma.c
+++ b/drivers/scsi/scsi_lib_dma.c
@@ -23,7 +23,7 @@ int scsi_dma_map(struct scsi_cmnd *cmd)
         int nseg = 0;
 
         if (scsi_sg_count(cmd)) {
-                struct device *dev = cmd->device->host->shost_gendev.parent;
+                struct device *dev = cmd->device->host->dma_dev;
 
                 nseg = dma_map_sg(dev, scsi_sglist(cmd), scsi_sg_count(cmd),
                                   cmd->sc_data_direction);
@@ -41,7 +41,7 @@ EXPORT_SYMBOL(scsi_dma_map);
 void scsi_dma_unmap(struct scsi_cmnd *cmd)
 {
         if (scsi_sg_count(cmd)) {
-                struct device *dev = cmd->device->host->shost_gendev.parent;
+                struct device *dev = cmd->device->host->dma_dev;
 
                 dma_unmap_sg(dev, scsi_sglist(cmd), scsi_sg_count(cmd),
                              cmd->sc_data_direction);
diff --git a/drivers/scsi/scsi_netlink.c b/drivers/scsi/scsi_netlink.c
index 723fdecd91bd..d53e6503c6d5 100644
--- a/drivers/scsi/scsi_netlink.c
+++ b/drivers/scsi/scsi_netlink.c
@@ -22,6 +22,7 @@
 #include <linux/jiffies.h>
 #include <linux/security.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <net/sock.h>
 #include <net/netlink.h>
 
@@ -613,7 +614,7 @@ EXPORT_SYMBOL_GPL(scsi_nl_send_transport_msg);
  * @data_buf:           pointer to vendor unique data buffer
  *
  * Returns:
- *   0 on succesful return
+ *   0 on successful return
  *   otherwise, failing error code
  *
  * Notes:
diff --git a/drivers/scsi/scsi_proc.c b/drivers/scsi/scsi_proc.c
index 77fbddb507fd..c99da926fdac 100644
--- a/drivers/scsi/scsi_proc.c
+++ b/drivers/scsi/scsi_proc.c
@@ -20,12 +20,12 @@
 #include <linux/init.h>
 #include <linux/string.h>
 #include <linux/mm.h>
-#include <linux/slab.h>
 #include <linux/proc_fs.h>
 #include <linux/errno.h>
 #include <linux/blkdev.h>
 #include <linux/seq_file.h>
 #include <linux/mutex.h>
+#include <linux/gfp.h>
 #include <asm/uaccess.h>
 
 #include <scsi/scsi.h>
diff --git a/drivers/scsi/scsi_sas_internal.h b/drivers/scsi/scsi_sas_internal.h
index 998cb5be6833..6266a5d73d0f 100644
--- a/drivers/scsi/scsi_sas_internal.h
+++ b/drivers/scsi/scsi_sas_internal.h
@@ -5,7 +5,7 @@
 #define SAS_PHY_ATTRS           17
 #define SAS_PORT_ATTRS          1
 #define SAS_RPORT_ATTRS         7
-#define SAS_END_DEV_ATTRS       3
+#define SAS_END_DEV_ATTRS       5
 #define SAS_EXPANDER_ATTRS      7
 
 struct sas_internal {
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 47291bcff0d5..38518b088073 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -33,6 +33,7 @@
 #include <linux/kthread.h>
 #include <linux/spinlock.h>
 #include <linux/async.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -251,6 +252,7 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
         sdev->model = scsi_null_device_strs;
         sdev->rev = scsi_null_device_strs;
         sdev->host = shost;
+        sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD;
         sdev->id = starget->id;
         sdev->lun = lun;
         sdev->channel = starget->channel;
@@ -878,7 +880,7 @@ static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
          * broken RA4x00 Compaq Disk Array
          */
         if (*bflags & BLIST_MAX_512)
-                blk_queue_max_sectors(sdev->request_queue, 512);
+                blk_queue_max_hw_sectors(sdev->request_queue, 512);
 
         /*
          * Some devices may not want to have a start command automatically
@@ -941,6 +943,8 @@ static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
                 }
         }
 
+        sdev->max_queue_depth = sdev->queue_depth;
+
         /*
          * Ok, the device is now all set up, we can
          * register it and tell the rest of the kernel
@@ -1336,8 +1340,10 @@ static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
                 sdev = scsi_alloc_sdev(starget, 0, NULL);
                 if (!sdev)
                         return 0;
-                if (scsi_device_get(sdev))
+                if (scsi_device_get(sdev)) {
+                        __scsi_remove_device(sdev);
                         return 0;
+                }
         }
 
         sprintf(devname, "host %d channel %d id %d",
@@ -1904,10 +1910,9 @@ struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
                 goto out;
 
         sdev = scsi_alloc_sdev(starget, 0, NULL);
-        if (sdev) {
-                sdev->sdev_gendev.parent = get_device(&starget->dev);
+        if (sdev)
                 sdev->borken = 0;
-        } else
+        else
                 scsi_target_reap(starget);
         put_device(&starget->dev);
  out:
diff --git a/drivers/scsi/scsi_sysctl.c b/drivers/scsi/scsi_sysctl.c
index 63a30f566f3a..2b6b93f7d8ef 100644
--- a/drivers/scsi/scsi_sysctl.c
+++ b/drivers/scsi/scsi_sysctl.c
@@ -13,26 +13,23 @@
 
 
 static ctl_table scsi_table[] = {
-        { .ctl_name     = DEV_SCSI_LOGGING_LEVEL,
-          .procname     = "logging_level",
+        { .procname     = "logging_level",
           .data         = &scsi_logging_level,
           .maxlen       = sizeof(scsi_logging_level),
           .mode         = 0644,
-          .proc_handler = &proc_dointvec },
+          .proc_handler = proc_dointvec },
         { }
 };
 
 static ctl_table scsi_dir_table[] = {
-        { .ctl_name     = DEV_SCSI,
-          .procname     = "scsi",
+        { .procname     = "scsi",
           .mode         = 0555,
           .child        = scsi_table },
         { }
 };
 
 static ctl_table scsi_root_table[] = {
-        { .ctl_name     = CTL_DEV,
-          .procname     = "dev",
+        { .procname     = "dev",
           .mode         = 0555,
           .child        = scsi_dir_table },
         { }
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index 392d8db33905..429c9b73e3e4 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -7,6 +7,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/device.h>
@@ -766,10 +767,13 @@ sdev_store_queue_depth_rw(struct device *dev, struct device_attribute *attr,
         if (depth < 1)
                 return -EINVAL;
 
-        retval = sht->change_queue_depth(sdev, depth);
+        retval = sht->change_queue_depth(sdev, depth,
+                                         SCSI_QDEPTH_DEFAULT);
         if (retval < 0)
                 return retval;
 
+        sdev->max_queue_depth = sdev->queue_depth;
+
         return count;
 }
 
@@ -778,6 +782,37 @@ static struct device_attribute sdev_attr_queue_depth_rw =
                sdev_store_queue_depth_rw);
 
 static ssize_t
+sdev_show_queue_ramp_up_period(struct device *dev,
+                               struct device_attribute *attr,
+                               char *buf)
+{
+        struct scsi_device *sdev;
+        sdev = to_scsi_device(dev);
+        return snprintf(buf, 20, "%u\n",
+                        jiffies_to_msecs(sdev->queue_ramp_up_period));
+}
+
+static ssize_t
+sdev_store_queue_ramp_up_period(struct device *dev,
+                                struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        struct scsi_device *sdev = to_scsi_device(dev);
+        unsigned long period;
+
+        if (strict_strtoul(buf, 10, &period))
+                return -EINVAL;
+
+        sdev->queue_ramp_up_period = msecs_to_jiffies(period);
+        return period;
+}
+
+static struct device_attribute sdev_attr_queue_ramp_up_period =
+        __ATTR(queue_ramp_up_period, S_IRUGO | S_IWUSR,
+               sdev_show_queue_ramp_up_period,
+               sdev_store_queue_ramp_up_period);
+
+static ssize_t
 sdev_store_queue_type_rw(struct device *dev, struct device_attribute *attr,
                          const char *buf, size_t count)
 {
@@ -813,6 +848,8 @@ static int scsi_target_add(struct scsi_target *starget)
         if (starget->state != STARGET_CREATED)
                 return 0;
 
+        device_enable_async_suspend(&starget->dev);
+
         error = device_add(&starget->dev);
         if (error) {
                 dev_err(&starget->dev, "target device_add failed, error %d\n", error);
@@ -844,7 +881,8 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
         struct request_queue *rq = sdev->request_queue;
         struct scsi_target *starget = sdev->sdev_target;
 
-        if ((error = scsi_device_set_state(sdev, SDEV_RUNNING)) != 0)
+        error = scsi_device_set_state(sdev, SDEV_RUNNING);
+        if (error)
                 return error;
 
         error = scsi_target_add(starget);
@@ -852,34 +890,40 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
                 return error;
 
         transport_configure_device(&starget->dev);
+        device_enable_async_suspend(&sdev->sdev_gendev);
         error = device_add(&sdev->sdev_gendev);
         if (error) {
                 printk(KERN_INFO "error 1\n");
-                goto out_remove;
+                return error;
         }
+        device_enable_async_suspend(&sdev->sdev_dev);
         error = device_add(&sdev->sdev_dev);
         if (error) {
                 printk(KERN_INFO "error 2\n");
                 device_del(&sdev->sdev_gendev);
-                goto out_remove;
+                return error;
         }
         transport_add_device(&sdev->sdev_gendev);
         sdev->is_visible = 1;
 
         /* create queue files, which may be writable, depending on the host */
-        if (sdev->host->hostt->change_queue_depth)
-                error = device_create_file(&sdev->sdev_gendev, &sdev_attr_queue_depth_rw);
+        if (sdev->host->hostt->change_queue_depth) {
+                error = device_create_file(&sdev->sdev_gendev,
+                                           &sdev_attr_queue_depth_rw);
+                error = device_create_file(&sdev->sdev_gendev,
+                                           &sdev_attr_queue_ramp_up_period);
+        }
         else
                 error = device_create_file(&sdev->sdev_gendev, &dev_attr_queue_depth);
         if (error)
-                goto out_remove;
+                return error;
 
         if (sdev->host->hostt->change_queue_type)
                 error = device_create_file(&sdev->sdev_gendev, &sdev_attr_queue_type_rw);
         else
                 error = device_create_file(&sdev->sdev_gendev, &dev_attr_queue_type);
         if (error)
-                goto out_remove;
+                return error;
 
         error = bsg_register_queue(rq, &sdev->sdev_gendev, NULL, NULL);
 
@@ -895,16 +939,11 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
                         error = device_create_file(&sdev->sdev_gendev,
                                         sdev->host->hostt->sdev_attrs[i]);
                         if (error)
-                                goto out_remove;
+                                return error;
                 }
         }
 
-        return 0;
-
- out_remove:
-        __scsi_remove_device(sdev);
         return error;
-
 }
 
 void __scsi_remove_device(struct scsi_device *sdev)
diff --git a/drivers/scsi/scsi_tgt_if.c b/drivers/scsi/scsi_tgt_if.c
index 0e9533f7aabc..a87e21c35ef2 100644
--- a/drivers/scsi/scsi_tgt_if.c
+++ b/drivers/scsi/scsi_tgt_if.c
@@ -20,6 +20,7 @@
  * 02110-1301 USA
  */
 #include <linux/miscdevice.h>
+#include <linux/gfp.h>
 #include <linux/file.h>
 #include <linux/smp_lock.h>
 #include <net/tcp.h>
diff --git a/drivers/scsi/scsi_tgt_lib.c b/drivers/scsi/scsi_tgt_lib.c
index 10303272ba45..66241dd525ae 100644
--- a/drivers/scsi/scsi_tgt_lib.c
+++ b/drivers/scsi/scsi_tgt_lib.c
@@ -23,6 +23,7 @@
 #include <linux/hash.h>
 #include <linux/module.h>
 #include <linux/pagemap.h>
+#include <linux/slab.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index c6f70dae9b2e..6cfffc88022a 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -27,6 +27,8 @@
  */
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_transport.h>
@@ -474,7 +476,8 @@ MODULE_PARM_DESC(dev_loss_tmo,
                  "Maximum number of seconds that the FC transport should"
                  " insulate the loss of a remote port. Once this value is"
                  " exceeded, the scsi target is removed. Value should be"
-                 " between 1 and SCSI_DEVICE_BLOCK_MAX_TIMEOUT.");
+                 " between 1 and SCSI_DEVICE_BLOCK_MAX_TIMEOUT if"
+                 " fast_io_fail_tmo is not set.");
 
 /*
  * Netlink Infrastructure
@@ -648,11 +651,22 @@ static __init int fc_transport_init(void)
                 return error;
         error = transport_class_register(&fc_vport_class);
         if (error)
-                return error;
+                goto unreg_host_class;
         error = transport_class_register(&fc_rport_class);
         if (error)
-                return error;
-        return transport_class_register(&fc_transport_class);
+                goto unreg_vport_class;
+        error = transport_class_register(&fc_transport_class);
+        if (error)
+                goto unreg_rport_class;
+        return 0;
+
+unreg_rport_class:
+        transport_class_unregister(&fc_rport_class);
+unreg_vport_class:
+        transport_class_unregister(&fc_vport_class);
+unreg_host_class:
+        transport_class_unregister(&fc_host_class);
+        return error;
 }
 
 static void __exit fc_transport_exit(void)
@@ -830,9 +844,17 @@ store_fc_rport_dev_loss_tmo(struct device *dev, struct device_attribute *attr,
             (rport->port_state == FC_PORTSTATE_NOTPRESENT))
                 return -EBUSY;
         val = simple_strtoul(buf, &cp, 0);
-        if ((*cp && (*cp != '\n')) ||
-            (val < 0) || (val > SCSI_DEVICE_BLOCK_MAX_TIMEOUT))
+        if ((*cp && (*cp != '\n')) || (val < 0))
                 return -EINVAL;
+
+        /*
+         * If fast_io_fail is off we have to cap
+         * dev_loss_tmo at SCSI_DEVICE_BLOCK_MAX_TIMEOUT
+         */
+        if (rport->fast_io_fail_tmo == -1 &&
+            val > SCSI_DEVICE_BLOCK_MAX_TIMEOUT)
+                return -EINVAL;
+
         i->f->set_rport_dev_loss_tmo(rport, val);
         return count;
 }
@@ -913,9 +935,16 @@ store_fc_rport_fast_io_fail_tmo(struct device *dev,
                 rport->fast_io_fail_tmo = -1;
         else {
                 val = simple_strtoul(buf, &cp, 0);
-                if ((*cp && (*cp != '\n')) ||
-                    (val < 0) || (val >= rport->dev_loss_tmo))
+                if ((*cp && (*cp != '\n')) || (val < 0))
                         return -EINVAL;
+                /*
+                 * Cap fast_io_fail by dev_loss_tmo or
+                 * SCSI_DEVICE_BLOCK_MAX_TIMEOUT.
+                 */
+                if ((val >= rport->dev_loss_tmo) ||
+                    (val > SCSI_DEVICE_BLOCK_MAX_TIMEOUT))
+                        return -EINVAL;
+
                 rport->fast_io_fail_tmo = val;
         }
         return count;
@@ -1204,6 +1233,15 @@ store_fc_vport_delete(struct device *dev, struct device_attribute *attr,
 {
         struct fc_vport *vport = transport_class_to_vport(dev);
         struct Scsi_Host *shost = vport_to_shost(vport);
+        unsigned long flags;
+
+        spin_lock_irqsave(shost->host_lock, flags);
+        if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING)) {
+                spin_unlock_irqrestore(shost->host_lock, flags);
+                return -EBUSY;
+        }
+        vport->flags |= FC_VPORT_DELETING;
+        spin_unlock_irqrestore(shost->host_lock, flags);
 
         fc_queue_work(shost, &vport->vport_delete_work);
         return count;
@@ -1793,6 +1831,9 @@ store_fc_host_vport_delete(struct device *dev, struct device_attribute *attr,
         list_for_each_entry(vport, &fc_host->vports, peers) {
                 if ((vport->channel == 0) &&
                     (vport->port_name == wwpn) && (vport->node_name == wwnn)) {
+                        if (vport->flags & (FC_VPORT_DEL | FC_VPORT_CREATING))
+                                break;
+                        vport->flags |= FC_VPORT_DELETING;
                         match = 1;
                         break;
                 }
@@ -2384,6 +2425,7 @@ fc_rport_final_delete(struct work_struct *work)
         struct Scsi_Host *shost = rport_to_shost(rport);
         struct fc_internal *i = to_fc_internal(shost->transportt);
         unsigned long flags;
+        int do_callback = 0;
 
         /*
          * if a scan is pending, flush the SCSI Host work_q so that
@@ -2422,8 +2464,15 @@ fc_rport_final_delete(struct work_struct *work)
          * Avoid this call if we already called it when we preserved the
          * rport for the binding.
          */
+        spin_lock_irqsave(shost->host_lock, flags);
         if (!(rport->flags & FC_RPORT_DEVLOSS_CALLBK_DONE) &&
-            (i->f->dev_loss_tmo_callbk))
+            (i->f->dev_loss_tmo_callbk)) {
+                rport->flags |= FC_RPORT_DEVLOSS_CALLBK_DONE;
+                do_callback = 1;
+        }
+        spin_unlock_irqrestore(shost->host_lock, flags);
+
+        if (do_callback)
                 i->f->dev_loss_tmo_callbk(rport);
 
         fc_bsg_remove(rport->rqst_q);
@@ -2970,6 +3019,7 @@ fc_timeout_deleted_rport(struct work_struct *work)
         struct fc_internal *i = to_fc_internal(shost->transportt);
         struct fc_host_attrs *fc_host = shost_to_fc_host(shost);
         unsigned long flags;
+        int do_callback = 0;
 
         spin_lock_irqsave(shost->host_lock, flags);
 
@@ -3035,7 +3085,6 @@ fc_timeout_deleted_rport(struct work_struct *work)
         rport->roles = FC_PORT_ROLE_UNKNOWN;
         rport->port_state = FC_PORTSTATE_NOTPRESENT;
         rport->flags &= ~FC_RPORT_FAST_FAIL_TIMEDOUT;
-        rport->flags |= FC_RPORT_DEVLOSS_CALLBK_DONE;
 
         /*
          * Pre-emptively kill I/O rather than waiting for the work queue
@@ -3045,32 +3094,40 @@ fc_timeout_deleted_rport(struct work_struct *work)
         spin_unlock_irqrestore(shost->host_lock, flags);
         fc_terminate_rport_io(rport);
 
-        BUG_ON(rport->port_state != FC_PORTSTATE_NOTPRESENT);
+        spin_lock_irqsave(shost->host_lock, flags);
 
-        /* remove the identifiers that aren't used in the consisting binding */
-        switch (fc_host->tgtid_bind_type) {
-        case FC_TGTID_BIND_BY_WWPN:
-                rport->node_name = -1;
-                rport->port_id = -1;
-                break;
-        case FC_TGTID_BIND_BY_WWNN:
-                rport->port_name = -1;
-                rport->port_id = -1;
-                break;
-        case FC_TGTID_BIND_BY_ID:
-                rport->node_name = -1;
-                rport->port_name = -1;
-                break;
-        case FC_TGTID_BIND_NONE:        /* to keep compiler happy */
-                break;
+        if (rport->port_state == FC_PORTSTATE_NOTPRESENT) {     /* still missing */
+
+                /* remove the identifiers that aren't used in the consisting binding */
+                switch (fc_host->tgtid_bind_type) {
+                case FC_TGTID_BIND_BY_WWPN:
+                        rport->node_name = -1;
+                        rport->port_id = -1;
+                        break;
+                case FC_TGTID_BIND_BY_WWNN:
+                        rport->port_name = -1;
+                        rport->port_id = -1;
+                        break;
+                case FC_TGTID_BIND_BY_ID:
+                        rport->node_name = -1;
+                        rport->port_name = -1;
+                        break;
+                case FC_TGTID_BIND_NONE:        /* to keep compiler happy */
+                        break;
+                }
+
+                /*
+                 * As this only occurs if the remote port (scsi target)
+                 * went away and didn't come back - we'll remove
+                 * all attached scsi devices.
+                 */
+                rport->flags |= FC_RPORT_DEVLOSS_CALLBK_DONE;
+                fc_queue_work(shost, &rport->stgt_delete_work);
+
+                do_callback = 1;
         }
 
-        /*
-         * As this only occurs if the remote port (scsi target)
-         * went away and didn't come back - we'll remove
-         * all attached scsi devices.
-         */
-        fc_queue_work(shost, &rport->stgt_delete_work);
+        spin_unlock_irqrestore(shost->host_lock, flags);
 
         /*
          * Notify the driver that the rport is now dead. The LLDD will
@@ -3078,7 +3135,7 @@ fc_timeout_deleted_rport(struct work_struct *work)
          *
          * Note: we set the CALLBK_DONE flag above to correspond
          */
-        if (i->f->dev_loss_tmo_callbk)
+        if (do_callback && i->f->dev_loss_tmo_callbk)
                 i->f->dev_loss_tmo_callbk(rport);
 }
 
@@ -3128,6 +3185,31 @@ fc_scsi_scan_rport(struct work_struct *work)
         spin_unlock_irqrestore(shost->host_lock, flags);
 }
 
+/**
+ * fc_block_scsi_eh - Block SCSI eh thread for blocked fc_rport
+ * @cmnd: SCSI command that scsi_eh is trying to recover
+ *
+ * This routine can be called from a FC LLD scsi_eh callback. It
+ * blocks the scsi_eh thread until the fc_rport leaves the
+ * FC_PORTSTATE_BLOCKED. This is necessary to avoid the scsi_eh
+ * failing recovery actions for blocked rports which would lead to
+ * offlined SCSI devices.
+ */
+void fc_block_scsi_eh(struct scsi_cmnd *cmnd)
+{
+        struct Scsi_Host *shost = cmnd->device->host;
+        struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device));
+        unsigned long flags;
+
+        spin_lock_irqsave(shost->host_lock, flags);
+        while (rport->port_state == FC_PORTSTATE_BLOCKED) {
+                spin_unlock_irqrestore(shost->host_lock, flags);
+                msleep(1000);
+                spin_lock_irqsave(shost->host_lock, flags);
+        }
+        spin_unlock_irqrestore(shost->host_lock, flags);
+}
+EXPORT_SYMBOL(fc_block_scsi_eh);
 
 /**
  * fc_vport_setup - allocates and creates a FC virtual port.
@@ -3301,18 +3383,6 @@ fc_vport_terminate(struct fc_vport *vport)
         unsigned long flags;
         int stat;
 
-        spin_lock_irqsave(shost->host_lock, flags);
-        if (vport->flags & FC_VPORT_CREATING) {
-                spin_unlock_irqrestore(shost->host_lock, flags);
-                return -EBUSY;
-        }
-        if (vport->flags & (FC_VPORT_DEL)) {
-                spin_unlock_irqrestore(shost->host_lock, flags);
-                return -EALREADY;
-        }
-        vport->flags |= FC_VPORT_DELETING;
-        spin_unlock_irqrestore(shost->host_lock, flags);
-
         if (i->f->vport_delete)
                 stat = i->f->vport_delete(vport);
         else
@@ -3474,7 +3544,10 @@ fc_bsg_job_timeout(struct request *req)
         if (!done && i->f->bsg_timeout) {
                 /* call LLDD to abort the i/o as it has timed out */
                 err = i->f->bsg_timeout(job);
-                if (err)
+                if (err == -EAGAIN) {
+                        job->ref_cnt--;
+                        return BLK_EH_RESET_TIMER;
+                } else if (err)
                         printk(KERN_ERR "ERROR: FC BSG request timeout - LLD "
                                 "abort failed with status %d\n", err);
         }
@@ -3769,8 +3842,9 @@ fc_bsg_request_handler(struct request_queue *q, struct Scsi_Host *shost,
                 return;
 
         while (!blk_queue_plugged(q)) {
-                if (rport && (rport->port_state == FC_PORTSTATE_BLOCKED))
-                                break;
+                if (rport && (rport->port_state == FC_PORTSTATE_BLOCKED) &&
+                    !(rport->flags & FC_RPORT_FAST_FAIL_TIMEDOUT))
+                        break;
 
                 req = blk_fetch_request(q);
                 if (!req)
@@ -3779,7 +3853,7 @@ fc_bsg_request_handler(struct request_queue *q, struct Scsi_Host *shost,
                 if (rport && (rport->port_state != FC_PORTSTATE_ONLINE)) {
                         req->errors = -ENXIO;
                         spin_unlock_irq(q->queue_lock);
-                        blk_end_request(req, -ENXIO, blk_rq_bytes(req));
+                        blk_end_request_all(req, -ENXIO);
                         spin_lock_irq(q->queue_lock);
                         continue;
                 }
@@ -3789,7 +3863,7 @@ fc_bsg_request_handler(struct request_queue *q, struct Scsi_Host *shost,
                 ret = fc_req_to_bsgjob(shost, rport, req);
                 if (ret) {
                         req->errors = ret;
-                        blk_end_request(req, ret, blk_rq_bytes(req));
+                        blk_end_request_all(req, ret);
                         spin_lock_irq(q->queue_lock);
                         continue;
                 }
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
index ad897df36615..1e6d4793542c 100644
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -22,6 +22,7 @@
  */
 #include <linux/module.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 #include <net/tcp.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
@@ -30,7 +31,7 @@
 #include <scsi/scsi_transport_iscsi.h>
 #include <scsi/iscsi_if.h>
 
-#define ISCSI_SESSION_ATTRS 21
+#define ISCSI_SESSION_ATTRS 22
 #define ISCSI_CONN_ATTRS 13
 #define ISCSI_HOST_ATTRS 4
 
@@ -627,8 +628,10 @@ static void __iscsi_block_session(struct work_struct *work)
         spin_unlock_irqrestore(&session->lock, flags);
         scsi_target_block(&session->dev);
         ISCSI_DBG_TRANS_SESSION(session, "Completed SCSI target blocking\n");
-        queue_delayed_work(iscsi_eh_timer_workq, &session->recovery_work,
-                           session->recovery_tmo * HZ);
+        if (session->recovery_tmo >= 0)
+                queue_delayed_work(iscsi_eh_timer_workq,
+                                   &session->recovery_work,
+                                   session->recovery_tmo * HZ);
 }
 
 void iscsi_block_session(struct iscsi_cls_session *session)
@@ -1348,8 +1351,7 @@ iscsi_set_param(struct iscsi_transport *transport, struct iscsi_uevent *ev)
         switch (ev->u.set_param.param) {
         case ISCSI_PARAM_SESS_RECOVERY_TMO:
                 sscanf(data, "%d", &value);
-                if (value != 0)
-                        session->recovery_tmo = value;
+                session->recovery_tmo = value;
                 break;
         default:
                 err = transport->set_param(conn, ev->u.set_param.param,
@@ -1759,6 +1761,7 @@ iscsi_session_attr(password_in, ISCSI_PARAM_PASSWORD_IN, 1);
 iscsi_session_attr(fast_abort, ISCSI_PARAM_FAST_ABORT, 0);
 iscsi_session_attr(abort_tmo, ISCSI_PARAM_ABORT_TMO, 0);
 iscsi_session_attr(lu_reset_tmo, ISCSI_PARAM_LU_RESET_TMO, 0);
+iscsi_session_attr(tgt_reset_tmo, ISCSI_PARAM_TGT_RESET_TMO, 0);
 iscsi_session_attr(ifacename, ISCSI_PARAM_IFACE_NAME, 0);
 iscsi_session_attr(initiatorname, ISCSI_PARAM_INITIATOR_NAME, 0)
 
@@ -2000,6 +2003,7 @@ iscsi_register_transport(struct iscsi_transport *tt)
         SETUP_SESSION_RD_ATTR(fast_abort, ISCSI_FAST_ABORT);
         SETUP_SESSION_RD_ATTR(abort_tmo, ISCSI_ABORT_TMO);
         SETUP_SESSION_RD_ATTR(lu_reset_tmo,ISCSI_LU_RESET_TMO);
+        SETUP_SESSION_RD_ATTR(tgt_reset_tmo,ISCSI_TGT_RESET_TMO);
         SETUP_SESSION_RD_ATTR(ifacename, ISCSI_IFACE_NAME);
         SETUP_SESSION_RD_ATTR(initiatorname, ISCSI_INITIATOR_NAME);
         SETUP_PRIV_SESSION_RD_ATTR(recovery_tmo);
diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c
index fd47cb1bee1b..927e99cb7225 100644
--- a/drivers/scsi/scsi_transport_sas.c
+++ b/drivers/scsi/scsi_transport_sas.c
@@ -155,6 +155,17 @@ static struct {
 sas_bitfield_name_search(linkspeed, sas_linkspeed_names)
 sas_bitfield_name_set(linkspeed, sas_linkspeed_names)
 
+static struct sas_end_device *sas_sdev_to_rdev(struct scsi_device *sdev)
+{
+        struct sas_rphy *rphy = target_to_rphy(sdev->sdev_target);
+        struct sas_end_device *rdev;
+
+        BUG_ON(rphy->identify.device_type != SAS_END_DEVICE);
+
+        rdev = rphy_to_end_device(rphy);
+        return rdev;
+}
+
 static void sas_smp_request(struct request_queue *q, struct Scsi_Host *shost,
                             struct sas_rphy *rphy)
 {
@@ -358,6 +369,85 @@ void sas_remove_host(struct Scsi_Host *shost)
 }
 EXPORT_SYMBOL(sas_remove_host);
 
+/**
+ * sas_tlr_supported - checking TLR bit in vpd 0x90
+ * @sdev: scsi device struct
+ *
+ * Check Transport Layer Retries are supported or not.
+ * If vpd page 0x90 is present, TRL is supported.
+ *
+ */
+unsigned int
+sas_tlr_supported(struct scsi_device *sdev)
+{
+        const int vpd_len = 32;
+        struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
+        char *buffer = kzalloc(vpd_len, GFP_KERNEL);
+        int ret = 0;
+
+        if (scsi_get_vpd_page(sdev, 0x90, buffer, vpd_len))
+                goto out;
+
+        /*
+         * Magic numbers: the VPD Protocol page (0x90)
+         * has a 4 byte header and then one entry per device port
+         * the TLR bit is at offset 8 on each port entry
+         * if we take the first port, that's at total offset 12
+         */
+        ret = buffer[12] & 0x01;
+
+ out:
+        kfree(buffer);
+        rdev->tlr_supported = ret;
+        return ret;
+
+}
+EXPORT_SYMBOL_GPL(sas_tlr_supported);
+
+/**
+ * sas_disable_tlr - setting TLR flags
+ * @sdev: scsi device struct
+ *
+ * Seting tlr_enabled flag to 0.
+ *
+ */
+void
+sas_disable_tlr(struct scsi_device *sdev)
+{
+        struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
+
+        rdev->tlr_enabled = 0;
+}
+EXPORT_SYMBOL_GPL(sas_disable_tlr);
+
+/**
+ * sas_enable_tlr - setting TLR flags
+ * @sdev: scsi device struct
+ *
+ * Seting tlr_enabled flag 1.
+ *
+ */
+void sas_enable_tlr(struct scsi_device *sdev)
+{
+        unsigned int tlr_supported = 0;
+        tlr_supported  = sas_tlr_supported(sdev);
+
+        if (tlr_supported) {
+                struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
+
+                rdev->tlr_enabled = 1;
+        }
+
+        return;
+}
+EXPORT_SYMBOL_GPL(sas_enable_tlr);
+
+unsigned int sas_is_tlr_enabled(struct scsi_device *sdev)
+{
+        struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
+        return rdev->tlr_enabled;
+}
+EXPORT_SYMBOL_GPL(sas_is_tlr_enabled);
 
 /*
  * SAS Phy attributes
@@ -666,7 +756,7 @@ EXPORT_SYMBOL(sas_phy_add);
  *
  * Note:
  *   This function must only be called on a PHY that has not
- *   sucessfully been added using sas_phy_add().
+ *   successfully been added using sas_phy_add().
  */
 void sas_phy_free(struct sas_phy *phy)
 {
@@ -896,7 +986,7 @@ EXPORT_SYMBOL(sas_port_add);
  *
  * Note:
  *   This function must only be called on a PORT that has not
- *   sucessfully been added using sas_port_add().
+ *   successfully been added using sas_port_add().
  */
 void sas_port_free(struct sas_port *port)
 {
@@ -1146,15 +1236,10 @@ sas_rphy_simple_attr(identify.phy_identifier, phy_identifier, "%d\n", u8);
 int sas_read_port_mode_page(struct scsi_device *sdev)
 {
         char *buffer = kzalloc(BUF_SIZE, GFP_KERNEL), *msdata;
-        struct sas_rphy *rphy = target_to_rphy(sdev->sdev_target);
-        struct sas_end_device *rdev;
+        struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
         struct scsi_mode_data mode_data;
         int res, error;
 
-        BUG_ON(rphy->identify.device_type != SAS_END_DEVICE);
-
-        rdev = rphy_to_end_device(rphy);
-
         if (!buffer)
                 return -ENOMEM;
 
@@ -1207,6 +1292,10 @@ sas_end_dev_simple_attr(I_T_nexus_loss_timeout, I_T_nexus_loss_timeout,
                         "%d\n", int);
 sas_end_dev_simple_attr(initiator_response_timeout, initiator_response_timeout,
                         "%d\n", int);
+sas_end_dev_simple_attr(tlr_supported, tlr_supported,
+                        "%d\n", int);
+sas_end_dev_simple_attr(tlr_enabled, tlr_enabled,
+                        "%d\n", int);
 
 static DECLARE_TRANSPORT_CLASS(sas_expander_class,
                                "sas_expander", NULL, NULL, NULL);
@@ -1476,7 +1565,7 @@ EXPORT_SYMBOL(sas_rphy_add);
  *
  * Note:
  *   This function must only be called on a remote
- *   PHY that has not sucessfully been added using
+ *   PHY that has not successfully been added using
  *   sas_rphy_add() (or has been sas_rphy_remove()'d)
  */
 void sas_rphy_free(struct sas_rphy *rphy)
@@ -1733,6 +1822,8 @@ sas_attach_transport(struct sas_function_template *ft)
         SETUP_END_DEV_ATTRIBUTE(end_dev_ready_led_meaning);
         SETUP_END_DEV_ATTRIBUTE(end_dev_I_T_nexus_loss_timeout);
         SETUP_END_DEV_ATTRIBUTE(end_dev_initiator_response_timeout);
+        SETUP_END_DEV_ATTRIBUTE(end_dev_tlr_supported);
+        SETUP_END_DEV_ATTRIBUTE(end_dev_tlr_enabled);
         i->end_dev_attrs[count] = NULL;
 
         count = 0;
diff --git a/drivers/scsi/scsi_transport_spi.c b/drivers/scsi/scsi_transport_spi.c
index c25bd9a34e02..8a172d4f4564 100644
--- a/drivers/scsi/scsi_transport_spi.c
+++ b/drivers/scsi/scsi_transport_spi.c
@@ -25,6 +25,7 @@
 #include <linux/blkdev.h>
 #include <linux/mutex.h>
 #include <linux/sysfs.h>
+#include <linux/slab.h>
 #include <scsi/scsi.h>
 #include "scsi_priv.h"
 #include <scsi/scsi_device.h>
diff --git a/drivers/scsi/scsicam.c b/drivers/scsi/scsicam.c
index 3f21bc65e8c6..6803b1e26ecc 100644
--- a/drivers/scsi/scsicam.c
+++ b/drivers/scsi/scsicam.c
@@ -11,6 +11,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/fs.h>
 #include <linux/genhd.h>
 #include <linux/kernel.h>
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 9093c7261f33..de6c60320f6f 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -49,6 +49,7 @@
 #include <linux/mutex.h>
 #include <linux/string_helpers.h>
 #include <linux/async.h>
+#include <linux/slab.h>
 #include <asm/uaccess.h>
 #include <asm/unaligned.h>
 
@@ -264,6 +265,15 @@ sd_show_app_tag_own(struct device *dev, struct device_attribute *attr,
         return snprintf(buf, 20, "%u\n", sdkp->ATO);
 }
 
+static ssize_t
+sd_show_thin_provisioning(struct device *dev, struct device_attribute *attr,
+                          char *buf)
+{
+        struct scsi_disk *sdkp = to_scsi_disk(dev);
+
+        return snprintf(buf, 20, "%u\n", sdkp->thin_provisioning);
+}
+
 static struct device_attribute sd_disk_attrs[] = {
         __ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type,
                sd_store_cache_type),
@@ -274,6 +284,7 @@ static struct device_attribute sd_disk_attrs[] = {
                sd_store_manage_start_stop),
         __ATTR(protection_type, S_IRUGO, sd_show_protection_type, NULL),
         __ATTR(app_tag_own, S_IRUGO, sd_show_app_tag_own, NULL),
+        __ATTR(thin_provisioning, S_IRUGO, sd_show_thin_provisioning, NULL),
         __ATTR_NULL,
 };
 
@@ -399,6 +410,57 @@ static void sd_prot_op(struct scsi_cmnd *scmd, unsigned int dif)
 }
 
 /**
+ * sd_prepare_discard - unmap blocks on thinly provisioned device
+ * @rq: Request to prepare
+ *
+ * Will issue either UNMAP or WRITE SAME(16) depending on preference
+ * indicated by target device.
+ **/
+static int sd_prepare_discard(struct request *rq)
+{
+        struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
+        struct bio *bio = rq->bio;
+        sector_t sector = bio->bi_sector;
+        unsigned int num = bio_sectors(bio);
+
+        if (sdkp->device->sector_size == 4096) {
+                sector >>= 3;
+                num >>= 3;
+        }
+
+        rq->cmd_type = REQ_TYPE_BLOCK_PC;
+        rq->timeout = SD_TIMEOUT;
+
+        memset(rq->cmd, 0, rq->cmd_len);
+
+        if (sdkp->unmap) {
+                char *buf = kmap_atomic(bio_page(bio), KM_USER0);
+
+                rq->cmd[0] = UNMAP;
+                rq->cmd[8] = 24;
+                rq->cmd_len = 10;
+
+                /* Ensure that data length matches payload */
+                rq->__data_len = bio->bi_size = bio->bi_io_vec->bv_len = 24;
+
+                put_unaligned_be16(6 + 16, &buf[0]);
+                put_unaligned_be16(16, &buf[2]);
+                put_unaligned_be64(sector, &buf[8]);
+                put_unaligned_be32(num, &buf[16]);
+
+                kunmap_atomic(buf, KM_USER0);
+        } else {
+                rq->cmd[0] = WRITE_SAME_16;
+                rq->cmd[1] = 0x8; /* UNMAP */
+                put_unaligned_be64(sector, &rq->cmd[2]);
+                put_unaligned_be32(num, &rq->cmd[10]);
+                rq->cmd_len = 16;
+        }
+
+        return BLKPREP_OK;
+}
+
+/**
  *      sd_init_command - build a scsi (read or write) command from
  *      information in the request structure.
  *      @SCpnt: pointer to mid-level's per scsi command structure that
@@ -418,6 +480,13 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
         int ret, host_dif;
         unsigned char protect;
 
+        /*
+         * Discard request come in as REQ_TYPE_FS but we turn them into
+         * block PC requests to make life easier.
+         */
+        if (blk_discard_rq(rq))
+                ret = sd_prepare_discard(rq);
+
         if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
                 ret = scsi_setup_blk_pc_cmnd(sdp, rq);
                 goto out;
@@ -971,6 +1040,7 @@ static void sd_prepare_flush(struct request_queue *q, struct request *rq)
 {
         rq->cmd_type = REQ_TYPE_BLOCK_PC;
         rq->timeout = SD_TIMEOUT;
+        rq->retries = SD_MAX_RETRIES;
         rq->cmd[0] = SYNCHRONIZE_CACHE;
         rq->cmd_len = 10;
 }
@@ -1128,19 +1198,10 @@ static int sd_done(struct scsi_cmnd *SCpnt)
                 SCpnt->result = 0;
                 memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
                 break;
-        case ABORTED_COMMAND:
-                if (sshdr.asc == 0x10) { /* DIF: Disk detected corruption */
-                        scsi_print_result(SCpnt);
-                        scsi_print_sense("sd", SCpnt);
+        case ABORTED_COMMAND: /* DIF: Target detected corruption */
+        case ILLEGAL_REQUEST: /* DIX: Host detected corruption */
+                if (sshdr.asc == 0x10)
                         good_bytes = sd_completed_bytes(SCpnt);
-                }
-                break;
-        case ILLEGAL_REQUEST:
-                if (sshdr.asc == 0x10) { /* DIX: HBA detected corruption */
-                        scsi_print_result(SCpnt);
-                        scsi_print_sense("sd", SCpnt);
-                        good_bytes = sd_completed_bytes(SCpnt);
-                }
                 break;
         default:
                 break;
@@ -1150,8 +1211,19 @@ static int sd_done(struct scsi_cmnd *SCpnt)
                 sd_dif_complete(SCpnt, good_bytes);
 
         if (scsi_host_dif_capable(sdkp->device->host, sdkp->protection_type)
-            == SD_DIF_TYPE2_PROTECTION && SCpnt->cmnd != SCpnt->request->cmd)
+            == SD_DIF_TYPE2_PROTECTION && SCpnt->cmnd != SCpnt->request->cmd) {
+
+                /* We have to print a failed command here as the
+                 * extended CDB gets freed before scsi_io_completion()
+                 * is called.
+                 */
+                if (result)
+                        scsi_print_command(SCpnt);
+
                 mempool_free(SCpnt->cmnd, sd_cdb_pool);
+                SCpnt->cmnd = NULL;
+                SCpnt->cmd_len = 0;
+        }
 
         return good_bytes;
 }
@@ -1432,6 +1504,19 @@ static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
                 sd_printk(KERN_NOTICE, sdkp,
                           "physical block alignment offset: %u\n", alignment);
 
+        if (buffer[14] & 0x80) { /* TPE */
+                struct request_queue *q = sdp->request_queue;
+
+                sdkp->thin_provisioning = 1;
+                q->limits.discard_granularity = sdkp->hw_sector_size;
+                q->limits.max_discard_sectors = 0xffffffff;
+
+                if (buffer[14] & 0x40) /* TPRZ */
+                        q->limits.discard_zeroes_data = 1;
+
+                queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
+        }
+
         sdkp->capacity = lba + 1;
         return sector_size;
 }
@@ -1863,20 +1948,47 @@ void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer)
  */
 static void sd_read_block_limits(struct scsi_disk *sdkp)
 {
+        struct request_queue *q = sdkp->disk->queue;
         unsigned int sector_sz = sdkp->device->sector_size;
-        char *buffer;
+        const int vpd_len = 64;
+        unsigned char *buffer = kmalloc(vpd_len, GFP_KERNEL);
 
-        /* Block Limits VPD */
-        buffer = scsi_get_vpd_page(sdkp->device, 0xb0);
-
-        if (buffer == NULL)
-                return;
+        if (!buffer ||
+            /* Block Limits VPD */
+            scsi_get_vpd_page(sdkp->device, 0xb0, buffer, vpd_len))
+                goto out;
 
         blk_queue_io_min(sdkp->disk->queue,
                          get_unaligned_be16(&buffer[6]) * sector_sz);
         blk_queue_io_opt(sdkp->disk->queue,
                          get_unaligned_be32(&buffer[12]) * sector_sz);
 
+        /* Thin provisioning enabled and page length indicates TP support */
+        if (sdkp->thin_provisioning && buffer[3] == 0x3c) {
+                unsigned int lba_count, desc_count, granularity;
+
+                lba_count = get_unaligned_be32(&buffer[20]);
+                desc_count = get_unaligned_be32(&buffer[24]);
+
+                if (lba_count) {
+                        q->limits.max_discard_sectors =
+                                lba_count * sector_sz >> 9;
+
+                        if (desc_count)
+                                sdkp->unmap = 1;
+                }
+
+                granularity = get_unaligned_be32(&buffer[28]);
+
+                if (granularity)
+                        q->limits.discard_granularity = granularity * sector_sz;
+
+                if (buffer[32] & 0x80)
+                        q->limits.discard_alignment =
+                                get_unaligned_be32(&buffer[32]) & ~(1 << 31);
+        }
+
+ out:
         kfree(buffer);
 }
 
@@ -1886,20 +1998,23 @@ static void sd_read_block_limits(struct scsi_disk *sdkp)
  */
 static void sd_read_block_characteristics(struct scsi_disk *sdkp)
 {
-        char *buffer;
+        unsigned char *buffer;
         u16 rot;
+        const int vpd_len = 64;
 
-        /* Block Device Characteristics VPD */
-        buffer = scsi_get_vpd_page(sdkp->device, 0xb1);
+        buffer = kmalloc(vpd_len, GFP_KERNEL);
 
-        if (buffer == NULL)
-                return;
+        if (!buffer ||
+            /* Block Device Characteristics VPD */
+            scsi_get_vpd_page(sdkp->device, 0xb1, buffer, vpd_len))
+                goto out;
 
         rot = get_unaligned_be16(&buffer[4]);
 
         if (rot == 1)
                 queue_flag_set_unlocked(QUEUE_FLAG_NONROT, sdkp->disk->queue);
 
+ out:
         kfree(buffer);
 }
 
@@ -1998,7 +2113,7 @@ static int sd_revalidate_disk(struct gendisk *disk)
  *      which is followed by sdaaa.
  *
  *      This is basically 26 base counting with one extra 'nil' entry
- *      at the beggining from the second digit on and can be
+ *      at the beginning from the second digit on and can be
  *      determined using similar method as 26 base conversion with the
  *      index shifted -1 after each digit is computed.
  *
@@ -2072,7 +2187,7 @@ static void sd_probe_async(void *data, async_cookie_t cookie)
         blk_queue_prep_rq(sdp->request_queue, sd_prep_fn);
 
         gd->driverfs_dev = &sdp->sdev_gendev;
-        gd->flags = GENHD_FL_EXT_DEVT | GENHD_FL_DRIVERFS;
+        gd->flags = GENHD_FL_EXT_DEVT;
         if (sdp->removable)
                 gd->flags |= GENHD_FL_REMOVABLE;
 
diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h
index e374804d26fb..43d3caf268ef 100644
--- a/drivers/scsi/sd.h
+++ b/drivers/scsi/sd.h
@@ -60,6 +60,8 @@ struct scsi_disk {
         unsigned        RCD : 1;        /* state of disk RCD bit, unused */
         unsigned        DPOFUA : 1;     /* state of disk DPOFUA bit */
         unsigned        first_scan : 1;
+        unsigned        thin_provisioning : 1;
+        unsigned        unmap : 1;
 };
 #define to_scsi_disk(obj) container_of(obj,struct scsi_disk,dev)
 
diff --git a/drivers/scsi/ses.c b/drivers/scsi/ses.c
index 55b034b72708..7f5a6a86f820 100644
--- a/drivers/scsi/ses.c
+++ b/drivers/scsi/ses.c
@@ -21,6 +21,7 @@
 **-----------------------------------------------------------------------------
 */
 
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/enclosure.h>
@@ -448,13 +449,17 @@ static void ses_match_to_enclosure(struct enclosure_device *edev,
                 .addr = 0,
         };
 
-        buf = scsi_get_vpd_page(sdev, 0x83);
-        if (!buf)
-                return;
+        buf = kmalloc(INIT_ALLOC_SIZE, GFP_KERNEL);
+        if (!buf || scsi_get_vpd_page(sdev, 0x83, buf, INIT_ALLOC_SIZE))
+                goto free;
 
         ses_enclosure_data_process(edev, to_scsi_device(edev->edev.parent), 0);
 
         vpd_len = ((buf[2] << 8) | buf[3]) + 4;
+        kfree(buf);
+        buf = kmalloc(vpd_len, GFP_KERNEL);
+        if (!buf ||scsi_get_vpd_page(sdev, 0x83, buf, vpd_len))
+                goto free;
 
         desc = buf + 4;
         while (desc < buf + vpd_len) {
@@ -591,8 +596,6 @@ static int ses_intf_add(struct device *cdev,
                 ses_dev->page10_len = len;
                 buf = NULL;
         }
-        kfree(hdr_buf);
-
         scomp = kzalloc(sizeof(struct ses_component) * components, GFP_KERNEL);
         if (!scomp)
                 goto err_free;
@@ -604,6 +607,8 @@ static int ses_intf_add(struct device *cdev,
                 goto err_free;
         }
 
+        kfree(hdr_buf);
+
         edev->scratch = ses_dev;
         for (i = 0; i < components; i++)
                 edev->component[i].scratch = scomp + i;
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 040f751809ea..dee1c96288d4 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -38,6 +38,7 @@ static int sg_version_num = 30534;	/* 2 digits for each component */
 #include <linux/errno.h>
 #include <linux/mtio.h>
 #include <linux/ioctl.h>
+#include <linux/slab.h>
 #include <linux/fcntl.h>
 #include <linux/init.h>
 #include <linux/poll.h>
@@ -287,8 +288,7 @@ sg_open(struct inode *inode, struct file *filp)
         if (list_empty(&sdp->sfds)) {   /* no existing opens on this device */
                 sdp->sgdebug = 0;
                 q = sdp->device->request_queue;
-                sdp->sg_tablesize = min(queue_max_hw_segments(q),
-                                        queue_max_phys_segments(q));
+                sdp->sg_tablesize = queue_max_segments(q);
         }
         if ((sfp = sg_add_sfp(sdp, dev)))
                 filp->private_data = sfp;
@@ -1376,8 +1376,7 @@ static Sg_device *sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
         sdp->device = scsidp;
         INIT_LIST_HEAD(&sdp->sfds);
         init_waitqueue_head(&sdp->o_excl_wait);
-        sdp->sg_tablesize = min(queue_max_hw_segments(q),
-                                queue_max_phys_segments(q));
+        sdp->sg_tablesize = queue_max_segments(q);
         sdp->index = k;
         kref_init(&sdp->d_ref);
 
diff --git a/drivers/scsi/sgiwd93.c b/drivers/scsi/sgiwd93.c
index 0807b260268b..fef0e3c75b16 100644
--- a/drivers/scsi/sgiwd93.c
+++ b/drivers/scsi/sgiwd93.c
@@ -226,7 +226,7 @@ static struct scsi_host_template sgiwd93_template = {
         .use_clustering         = DISABLE_CLUSTERING,
 };
 
-static int __init sgiwd93_probe(struct platform_device *pdev)
+static int __devinit sgiwd93_probe(struct platform_device *pdev)
 {
         struct sgiwd93_platform_data *pd = pdev->dev.platform_data;
         unsigned char *wdregs = pd->wdregs;
diff --git a/drivers/scsi/sim710.c b/drivers/scsi/sim710.c
index 6dc8b846c112..8ac6ce792b69 100644
--- a/drivers/scsi/sim710.c
+++ b/drivers/scsi/sim710.c
@@ -27,6 +27,7 @@
  */
 
 #include <linux/module.h>
+#include <linux/slab.h>
 
 #include <linux/blkdev.h>
 #include <linux/device.h>
diff --git a/drivers/scsi/sni_53c710.c b/drivers/scsi/sni_53c710.c
index 37b3359e863e..9acc2b2a3601 100644
--- a/drivers/scsi/sni_53c710.c
+++ b/drivers/scsi/sni_53c710.c
@@ -30,6 +30,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/types.h>
+#include <linux/slab.h>
 #include <linux/stat.h>
 #include <linux/mm.h>
 #include <linux/blkdev.h>
@@ -64,7 +65,7 @@ static struct scsi_host_template snirm710_template = {
         .module         = THIS_MODULE,
 };
 
-static int __init snirm710_probe(struct platform_device *dev)
+static int __devinit snirm710_probe(struct platform_device *dev)
 {
         unsigned long base;
         struct NCR_700_Host_Parameters *hostdata;
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index d6f340f48a3b..0a90abc7f140 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -44,6 +44,7 @@
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/mutex.h>
+#include <linux/slab.h>
 #include <asm/uaccess.h>
 
 #include <scsi/scsi.h>
diff --git a/drivers/scsi/sr_ioctl.c b/drivers/scsi/sr_ioctl.c
index 291236e6e435..cbb38c5197fa 100644
--- a/drivers/scsi/sr_ioctl.c
+++ b/drivers/scsi/sr_ioctl.c
@@ -7,6 +7,7 @@
 #include <linux/blkpg.h>
 #include <linux/cdrom.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
 
diff --git a/drivers/scsi/sr_vendor.c b/drivers/scsi/sr_vendor.c
index 4ad3e017213f..92cc2efb25d7 100644
--- a/drivers/scsi/sr_vendor.c
+++ b/drivers/scsi/sr_vendor.c
@@ -39,6 +39,7 @@
 #include <linux/string.h>
 #include <linux/bcd.h>
 #include <linux/blkdev.h>
+#include <linux/slab.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 12d58a7ed6bc..3ea1a713ef25 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -27,6 +27,7 @@ static const char *verstr = "20081215";
 #include <linux/mm.h>
 #include <linux/init.h>
 #include <linux/string.h>
+#include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/mtio.h>
 #include <linux/cdrom.h>
@@ -552,13 +553,15 @@ st_do_scsi(struct st_request * SRpnt, struct scsi_tape * STp, unsigned char *cmd
         SRpnt->waiting = waiting;
 
         if (STp->buffer->do_dio) {
+                mdata->page_order = 0;
                 mdata->nr_entries = STp->buffer->sg_segs;
                 mdata->pages = STp->buffer->mapped_pages;
         } else {
+                mdata->page_order = STp->buffer->reserved_page_order;
                 mdata->nr_entries =
                         DIV_ROUND_UP(bytes, PAGE_SIZE << mdata->page_order);
-                STp->buffer->map_data.pages = STp->buffer->reserved_pages;
-                STp->buffer->map_data.offset = 0;
+                mdata->pages = STp->buffer->reserved_pages;
+                mdata->offset = 0;
         }
 
         memcpy(SRpnt->cmd, cmd, sizeof(SRpnt->cmd));
@@ -2280,7 +2283,8 @@ static int st_set_options(struct scsi_tape *STp, long options)
         } else if (code == MT_ST_SET_CLN) {
                 value = (options & ~MT_ST_OPTIONS) & 0xff;
                 if (value != 0 &&
-                    value < EXTENDED_SENSE_START && value >= SCSI_SENSE_BUFFERSIZE)
+                        (value < EXTENDED_SENSE_START ||
+                                value >= SCSI_SENSE_BUFFERSIZE))
                         return (-EINVAL);
                 STp->cln_mode = value;
                 STp->cln_sense_mask = (options >> 8) & 0xff;
@@ -3718,7 +3722,7 @@ static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dm
                 priority |= __GFP_ZERO;
 
         if (STbuffer->frp_segs) {
-                order = STbuffer->map_data.page_order;
+                order = STbuffer->reserved_page_order;
                 b_size = PAGE_SIZE << order;
         } else {
                 for (b_size = PAGE_SIZE, order = 0;
@@ -3751,7 +3755,7 @@ static int enlarge_buffer(struct st_buffer * STbuffer, int new_size, int need_dm
                 segs++;
         }
         STbuffer->b_data = page_address(STbuffer->reserved_pages[0]);
-        STbuffer->map_data.page_order = order;
+        STbuffer->reserved_page_order = order;
 
         return 1;
 }
@@ -3764,7 +3768,7 @@ static void clear_buffer(struct st_buffer * st_bp)
 
         for (i=0; i < st_bp->frp_segs; i++)
                 memset(page_address(st_bp->reserved_pages[i]), 0,
-                       PAGE_SIZE << st_bp->map_data.page_order);
+                       PAGE_SIZE << st_bp->reserved_page_order);
         st_bp->cleared = 1;
 }
 
@@ -3772,7 +3776,7 @@ static void clear_buffer(struct st_buffer * st_bp)
 /* Release the extra buffer */
 static void normalize_buffer(struct st_buffer * STbuffer)
 {
-        int i, order = STbuffer->map_data.page_order;
+        int i, order = STbuffer->reserved_page_order;
 
         for (i = 0; i < STbuffer->frp_segs; i++) {
                 __free_pages(STbuffer->reserved_pages[i], order);
@@ -3780,7 +3784,7 @@ static void normalize_buffer(struct st_buffer * STbuffer)
         }
         STbuffer->frp_segs = 0;
         STbuffer->sg_segs = 0;
-        STbuffer->map_data.page_order = 0;
+        STbuffer->reserved_page_order = 0;
         STbuffer->map_data.offset = 0;
 }
 
@@ -3790,7 +3794,7 @@ static void normalize_buffer(struct st_buffer * STbuffer)
 static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, int do_count)
 {
         int i, cnt, res, offset;
-        int length = PAGE_SIZE << st_bp->map_data.page_order;
+        int length = PAGE_SIZE << st_bp->reserved_page_order;
 
         for (i = 0, offset = st_bp->buffer_bytes;
              i < st_bp->frp_segs && offset >= length; i++)
@@ -3822,7 +3826,7 @@ static int append_to_buffer(const char __user *ubp, struct st_buffer * st_bp, in
 static int from_buffer(struct st_buffer * st_bp, char __user *ubp, int do_count)
 {
         int i, cnt, res, offset;
-        int length = PAGE_SIZE << st_bp->map_data.page_order;
+        int length = PAGE_SIZE << st_bp->reserved_page_order;
 
         for (i = 0, offset = st_bp->read_pointer;
              i < st_bp->frp_segs && offset >= length; i++)
@@ -3855,7 +3859,7 @@ static void move_buffer_data(struct st_buffer * st_bp, int offset)
 {
         int src_seg, dst_seg, src_offset = 0, dst_offset;
         int count, total;
-        int length = PAGE_SIZE << st_bp->map_data.page_order;
+        int length = PAGE_SIZE << st_bp->reserved_page_order;
 
         if (offset == 0)
                 return;
@@ -3980,8 +3984,7 @@ static int st_probe(struct device *dev)
                 return -ENODEV;
         }
 
-        i = min(queue_max_hw_segments(SDp->request_queue),
-                queue_max_phys_segments(SDp->request_queue));
+        i = queue_max_segments(SDp->request_queue);
         if (st_max_sg_segs < i)
                 i = st_max_sg_segs;
         buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
@@ -4577,7 +4580,6 @@ static int sgl_map_user_pages(struct st_buffer *STbp,
         }
 
         mdata->offset = uaddr & ~PAGE_MASK;
-        mdata->page_order = 0;
         STbp->mapped_pages = pages;
 
         return nr_pages;
diff --git a/drivers/scsi/st.h b/drivers/scsi/st.h
index 544dc6b1f548..f91a67c6d968 100644
--- a/drivers/scsi/st.h
+++ b/drivers/scsi/st.h
@@ -46,6 +46,7 @@ struct st_buffer {
         struct st_request *last_SRpnt;
         struct st_cmdstatus cmdstat;
         struct page **reserved_pages;
+        int reserved_page_order;
         struct page **mapped_pages;
         struct rq_map_data map_data;
         unsigned char *b_data;
diff --git a/drivers/scsi/stex.c b/drivers/scsi/stex.c
index 09fa8861fc58..9c73dbda3bbb 100644
--- a/drivers/scsi/stex.c
+++ b/drivers/scsi/stex.c
@@ -17,6 +17,7 @@
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/delay.h>
+#include <linux/slab.h>
 #include <linux/time.h>
 #include <linux/pci.h>
 #include <linux/blkdev.h>
@@ -36,11 +37,11 @@
 #include <scsi/scsi_eh.h>
 
 #define DRV_NAME "stex"
-#define ST_DRIVER_VERSION "4.6.0000.3"
+#define ST_DRIVER_VERSION "4.6.0000.4"
 #define ST_VER_MAJOR            4
 #define ST_VER_MINOR            6
 #define ST_OEM                  0
-#define ST_BUILD_VER            3
+#define ST_BUILD_VER            4
 
 enum {
         /* MU register offset */
@@ -64,24 +65,24 @@ enum {
         YH2I_REQ_HI                             = 0xc4,
 
         /* MU register value */
-        MU_INBOUND_DOORBELL_HANDSHAKE           = 1,
-        MU_INBOUND_DOORBELL_REQHEADCHANGED      = 2,
-        MU_INBOUND_DOORBELL_STATUSTAILCHANGED   = 4,
-        MU_INBOUND_DOORBELL_HMUSTOPPED          = 8,
-        MU_INBOUND_DOORBELL_RESET               = 16,
-
-        MU_OUTBOUND_DOORBELL_HANDSHAKE          = 1,
-        MU_OUTBOUND_DOORBELL_REQUESTTAILCHANGED = 2,
-        MU_OUTBOUND_DOORBELL_STATUSHEADCHANGED  = 4,
-        MU_OUTBOUND_DOORBELL_BUSCHANGE          = 8,
-        MU_OUTBOUND_DOORBELL_HASEVENT           = 16,
+        MU_INBOUND_DOORBELL_HANDSHAKE           = (1 << 0),
+        MU_INBOUND_DOORBELL_REQHEADCHANGED      = (1 << 1),
+        MU_INBOUND_DOORBELL_STATUSTAILCHANGED   = (1 << 2),
+        MU_INBOUND_DOORBELL_HMUSTOPPED          = (1 << 3),
+        MU_INBOUND_DOORBELL_RESET               = (1 << 4),
+
+        MU_OUTBOUND_DOORBELL_HANDSHAKE          = (1 << 0),
+        MU_OUTBOUND_DOORBELL_REQUESTTAILCHANGED = (1 << 1),
+        MU_OUTBOUND_DOORBELL_STATUSHEADCHANGED  = (1 << 2),
+        MU_OUTBOUND_DOORBELL_BUSCHANGE          = (1 << 3),
+        MU_OUTBOUND_DOORBELL_HASEVENT           = (1 << 4),
+        MU_OUTBOUND_DOORBELL_REQUEST_RESET      = (1 << 27),
 
         /* MU status code */
         MU_STATE_STARTING                       = 1,
-        MU_STATE_FMU_READY_FOR_HANDSHAKE        = 2,
-        MU_STATE_SEND_HANDSHAKE_FRAME           = 3,
-        MU_STATE_STARTED                        = 4,
-        MU_STATE_RESETTING                      = 5,
+        MU_STATE_STARTED                        = 2,
+        MU_STATE_RESETTING                      = 3,
+        MU_STATE_FAILED                         = 4,
 
         MU_MAX_DELAY                            = 120,
         MU_HANDSHAKE_SIGNATURE                  = 0x55aaaa55,
@@ -111,6 +112,8 @@ enum {
 
         SS_H2I_INT_RESET                        = 0x100,
 
+        SS_I2H_REQUEST_RESET                    = 0x2000,
+
         SS_MU_OPERATIONAL                       = 0x80000000,
 
         STEX_CDB_LENGTH                         = 16,
@@ -160,6 +163,7 @@ enum {
         INQUIRY_EVPD                            = 0x01,
 
         ST_ADDITIONAL_MEM                       = 0x200000,
+        ST_ADDITIONAL_MEM_MIN                   = 0x80000,
 };
 
 struct st_sgitem {
@@ -311,6 +315,10 @@ struct st_hba {
         struct st_ccb *wait_ccb;
         __le32 *scratch;
 
+        char work_q_name[20];
+        struct workqueue_struct *work_q;
+        struct work_struct reset_work;
+        wait_queue_head_t reset_waitq;
         unsigned int mu_status;
         unsigned int cardtype;
         int msi_enabled;
@@ -577,6 +585,9 @@ stex_queuecommand(struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *))
         lun = cmd->device->lun;
         hba = (struct st_hba *) &host->hostdata[0];
 
+        if (unlikely(hba->mu_status == MU_STATE_RESETTING))
+                return SCSI_MLQUEUE_HOST_BUSY;
+
         switch (cmd->cmnd[0]) {
         case MODE_SENSE_10:
         {
@@ -613,6 +624,11 @@ stex_queuecommand(struct scsi_cmnd *cmd, void (* done)(struct scsi_cmnd *))
                 }
                 break;
         case INQUIRY:
+                if (lun >= host->max_lun) {
+                        cmd->result = DID_NO_CONNECT << 16;
+                        done(cmd);
+                        return 0;
+                }
                 if (id != host->max_id - 1)
                         break;
                 if (!lun && !cmd->device->channel &&
@@ -841,7 +857,6 @@ static irqreturn_t stex_intr(int irq, void *__hba)
         void __iomem *base = hba->mmio_base;
         u32 data;
         unsigned long flags;
-        int handled = 0;
 
         spin_lock_irqsave(hba->host->host_lock, flags);
 
@@ -852,12 +867,16 @@ static irqreturn_t stex_intr(int irq, void *__hba)
                 writel(data, base + ODBL);
                 readl(base + ODBL); /* flush */
                 stex_mu_intr(hba, data);
-                handled = 1;
+                spin_unlock_irqrestore(hba->host->host_lock, flags);
+                if (unlikely(data & MU_OUTBOUND_DOORBELL_REQUEST_RESET &&
+                        hba->cardtype == st_shasta))
+                        queue_work(hba->work_q, &hba->reset_work);
+                return IRQ_HANDLED;
         }
 
         spin_unlock_irqrestore(hba->host->host_lock, flags);
 
-        return IRQ_RETVAL(handled);
+        return IRQ_NONE;
 }
 
 static void stex_ss_mu_intr(struct st_hba *hba)
@@ -939,7 +958,6 @@ static irqreturn_t stex_ss_intr(int irq, void *__hba)
         void __iomem *base = hba->mmio_base;
         u32 data;
         unsigned long flags;
-        int handled = 0;
 
         spin_lock_irqsave(hba->host->host_lock, flags);
 
@@ -948,12 +966,15 @@ static irqreturn_t stex_ss_intr(int irq, void *__hba)
                 /* clear the interrupt */
                 writel(data, base + YI2H_INT_C);
                 stex_ss_mu_intr(hba);
-                handled = 1;
+                spin_unlock_irqrestore(hba->host->host_lock, flags);
+                if (unlikely(data & SS_I2H_REQUEST_RESET))
+                        queue_work(hba->work_q, &hba->reset_work);
+                return IRQ_HANDLED;
         }
 
         spin_unlock_irqrestore(hba->host->host_lock, flags);
 
-        return IRQ_RETVAL(handled);
+        return IRQ_NONE;
 }
 
 static int stex_common_handshake(struct st_hba *hba)
@@ -1001,7 +1022,7 @@ static int stex_common_handshake(struct st_hba *hba)
         h->partner_type = HMU_PARTNER_TYPE;
         if (hba->extra_offset) {
                 h->extra_offset = cpu_to_le32(hba->extra_offset);
-                h->extra_size = cpu_to_le32(ST_ADDITIONAL_MEM);
+                h->extra_size = cpu_to_le32(hba->dma_size - hba->extra_offset);
         } else
                 h->extra_offset = h->extra_size = 0;
 
@@ -1046,7 +1067,7 @@ static int stex_ss_handshake(struct st_hba *hba)
         struct st_msg_header *msg_h;
         struct handshake_frame *h;
         __le32 *scratch;
-        u32 data;
+        u32 data, scratch_size;
         unsigned long before;
         int ret = 0;
 
@@ -1074,13 +1095,16 @@ static int stex_ss_handshake(struct st_hba *hba)
         stex_gettime(&h->hosttime);
         h->partner_type = HMU_PARTNER_TYPE;
         h->extra_offset = h->extra_size = 0;
-        h->scratch_size = cpu_to_le32((hba->sts_count+1)*sizeof(u32));
+        scratch_size = (hba->sts_count+1)*sizeof(u32);
+        h->scratch_size = cpu_to_le32(scratch_size);
 
         data = readl(base + YINT_EN);
         data &= ~4;
         writel(data, base + YINT_EN);
         writel((hba->dma_handle >> 16) >> 16, base + YH2I_REQ_HI);
+        readl(base + YH2I_REQ_HI);
         writel(hba->dma_handle, base + YH2I_REQ);
+        readl(base + YH2I_REQ); /* flush */
 
         scratch = hba->scratch;
         before = jiffies;
@@ -1096,7 +1120,7 @@ static int stex_ss_handshake(struct st_hba *hba)
                 msleep(1);
         }
 
-        *scratch = 0;
+        memset(scratch, 0, scratch_size);
         msg_h->flag = 0;
         return ret;
 }
@@ -1105,19 +1129,24 @@ static int stex_handshake(struct st_hba *hba)
 {
         int err;
         unsigned long flags;
+        unsigned int mu_status;
 
         err = (hba->cardtype == st_yel) ?
                 stex_ss_handshake(hba) : stex_common_handshake(hba);
+        spin_lock_irqsave(hba->host->host_lock, flags);
+        mu_status = hba->mu_status;
         if (err == 0) {
-                spin_lock_irqsave(hba->host->host_lock, flags);
                 hba->req_head = 0;
                 hba->req_tail = 0;
                 hba->status_head = 0;
                 hba->status_tail = 0;
                 hba->out_req_cnt = 0;
                 hba->mu_status = MU_STATE_STARTED;
-                spin_unlock_irqrestore(hba->host->host_lock, flags);
-        }
+        } else
+                hba->mu_status = MU_STATE_FAILED;
+        if (mu_status == MU_STATE_RESETTING)
+                wake_up_all(&hba->reset_waitq);
+        spin_unlock_irqrestore(hba->host->host_lock, flags);
         return err;
 }
 
@@ -1137,17 +1166,11 @@ static int stex_abort(struct scsi_cmnd *cmd)
 
         base = hba->mmio_base;
         spin_lock_irqsave(host->host_lock, flags);
-        if (tag < host->can_queue && hba->ccb[tag].cmd == cmd)
+        if (tag < host->can_queue &&
+                hba->ccb[tag].req && hba->ccb[tag].cmd == cmd)
                 hba->wait_ccb = &hba->ccb[tag];
-        else {
-                for (tag = 0; tag < host->can_queue; tag++)
-                        if (hba->ccb[tag].cmd == cmd) {
-                                hba->wait_ccb = &hba->ccb[tag];
-                                break;
-                        }
-                if (tag >= host->can_queue)
-                        goto out;
-        }
+        else
+                goto out;
 
         if (hba->cardtype == st_yel) {
                 data = readl(base + YI2H_INT);
@@ -1221,6 +1244,37 @@ static void stex_hard_reset(struct st_hba *hba)
                         hba->pdev->saved_config_space[i]);
 }
 
+static int stex_yos_reset(struct st_hba *hba)
+{
+        void __iomem *base;
+        unsigned long flags, before;
+        int ret = 0;
+
+        base = hba->mmio_base;
+        writel(MU_INBOUND_DOORBELL_RESET, base + IDBL);
+        readl(base + IDBL); /* flush */
+        before = jiffies;
+        while (hba->out_req_cnt > 0) {
+                if (time_after(jiffies, before + ST_INTERNAL_TIMEOUT * HZ)) {
+                        printk(KERN_WARNING DRV_NAME
+                                "(%s): reset timeout\n", pci_name(hba->pdev));
+                        ret = -1;
+                        break;
+                }
+                msleep(1);
+        }
+
+        spin_lock_irqsave(hba->host->host_lock, flags);
+        if (ret == -1)
+                hba->mu_status = MU_STATE_FAILED;
+        else
+                hba->mu_status = MU_STATE_STARTED;
+        wake_up_all(&hba->reset_waitq);
+        spin_unlock_irqrestore(hba->host->host_lock, flags);
+
+        return ret;
+}
+
 static void stex_ss_reset(struct st_hba *hba)
 {
         writel(SS_H2I_INT_RESET, hba->mmio_base + YH2I_INT);
@@ -1228,66 +1282,86 @@ static void stex_ss_reset(struct st_hba *hba)
         ssleep(5);
 }
 
-static int stex_reset(struct scsi_cmnd *cmd)
+static int stex_do_reset(struct st_hba *hba)
 {
-        struct st_hba *hba;
-        void __iomem *base;
-        unsigned long flags, before;
+        struct st_ccb *ccb;
+        unsigned long flags;
+        unsigned int mu_status = MU_STATE_RESETTING;
+        u16 tag;
 
-        hba = (struct st_hba *) &cmd->device->host->hostdata[0];
+        spin_lock_irqsave(hba->host->host_lock, flags);
+        if (hba->mu_status == MU_STATE_STARTING) {
+                spin_unlock_irqrestore(hba->host->host_lock, flags);
+                printk(KERN_INFO DRV_NAME "(%s): request reset during init\n",
+                        pci_name(hba->pdev));
+                return 0;
+        }
+        while (hba->mu_status == MU_STATE_RESETTING) {
+                spin_unlock_irqrestore(hba->host->host_lock, flags);
+                wait_event_timeout(hba->reset_waitq,
+                                   hba->mu_status != MU_STATE_RESETTING,
+                                   MU_MAX_DELAY * HZ);
+                spin_lock_irqsave(hba->host->host_lock, flags);
+                mu_status = hba->mu_status;
+        }
 
-        printk(KERN_INFO DRV_NAME
-                "(%s): resetting host\n", pci_name(hba->pdev));
-        scsi_print_command(cmd);
+        if (mu_status != MU_STATE_RESETTING) {
+                spin_unlock_irqrestore(hba->host->host_lock, flags);
+                return (mu_status == MU_STATE_STARTED) ? 0 : -1;
+        }
 
         hba->mu_status = MU_STATE_RESETTING;
+        spin_unlock_irqrestore(hba->host->host_lock, flags);
+
+        if (hba->cardtype == st_yosemite)
+                return stex_yos_reset(hba);
 
         if (hba->cardtype == st_shasta)
                 stex_hard_reset(hba);
         else if (hba->cardtype == st_yel)
                 stex_ss_reset(hba);
 
-        if (hba->cardtype != st_yosemite) {
-                if (stex_handshake(hba)) {
-                        printk(KERN_WARNING DRV_NAME
-                                "(%s): resetting: handshake failed\n",
-                                pci_name(hba->pdev));
-                        return FAILED;
+        spin_lock_irqsave(hba->host->host_lock, flags);
+        for (tag = 0; tag < hba->host->can_queue; tag++) {
+                ccb = &hba->ccb[tag];
+                if (ccb->req == NULL)
+                        continue;
+                ccb->req = NULL;
+                if (ccb->cmd) {
+                        scsi_dma_unmap(ccb->cmd);
+                        ccb->cmd->result = DID_RESET << 16;
+                        ccb->cmd->scsi_done(ccb->cmd);
+                        ccb->cmd = NULL;
                 }
-                return SUCCESS;
         }
+        spin_unlock_irqrestore(hba->host->host_lock, flags);
 
-        /* st_yosemite */
-        writel(MU_INBOUND_DOORBELL_RESET, hba->mmio_base + IDBL);
-        readl(hba->mmio_base + IDBL); /* flush */
-        before = jiffies;
-        while (hba->out_req_cnt > 0) {
-                if (time_after(jiffies, before + ST_INTERNAL_TIMEOUT * HZ)) {
-                        printk(KERN_WARNING DRV_NAME
-                                "(%s): reset timeout\n", pci_name(hba->pdev));
-                        return FAILED;
-                }
-                msleep(1);
-        }
+        if (stex_handshake(hba) == 0)
+                return 0;
 
-        base = hba->mmio_base;
-        writel(0, base + IMR0);
-        readl(base + IMR0);
-        writel(0, base + OMR0);
-        readl(base + OMR0);
-        writel(0, base + IMR1);
-        readl(base + IMR1);
-        writel(0, base + OMR1);
-        readl(base + OMR1); /* flush */
-        spin_lock_irqsave(hba->host->host_lock, flags);
-        hba->req_head = 0;
-        hba->req_tail = 0;
-        hba->status_head = 0;
-        hba->status_tail = 0;
-        hba->out_req_cnt = 0;
-        hba->mu_status = MU_STATE_STARTED;
-        spin_unlock_irqrestore(hba->host->host_lock, flags);
-        return SUCCESS;
+        printk(KERN_WARNING DRV_NAME "(%s): resetting: handshake failed\n",
+                pci_name(hba->pdev));
+        return -1;
+}
+
+static int stex_reset(struct scsi_cmnd *cmd)
+{
+        struct st_hba *hba;
+
+        hba = (struct st_hba *) &cmd->device->host->hostdata[0];
+
+        printk(KERN_INFO DRV_NAME
+                "(%s): resetting host\n", pci_name(hba->pdev));
+        scsi_print_command(cmd);
+
+        return stex_do_reset(hba) ? FAILED : SUCCESS;
+}
+
+static void stex_reset_work(struct work_struct *work)
+{
+        struct st_hba *hba = container_of(work, struct st_hba, reset_work);
+
+        stex_do_reset(hba);
 }
 
 static int stex_biosparam(struct scsi_device *sdev,
@@ -1420,8 +1494,8 @@ static int stex_set_dma_mask(struct pci_dev * pdev)
 {
         int ret;
 
-        if (!pci_set_dma_mask(pdev,  DMA_BIT_MASK(64))
-                && !pci_set_consistent_dma_mask(pdev,  DMA_BIT_MASK(64)))
+        if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
+                && !pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
                 return 0;
         ret = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
         if (!ret)
@@ -1528,10 +1602,24 @@ stex_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         hba->dma_mem = dma_alloc_coherent(&pdev->dev,
                 hba->dma_size, &hba->dma_handle, GFP_KERNEL);
         if (!hba->dma_mem) {
-                err = -ENOMEM;
-                printk(KERN_ERR DRV_NAME "(%s): dma mem alloc failed\n",
-                        pci_name(pdev));
-                goto out_iounmap;
+                /* Retry minimum coherent mapping for st_seq and st_vsc */
+                if (hba->cardtype == st_seq ||
+                    (hba->cardtype == st_vsc && (pdev->subsystem_device & 1))) {
+                        printk(KERN_WARNING DRV_NAME
+                                "(%s): allocating min buffer for controller\n",
+                                pci_name(pdev));
+                        hba->dma_size = hba->extra_offset
+                                + ST_ADDITIONAL_MEM_MIN;
+                        hba->dma_mem = dma_alloc_coherent(&pdev->dev,
+                                hba->dma_size, &hba->dma_handle, GFP_KERNEL);
+                }
+
+                if (!hba->dma_mem) {
+                        err = -ENOMEM;
+                        printk(KERN_ERR DRV_NAME "(%s): dma mem alloc failed\n",
+                                pci_name(pdev));
+                        goto out_iounmap;
+                }
         }
 
         hba->ccb = kcalloc(ci->rq_count, sizeof(struct st_ccb), GFP_KERNEL);
@@ -1568,12 +1656,24 @@ stex_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 
         hba->host = host;
         hba->pdev = pdev;
+        init_waitqueue_head(&hba->reset_waitq);
+
+        snprintf(hba->work_q_name, sizeof(hba->work_q_name),
+                 "stex_wq_%d", host->host_no);
+        hba->work_q = create_singlethread_workqueue(hba->work_q_name);
+        if (!hba->work_q) {
+                printk(KERN_ERR DRV_NAME "(%s): create workqueue failed\n",
+                        pci_name(pdev));
+                err = -ENOMEM;
+                goto out_ccb_free;
+        }
+        INIT_WORK(&hba->reset_work, stex_reset_work);
 
         err = stex_request_irq(hba);
         if (err) {
                 printk(KERN_ERR DRV_NAME "(%s): request irq failed\n",
                         pci_name(pdev));
-                goto out_ccb_free;
+                goto out_free_wq;
         }
 
         err = stex_handshake(hba);
@@ -1602,6 +1702,8 @@ stex_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 
 out_free_irq:
         stex_free_irq(hba);
+out_free_wq:
+        destroy_workqueue(hba->work_q);
 out_ccb_free:
         kfree(hba->ccb);
 out_pci_free:
@@ -1669,6 +1771,8 @@ static void stex_hba_free(struct st_hba *hba)
 {
         stex_free_irq(hba);
 
+        destroy_workqueue(hba->work_q);
+
         iounmap(hba->mmio_base);
 
         pci_release_regions(hba->pdev);
diff --git a/drivers/scsi/sun3_NCR5380.c b/drivers/scsi/sun3_NCR5380.c
index 75da6e58ce55..b5838d547c68 100644
--- a/drivers/scsi/sun3_NCR5380.c
+++ b/drivers/scsi/sun3_NCR5380.c
@@ -645,6 +645,7 @@ __inline__ void NCR5380_print_phase(struct Scsi_Host *instance) { };
  * interrupt or bottom half.
  */
 
+#include <linux/gfp.h>
 #include <linux/workqueue.h>
 #include <linux/interrupt.h>
 
diff --git a/drivers/scsi/sun3x_esp.c b/drivers/scsi/sun3x_esp.c
index 34a99620e5bd..0621037f0271 100644
--- a/drivers/scsi/sun3x_esp.c
+++ b/drivers/scsi/sun3x_esp.c
@@ -4,6 +4,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/gfp.h>
 #include <linux/types.h>
 #include <linux/delay.h>
 #include <linux/module.h>
diff --git a/drivers/scsi/sun_esp.c b/drivers/scsi/sun_esp.c
index 3d73aad4bc82..fc23d273fb1a 100644
--- a/drivers/scsi/sun_esp.c
+++ b/drivers/scsi/sun_esp.c
@@ -12,6 +12,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
+#include <linux/gfp.h>
 
 #include <asm/irq.h>
 #include <asm/io.h>
diff --git a/drivers/scsi/sym53c8xx_2/sym_glue.c b/drivers/scsi/sym53c8xx_2/sym_glue.c
index 45374d66d26a..8b955b534a36 100644
--- a/drivers/scsi/sym53c8xx_2/sym_glue.c
+++ b/drivers/scsi/sym53c8xx_2/sym_glue.c
@@ -984,7 +984,7 @@ static void sym_exec_user_command (struct sym_hcb *np, struct sym_usrcmd *uc)
         }
 }
 
-static int skip_spaces(char *ptr, int len)
+static int sym_skip_spaces(char *ptr, int len)
 {
         int cnt, c;
 
@@ -1012,7 +1012,7 @@ static int is_keyword(char *ptr, int len, char *verb)
 }
 
 #define SKIP_SPACES(ptr, len)                                           \
-        if ((arg_len = skip_spaces(ptr, len)) < 1)                      \
+        if ((arg_len = sym_skip_spaces(ptr, len)) < 1)                  \
                 return -EINVAL;                                         \
         ptr += arg_len; len -= arg_len;
 
@@ -1864,7 +1864,7 @@ static pci_ers_result_t sym2_io_slot_dump(struct pci_dev *pdev)
  *
  * This routine is similar to sym_set_workarounds(), except
  * that, at this point, we already know that the device was
- * succesfully intialized at least once before, and so most
+ * successfully intialized at least once before, and so most
  * of the steps taken there are un-needed here.
  */
 static void sym2_reset_workarounds(struct pci_dev *pdev)
diff --git a/drivers/scsi/sym53c8xx_2/sym_hipd.c b/drivers/scsi/sym53c8xx_2/sym_hipd.c
index 297deb817a5d..a7bc8b7b09ac 100644
--- a/drivers/scsi/sym53c8xx_2/sym_hipd.c
+++ b/drivers/scsi/sym53c8xx_2/sym_hipd.c
@@ -2692,7 +2692,7 @@ static void sym_int_ma (struct sym_hcb *np)
          *  we force a SIR_NEGO_PROTO interrupt (it is a hack that avoids 
          *  bloat for such a should_not_happen situation).
          *  In all other situation, we reset the BUS.
-         *  Are these assumptions reasonnable ? (Wait and see ...)
+         *  Are these assumptions reasonable ? (Wait and see ...)
          */
 unexpected_phase:
         dsp -= 8;
diff --git a/drivers/scsi/sym53c8xx_2/sym_hipd.h b/drivers/scsi/sym53c8xx_2/sym_hipd.h
index 053e63c86822..5a80cbac3f92 100644
--- a/drivers/scsi/sym53c8xx_2/sym_hipd.h
+++ b/drivers/scsi/sym53c8xx_2/sym_hipd.h
@@ -54,7 +54,7 @@
  *
  *    SYM_OPT_LIMIT_COMMAND_REORDERING
  *        When this option is set, the driver tries to limit tagged 
- *        command reordering to some reasonnable value.
+ *        command reordering to some reasonable value.
  *        (set for Linux)
  */
 #if 0
diff --git a/drivers/scsi/tmscsim.c b/drivers/scsi/tmscsim.c
index 9a4273445c0d..27866b0adfeb 100644
--- a/drivers/scsi/tmscsim.c
+++ b/drivers/scsi/tmscsim.c
@@ -233,6 +233,7 @@
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
+#include <linux/slab.h>
 #include <asm/io.h>
 
 #include <scsi/scsi.h>
diff --git a/drivers/scsi/u14-34f.c b/drivers/scsi/u14-34f.c
index 54023d41fd15..5d9fdeeb2315 100644
--- a/drivers/scsi/u14-34f.c
+++ b/drivers/scsi/u14-34f.c
@@ -420,6 +420,7 @@
 #include <linux/init.h>
 #include <linux/ctype.h>
 #include <linux/spinlock.h>
+#include <linux/slab.h>
 #include <asm/dma.h>
 #include <asm/irq.h>
 
@@ -1070,7 +1071,7 @@ static int option_setup(char *str) {
    char *cur = str;
    int i = 1;
 
-   while (cur && isdigit(*cur) && i <= MAX_INT_PARAM) {
+   while (cur && isdigit(*cur) && i < MAX_INT_PARAM) {
       ints[i++] = simple_strtoul(cur, NULL, 0);
 
       if ((cur = strchr(cur, ',')) != NULL) cur++;
diff --git a/drivers/scsi/vmw_pvscsi.c b/drivers/scsi/vmw_pvscsi.c
new file mode 100644
index 000000000000..26894459c37f
--- /dev/null
+++ b/drivers/scsi/vmw_pvscsi.c
@@ -0,0 +1,1409 @@
+/*
+ * Linux driver for VMware's para-virtualized SCSI HBA.
+ *
+ * Copyright (C) 2008-2009, VMware, Inc. All Rights Reserved.
+ *
+ * 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; version 2 of the License and no 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, GOOD TITLE or
+ * NON INFRINGEMENT.  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.
+ *
+ * Maintained by: Alok N Kataria <akataria@vmware.com>
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/workqueue.h>
+#include <linux/pci.h>
+
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_device.h>
+
+#include "vmw_pvscsi.h"
+
+#define PVSCSI_LINUX_DRIVER_DESC "VMware PVSCSI driver"
+
+MODULE_DESCRIPTION(PVSCSI_LINUX_DRIVER_DESC);
+MODULE_AUTHOR("VMware, Inc.");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(PVSCSI_DRIVER_VERSION_STRING);
+
+#define PVSCSI_DEFAULT_NUM_PAGES_PER_RING       8
+#define PVSCSI_DEFAULT_NUM_PAGES_MSG_RING       1
+#define PVSCSI_DEFAULT_QUEUE_DEPTH              64
+#define SGL_SIZE                                PAGE_SIZE
+
+struct pvscsi_sg_list {
+        struct PVSCSISGElement sge[PVSCSI_MAX_NUM_SG_ENTRIES_PER_SEGMENT];
+};
+
+struct pvscsi_ctx {
+        /*
+         * The index of the context in cmd_map serves as the context ID for a
+         * 1-to-1 mapping completions back to requests.
+         */
+        struct scsi_cmnd        *cmd;
+        struct pvscsi_sg_list   *sgl;
+        struct list_head        list;
+        dma_addr_t              dataPA;
+        dma_addr_t              sensePA;
+        dma_addr_t              sglPA;
+};
+
+struct pvscsi_adapter {
+        char                            *mmioBase;
+        unsigned int                    irq;
+        u8                              rev;
+        bool                            use_msi;
+        bool                            use_msix;
+        bool                            use_msg;
+
+        spinlock_t                      hw_lock;
+
+        struct workqueue_struct         *workqueue;
+        struct work_struct              work;
+
+        struct PVSCSIRingReqDesc        *req_ring;
+        unsigned                        req_pages;
+        unsigned                        req_depth;
+        dma_addr_t                      reqRingPA;
+
+        struct PVSCSIRingCmpDesc        *cmp_ring;
+        unsigned                        cmp_pages;
+        dma_addr_t                      cmpRingPA;
+
+        struct PVSCSIRingMsgDesc        *msg_ring;
+        unsigned                        msg_pages;
+        dma_addr_t                      msgRingPA;
+
+        struct PVSCSIRingsState         *rings_state;
+        dma_addr_t                      ringStatePA;
+
+        struct pci_dev                  *dev;
+        struct Scsi_Host                *host;
+
+        struct list_head                cmd_pool;
+        struct pvscsi_ctx               *cmd_map;
+};
+
+
+/* Command line parameters */
+static int pvscsi_ring_pages     = PVSCSI_DEFAULT_NUM_PAGES_PER_RING;
+static int pvscsi_msg_ring_pages = PVSCSI_DEFAULT_NUM_PAGES_MSG_RING;
+static int pvscsi_cmd_per_lun    = PVSCSI_DEFAULT_QUEUE_DEPTH;
+static bool pvscsi_disable_msi;
+static bool pvscsi_disable_msix;
+static bool pvscsi_use_msg       = true;
+
+#define PVSCSI_RW (S_IRUSR | S_IWUSR)
+
+module_param_named(ring_pages, pvscsi_ring_pages, int, PVSCSI_RW);
+MODULE_PARM_DESC(ring_pages, "Number of pages per req/cmp ring - (default="
+                 __stringify(PVSCSI_DEFAULT_NUM_PAGES_PER_RING) ")");
+
+module_param_named(msg_ring_pages, pvscsi_msg_ring_pages, int, PVSCSI_RW);
+MODULE_PARM_DESC(msg_ring_pages, "Number of pages for the msg ring - (default="
+                 __stringify(PVSCSI_DEFAULT_NUM_PAGES_MSG_RING) ")");
+
+module_param_named(cmd_per_lun, pvscsi_cmd_per_lun, int, PVSCSI_RW);
+MODULE_PARM_DESC(cmd_per_lun, "Maximum commands per lun - (default="
+                 __stringify(PVSCSI_MAX_REQ_QUEUE_DEPTH) ")");
+
+module_param_named(disable_msi, pvscsi_disable_msi, bool, PVSCSI_RW);
+MODULE_PARM_DESC(disable_msi, "Disable MSI use in driver - (default=0)");
+
+module_param_named(disable_msix, pvscsi_disable_msix, bool, PVSCSI_RW);
+MODULE_PARM_DESC(disable_msix, "Disable MSI-X use in driver - (default=0)");
+
+module_param_named(use_msg, pvscsi_use_msg, bool, PVSCSI_RW);
+MODULE_PARM_DESC(use_msg, "Use msg ring when available - (default=1)");
+
+static const struct pci_device_id pvscsi_pci_tbl[] = {
+        { PCI_VDEVICE(VMWARE, PCI_DEVICE_ID_VMWARE_PVSCSI) },
+        { 0 }
+};
+
+MODULE_DEVICE_TABLE(pci, pvscsi_pci_tbl);
+
+static struct device *
+pvscsi_dev(const struct pvscsi_adapter *adapter)
+{
+        return &(adapter->dev->dev);
+}
+
+static struct pvscsi_ctx *
+pvscsi_find_context(const struct pvscsi_adapter *adapter, struct scsi_cmnd *cmd)
+{
+        struct pvscsi_ctx *ctx, *end;
+
+        end = &adapter->cmd_map[adapter->req_depth];
+        for (ctx = adapter->cmd_map; ctx < end; ctx++)
+                if (ctx->cmd == cmd)
+                        return ctx;
+
+        return NULL;
+}
+
+static struct pvscsi_ctx *
+pvscsi_acquire_context(struct pvscsi_adapter *adapter, struct scsi_cmnd *cmd)
+{
+        struct pvscsi_ctx *ctx;
+
+        if (list_empty(&adapter->cmd_pool))
+                return NULL;
+
+        ctx = list_first_entry(&adapter->cmd_pool, struct pvscsi_ctx, list);
+        ctx->cmd = cmd;
+        list_del(&ctx->list);
+
+        return ctx;
+}
+
+static void pvscsi_release_context(struct pvscsi_adapter *adapter,
+                                   struct pvscsi_ctx *ctx)
+{
+        ctx->cmd = NULL;
+        list_add(&ctx->list, &adapter->cmd_pool);
+}
+
+/*
+ * Map a pvscsi_ctx struct to a context ID field value; we map to a simple
+ * non-zero integer. ctx always points to an entry in cmd_map array, hence
+ * the return value is always >=1.
+ */
+static u64 pvscsi_map_context(const struct pvscsi_adapter *adapter,
+                              const struct pvscsi_ctx *ctx)
+{
+        return ctx - adapter->cmd_map + 1;
+}
+
+static struct pvscsi_ctx *
+pvscsi_get_context(const struct pvscsi_adapter *adapter, u64 context)
+{
+        return &adapter->cmd_map[context - 1];
+}
+
+static void pvscsi_reg_write(const struct pvscsi_adapter *adapter,
+                             u32 offset, u32 val)
+{
+        writel(val, adapter->mmioBase + offset);
+}
+
+static u32 pvscsi_reg_read(const struct pvscsi_adapter *adapter, u32 offset)
+{
+        return readl(adapter->mmioBase + offset);
+}
+
+static u32 pvscsi_read_intr_status(const struct pvscsi_adapter *adapter)
+{
+        return pvscsi_reg_read(adapter, PVSCSI_REG_OFFSET_INTR_STATUS);
+}
+
+static void pvscsi_write_intr_status(const struct pvscsi_adapter *adapter,
+                                     u32 val)
+{
+        pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_INTR_STATUS, val);
+}
+
+static void pvscsi_unmask_intr(const struct pvscsi_adapter *adapter)
+{
+        u32 intr_bits;
+
+        intr_bits = PVSCSI_INTR_CMPL_MASK;
+        if (adapter->use_msg)
+                intr_bits |= PVSCSI_INTR_MSG_MASK;
+
+        pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_INTR_MASK, intr_bits);
+}
+
+static void pvscsi_mask_intr(const struct pvscsi_adapter *adapter)
+{
+        pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_INTR_MASK, 0);
+}
+
+static void pvscsi_write_cmd_desc(const struct pvscsi_adapter *adapter,
+                                  u32 cmd, const void *desc, size_t len)
+{
+        const u32 *ptr = desc;
+        size_t i;
+
+        len /= sizeof(*ptr);
+        pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_COMMAND, cmd);
+        for (i = 0; i < len; i++)
+                pvscsi_reg_write(adapter,
+                                 PVSCSI_REG_OFFSET_COMMAND_DATA, ptr[i]);
+}
+
+static void pvscsi_abort_cmd(const struct pvscsi_adapter *adapter,
+                             const struct pvscsi_ctx *ctx)
+{
+        struct PVSCSICmdDescAbortCmd cmd = { 0 };
+
+        cmd.target = ctx->cmd->device->id;
+        cmd.context = pvscsi_map_context(adapter, ctx);
+
+        pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_ABORT_CMD, &cmd, sizeof(cmd));
+}
+
+static void pvscsi_kick_rw_io(const struct pvscsi_adapter *adapter)
+{
+        pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_KICK_RW_IO, 0);
+}
+
+static void pvscsi_process_request_ring(const struct pvscsi_adapter *adapter)
+{
+        pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_KICK_NON_RW_IO, 0);
+}
+
+static int scsi_is_rw(unsigned char op)
+{
+        return op == READ_6  || op == WRITE_6 ||
+               op == READ_10 || op == WRITE_10 ||
+               op == READ_12 || op == WRITE_12 ||
+               op == READ_16 || op == WRITE_16;
+}
+
+static void pvscsi_kick_io(const struct pvscsi_adapter *adapter,
+                           unsigned char op)
+{
+        if (scsi_is_rw(op))
+                pvscsi_kick_rw_io(adapter);
+        else
+                pvscsi_process_request_ring(adapter);
+}
+
+static void ll_adapter_reset(const struct pvscsi_adapter *adapter)
+{
+        dev_dbg(pvscsi_dev(adapter), "Adapter Reset on %p\n", adapter);
+
+        pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_ADAPTER_RESET, NULL, 0);
+}
+
+static void ll_bus_reset(const struct pvscsi_adapter *adapter)
+{
+        dev_dbg(pvscsi_dev(adapter), "Reseting bus on %p\n", adapter);
+
+        pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_RESET_BUS, NULL, 0);
+}
+
+static void ll_device_reset(const struct pvscsi_adapter *adapter, u32 target)
+{
+        struct PVSCSICmdDescResetDevice cmd = { 0 };
+
+        dev_dbg(pvscsi_dev(adapter), "Reseting device: target=%u\n", target);
+
+        cmd.target = target;
+
+        pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_RESET_DEVICE,
+                              &cmd, sizeof(cmd));
+}
+
+static void pvscsi_create_sg(struct pvscsi_ctx *ctx,
+                             struct scatterlist *sg, unsigned count)
+{
+        unsigned i;
+        struct PVSCSISGElement *sge;
+
+        BUG_ON(count > PVSCSI_MAX_NUM_SG_ENTRIES_PER_SEGMENT);
+
+        sge = &ctx->sgl->sge[0];
+        for (i = 0; i < count; i++, sg++) {
+                sge[i].addr   = sg_dma_address(sg);
+                sge[i].length = sg_dma_len(sg);
+                sge[i].flags  = 0;
+        }
+}
+
+/*
+ * Map all data buffers for a command into PCI space and
+ * setup the scatter/gather list if needed.
+ */
+static void pvscsi_map_buffers(struct pvscsi_adapter *adapter,
+                               struct pvscsi_ctx *ctx, struct scsi_cmnd *cmd,
+                               struct PVSCSIRingReqDesc *e)
+{
+        unsigned count;
+        unsigned bufflen = scsi_bufflen(cmd);
+        struct scatterlist *sg;
+
+        e->dataLen = bufflen;
+        e->dataAddr = 0;
+        if (bufflen == 0)
+                return;
+
+        sg = scsi_sglist(cmd);
+        count = scsi_sg_count(cmd);
+        if (count != 0) {
+                int segs = scsi_dma_map(cmd);
+                if (segs > 1) {
+                        pvscsi_create_sg(ctx, sg, segs);
+
+                        e->flags |= PVSCSI_FLAG_CMD_WITH_SG_LIST;
+                        ctx->sglPA = pci_map_single(adapter->dev, ctx->sgl,
+                                                    SGL_SIZE, PCI_DMA_TODEVICE);
+                        e->dataAddr = ctx->sglPA;
+                } else
+                        e->dataAddr = sg_dma_address(sg);
+        } else {
+                /*
+                 * In case there is no S/G list, scsi_sglist points
+                 * directly to the buffer.
+                 */
+                ctx->dataPA = pci_map_single(adapter->dev, sg, bufflen,
+                                             cmd->sc_data_direction);
+                e->dataAddr = ctx->dataPA;
+        }
+}
+
+static void pvscsi_unmap_buffers(const struct pvscsi_adapter *adapter,
+                                 struct pvscsi_ctx *ctx)
+{
+        struct scsi_cmnd *cmd;
+        unsigned bufflen;
+
+        cmd = ctx->cmd;
+        bufflen = scsi_bufflen(cmd);
+
+        if (bufflen != 0) {
+                unsigned count = scsi_sg_count(cmd);
+
+                if (count != 0) {
+                        scsi_dma_unmap(cmd);
+                        if (ctx->sglPA) {
+                                pci_unmap_single(adapter->dev, ctx->sglPA,
+                                                 SGL_SIZE, PCI_DMA_TODEVICE);
+                                ctx->sglPA = 0;
+                        }
+                } else
+                        pci_unmap_single(adapter->dev, ctx->dataPA, bufflen,
+                                         cmd->sc_data_direction);
+        }
+        if (cmd->sense_buffer)
+                pci_unmap_single(adapter->dev, ctx->sensePA,
+                                 SCSI_SENSE_BUFFERSIZE, PCI_DMA_FROMDEVICE);
+}
+
+static int __devinit pvscsi_allocate_rings(struct pvscsi_adapter *adapter)
+{
+        adapter->rings_state = pci_alloc_consistent(adapter->dev, PAGE_SIZE,
+                                                    &adapter->ringStatePA);
+        if (!adapter->rings_state)
+                return -ENOMEM;
+
+        adapter->req_pages = min(PVSCSI_MAX_NUM_PAGES_REQ_RING,
+                                 pvscsi_ring_pages);
+        adapter->req_depth = adapter->req_pages
+                                        * PVSCSI_MAX_NUM_REQ_ENTRIES_PER_PAGE;
+        adapter->req_ring = pci_alloc_consistent(adapter->dev,
+                                                 adapter->req_pages * PAGE_SIZE,
+                                                 &adapter->reqRingPA);
+        if (!adapter->req_ring)
+                return -ENOMEM;
+
+        adapter->cmp_pages = min(PVSCSI_MAX_NUM_PAGES_CMP_RING,
+                                 pvscsi_ring_pages);
+        adapter->cmp_ring = pci_alloc_consistent(adapter->dev,
+                                                 adapter->cmp_pages * PAGE_SIZE,
+                                                 &adapter->cmpRingPA);
+        if (!adapter->cmp_ring)
+                return -ENOMEM;
+
+        BUG_ON(!IS_ALIGNED(adapter->ringStatePA, PAGE_SIZE));
+        BUG_ON(!IS_ALIGNED(adapter->reqRingPA, PAGE_SIZE));
+        BUG_ON(!IS_ALIGNED(adapter->cmpRingPA, PAGE_SIZE));
+
+        if (!adapter->use_msg)
+                return 0;
+
+        adapter->msg_pages = min(PVSCSI_MAX_NUM_PAGES_MSG_RING,
+                                 pvscsi_msg_ring_pages);
+        adapter->msg_ring = pci_alloc_consistent(adapter->dev,
+                                                 adapter->msg_pages * PAGE_SIZE,
+                                                 &adapter->msgRingPA);
+        if (!adapter->msg_ring)
+                return -ENOMEM;
+        BUG_ON(!IS_ALIGNED(adapter->msgRingPA, PAGE_SIZE));
+
+        return 0;
+}
+
+static void pvscsi_setup_all_rings(const struct pvscsi_adapter *adapter)
+{
+        struct PVSCSICmdDescSetupRings cmd = { 0 };
+        dma_addr_t base;
+        unsigned i;
+
+        cmd.ringsStatePPN   = adapter->ringStatePA >> PAGE_SHIFT;
+        cmd.reqRingNumPages = adapter->req_pages;
+        cmd.cmpRingNumPages = adapter->cmp_pages;
+
+        base = adapter->reqRingPA;
+        for (i = 0; i < adapter->req_pages; i++) {
+                cmd.reqRingPPNs[i] = base >> PAGE_SHIFT;
+                base += PAGE_SIZE;
+        }
+
+        base = adapter->cmpRingPA;
+        for (i = 0; i < adapter->cmp_pages; i++) {
+                cmd.cmpRingPPNs[i] = base >> PAGE_SHIFT;
+                base += PAGE_SIZE;
+        }
+
+        memset(adapter->rings_state, 0, PAGE_SIZE);
+        memset(adapter->req_ring, 0, adapter->req_pages * PAGE_SIZE);
+        memset(adapter->cmp_ring, 0, adapter->cmp_pages * PAGE_SIZE);
+
+        pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_SETUP_RINGS,
+                              &cmd, sizeof(cmd));
+
+        if (adapter->use_msg) {
+                struct PVSCSICmdDescSetupMsgRing cmd_msg = { 0 };
+
+                cmd_msg.numPages = adapter->msg_pages;
+
+                base = adapter->msgRingPA;
+                for (i = 0; i < adapter->msg_pages; i++) {
+                        cmd_msg.ringPPNs[i] = base >> PAGE_SHIFT;
+                        base += PAGE_SIZE;
+                }
+                memset(adapter->msg_ring, 0, adapter->msg_pages * PAGE_SIZE);
+
+                pvscsi_write_cmd_desc(adapter, PVSCSI_CMD_SETUP_MSG_RING,
+                                      &cmd_msg, sizeof(cmd_msg));
+        }
+}
+
+/*
+ * Pull a completion descriptor off and pass the completion back
+ * to the SCSI mid layer.
+ */
+static void pvscsi_complete_request(struct pvscsi_adapter *adapter,
+                                    const struct PVSCSIRingCmpDesc *e)
+{
+        struct pvscsi_ctx *ctx;
+        struct scsi_cmnd *cmd;
+        u32 btstat = e->hostStatus;
+        u32 sdstat = e->scsiStatus;
+
+        ctx = pvscsi_get_context(adapter, e->context);
+        cmd = ctx->cmd;
+        pvscsi_unmap_buffers(adapter, ctx);
+        pvscsi_release_context(adapter, ctx);
+        cmd->result = 0;
+
+        if (sdstat != SAM_STAT_GOOD &&
+            (btstat == BTSTAT_SUCCESS ||
+             btstat == BTSTAT_LINKED_COMMAND_COMPLETED ||
+             btstat == BTSTAT_LINKED_COMMAND_COMPLETED_WITH_FLAG)) {
+                cmd->result = (DID_OK << 16) | sdstat;
+                if (sdstat == SAM_STAT_CHECK_CONDITION && cmd->sense_buffer)
+                        cmd->result |= (DRIVER_SENSE << 24);
+        } else
+                switch (btstat) {
+                case BTSTAT_SUCCESS:
+                case BTSTAT_LINKED_COMMAND_COMPLETED:
+                case BTSTAT_LINKED_COMMAND_COMPLETED_WITH_FLAG:
+                        /* If everything went fine, let's move on..  */
+                        cmd->result = (DID_OK << 16);
+                        break;
+
+                case BTSTAT_DATARUN:
+                case BTSTAT_DATA_UNDERRUN:
+                        /* Report residual data in underruns */
+                        scsi_set_resid(cmd, scsi_bufflen(cmd) - e->dataLen);
+                        cmd->result = (DID_ERROR << 16);
+                        break;
+
+                case BTSTAT_SELTIMEO:
+                        /* Our emulation returns this for non-connected devs */
+                        cmd->result = (DID_BAD_TARGET << 16);
+                        break;
+
+                case BTSTAT_LUNMISMATCH:
+                case BTSTAT_TAGREJECT:
+                case BTSTAT_BADMSG:
+                        cmd->result = (DRIVER_INVALID << 24);
+                        /* fall through */
+
+                case BTSTAT_HAHARDWARE:
+                case BTSTAT_INVPHASE:
+                case BTSTAT_HATIMEOUT:
+                case BTSTAT_NORESPONSE:
+                case BTSTAT_DISCONNECT:
+                case BTSTAT_HASOFTWARE:
+                case BTSTAT_BUSFREE:
+                case BTSTAT_SENSFAILED:
+                        cmd->result |= (DID_ERROR << 16);
+                        break;
+
+                case BTSTAT_SENTRST:
+                case BTSTAT_RECVRST:
+                case BTSTAT_BUSRESET:
+                        cmd->result = (DID_RESET << 16);
+                        break;
+
+                case BTSTAT_ABORTQUEUE:
+                        cmd->result = (DID_ABORT << 16);
+                        break;
+
+                case BTSTAT_SCSIPARITY:
+                        cmd->result = (DID_PARITY << 16);
+                        break;
+
+                default:
+                        cmd->result = (DID_ERROR << 16);
+                        scmd_printk(KERN_DEBUG, cmd,
+                                    "Unknown completion status: 0x%x\n",
+                                    btstat);
+        }
+
+        dev_dbg(&cmd->device->sdev_gendev,
+                "cmd=%p %x ctx=%p result=0x%x status=0x%x,%x\n",
+                cmd, cmd->cmnd[0], ctx, cmd->result, btstat, sdstat);
+
+        cmd->scsi_done(cmd);
+}
+
+/*
+ * barrier usage : Since the PVSCSI device is emulated, there could be cases
+ * where we may want to serialize some accesses between the driver and the
+ * emulation layer. We use compiler barriers instead of the more expensive
+ * memory barriers because PVSCSI is only supported on X86 which has strong
+ * memory access ordering.
+ */
+static void pvscsi_process_completion_ring(struct pvscsi_adapter *adapter)
+{
+        struct PVSCSIRingsState *s = adapter->rings_state;
+        struct PVSCSIRingCmpDesc *ring = adapter->cmp_ring;
+        u32 cmp_entries = s->cmpNumEntriesLog2;
+
+        while (s->cmpConsIdx != s->cmpProdIdx) {
+                struct PVSCSIRingCmpDesc *e = ring + (s->cmpConsIdx &
+                                                      MASK(cmp_entries));
+                /*
+                 * This barrier() ensures that *e is not dereferenced while
+                 * the device emulation still writes data into the slot.
+                 * Since the device emulation advances s->cmpProdIdx only after
+                 * updating the slot we want to check it first.
+                 */
+                barrier();
+                pvscsi_complete_request(adapter, e);
+                /*
+                 * This barrier() ensures that compiler doesn't reorder write
+                 * to s->cmpConsIdx before the read of (*e) inside
+                 * pvscsi_complete_request. Otherwise, device emulation may
+                 * overwrite *e before we had a chance to read it.
+                 */
+                barrier();
+                s->cmpConsIdx++;
+        }
+}
+
+/*
+ * Translate a Linux SCSI request into a request ring entry.
+ */
+static int pvscsi_queue_ring(struct pvscsi_adapter *adapter,
+                             struct pvscsi_ctx *ctx, struct scsi_cmnd *cmd)
+{
+        struct PVSCSIRingsState *s;
+        struct PVSCSIRingReqDesc *e;
+        struct scsi_device *sdev;
+        u32 req_entries;
+
+        s = adapter->rings_state;
+        sdev = cmd->device;
+        req_entries = s->reqNumEntriesLog2;
+
+        /*
+         * If this condition holds, we might have room on the request ring, but
+         * we might not have room on the completion ring for the response.
+         * However, we have already ruled out this possibility - we would not
+         * have successfully allocated a context if it were true, since we only
+         * have one context per request entry.  Check for it anyway, since it
+         * would be a serious bug.
+         */
+        if (s->reqProdIdx - s->cmpConsIdx >= 1 << req_entries) {
+                scmd_printk(KERN_ERR, cmd, "vmw_pvscsi: "
+                            "ring full: reqProdIdx=%d cmpConsIdx=%d\n",
+                            s->reqProdIdx, s->cmpConsIdx);
+                return -1;
+        }
+
+        e = adapter->req_ring + (s->reqProdIdx & MASK(req_entries));
+
+        e->bus    = sdev->channel;
+        e->target = sdev->id;
+        memset(e->lun, 0, sizeof(e->lun));
+        e->lun[1] = sdev->lun;
+
+        if (cmd->sense_buffer) {
+                ctx->sensePA = pci_map_single(adapter->dev, cmd->sense_buffer,
+                                              SCSI_SENSE_BUFFERSIZE,
+                                              PCI_DMA_FROMDEVICE);
+                e->senseAddr = ctx->sensePA;
+                e->senseLen = SCSI_SENSE_BUFFERSIZE;
+        } else {
+                e->senseLen  = 0;
+                e->senseAddr = 0;
+        }
+        e->cdbLen   = cmd->cmd_len;
+        e->vcpuHint = smp_processor_id();
+        memcpy(e->cdb, cmd->cmnd, e->cdbLen);
+
+        e->tag = SIMPLE_QUEUE_TAG;
+        if (sdev->tagged_supported &&
+            (cmd->tag == HEAD_OF_QUEUE_TAG ||
+             cmd->tag == ORDERED_QUEUE_TAG))
+                e->tag = cmd->tag;
+
+        if (cmd->sc_data_direction == DMA_FROM_DEVICE)
+                e->flags = PVSCSI_FLAG_CMD_DIR_TOHOST;
+        else if (cmd->sc_data_direction == DMA_TO_DEVICE)
+                e->flags = PVSCSI_FLAG_CMD_DIR_TODEVICE;
+        else if (cmd->sc_data_direction == DMA_NONE)
+                e->flags = PVSCSI_FLAG_CMD_DIR_NONE;
+        else
+                e->flags = 0;
+
+        pvscsi_map_buffers(adapter, ctx, cmd, e);
+
+        e->context = pvscsi_map_context(adapter, ctx);
+
+        barrier();
+
+        s->reqProdIdx++;
+
+        return 0;
+}
+
+static int pvscsi_queue(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
+{
+        struct Scsi_Host *host = cmd->device->host;
+        struct pvscsi_adapter *adapter = shost_priv(host);
+        struct pvscsi_ctx *ctx;
+        unsigned long flags;
+
+        spin_lock_irqsave(&adapter->hw_lock, flags);
+
+        ctx = pvscsi_acquire_context(adapter, cmd);
+        if (!ctx || pvscsi_queue_ring(adapter, ctx, cmd) != 0) {
+                if (ctx)
+                        pvscsi_release_context(adapter, ctx);
+                spin_unlock_irqrestore(&adapter->hw_lock, flags);
+                return SCSI_MLQUEUE_HOST_BUSY;
+        }
+
+        cmd->scsi_done = done;
+
+        dev_dbg(&cmd->device->sdev_gendev,
+                "queued cmd %p, ctx %p, op=%x\n", cmd, ctx, cmd->cmnd[0]);
+
+        spin_unlock_irqrestore(&adapter->hw_lock, flags);
+
+        pvscsi_kick_io(adapter, cmd->cmnd[0]);
+
+        return 0;
+}
+
+static int pvscsi_abort(struct scsi_cmnd *cmd)
+{
+        struct pvscsi_adapter *adapter = shost_priv(cmd->device->host);
+        struct pvscsi_ctx *ctx;
+        unsigned long flags;
+
+        scmd_printk(KERN_DEBUG, cmd, "task abort on host %u, %p\n",
+                    adapter->host->host_no, cmd);
+
+        spin_lock_irqsave(&adapter->hw_lock, flags);
+
+        /*
+         * Poll the completion ring first - we might be trying to abort
+         * a command that is waiting to be dispatched in the completion ring.
+         */
+        pvscsi_process_completion_ring(adapter);
+
+        /*
+         * If there is no context for the command, it either already succeeded
+         * or else was never properly issued.  Not our problem.
+         */
+        ctx = pvscsi_find_context(adapter, cmd);
+        if (!ctx) {
+                scmd_printk(KERN_DEBUG, cmd, "Failed to abort cmd %p\n", cmd);
+                goto out;
+        }
+
+        pvscsi_abort_cmd(adapter, ctx);
+
+        pvscsi_process_completion_ring(adapter);
+
+out:
+        spin_unlock_irqrestore(&adapter->hw_lock, flags);
+        return SUCCESS;
+}
+
+/*
+ * Abort all outstanding requests.  This is only safe to use if the completion
+ * ring will never be walked again or the device has been reset, because it
+ * destroys the 1-1 mapping between context field passed to emulation and our
+ * request structure.
+ */
+static void pvscsi_reset_all(struct pvscsi_adapter *adapter)
+{
+        unsigned i;
+
+        for (i = 0; i < adapter->req_depth; i++) {
+                struct pvscsi_ctx *ctx = &adapter->cmd_map[i];
+                struct scsi_cmnd *cmd = ctx->cmd;
+                if (cmd) {
+                        scmd_printk(KERN_ERR, cmd,
+                                    "Forced reset on cmd %p\n", cmd);
+                        pvscsi_unmap_buffers(adapter, ctx);
+                        pvscsi_release_context(adapter, ctx);
+                        cmd->result = (DID_RESET << 16);
+                        cmd->scsi_done(cmd);
+                }
+        }
+}
+
+static int pvscsi_host_reset(struct scsi_cmnd *cmd)
+{
+        struct Scsi_Host *host = cmd->device->host;
+        struct pvscsi_adapter *adapter = shost_priv(host);
+        unsigned long flags;
+        bool use_msg;
+
+        scmd_printk(KERN_INFO, cmd, "SCSI Host reset\n");
+
+        spin_lock_irqsave(&adapter->hw_lock, flags);
+
+        use_msg = adapter->use_msg;
+
+        if (use_msg) {
+                adapter->use_msg = 0;
+                spin_unlock_irqrestore(&adapter->hw_lock, flags);
+
+                /*
+                 * Now that we know that the ISR won't add more work on the
+                 * workqueue we can safely flush any outstanding work.
+                 */
+                flush_workqueue(adapter->workqueue);
+                spin_lock_irqsave(&adapter->hw_lock, flags);
+        }
+
+        /*
+         * We're going to tear down the entire ring structure and set it back
+         * up, so stalling new requests until all completions are flushed and
+         * the rings are back in place.
+         */
+
+        pvscsi_process_request_ring(adapter);
+
+        ll_adapter_reset(adapter);
+
+        /*
+         * Now process any completions.  Note we do this AFTER adapter reset,
+         * which is strange, but stops races where completions get posted
+         * between processing the ring and issuing the reset.  The backend will
+         * not touch the ring memory after reset, so the immediately pre-reset
+         * completion ring state is still valid.
+         */
+        pvscsi_process_completion_ring(adapter);
+
+        pvscsi_reset_all(adapter);
+        adapter->use_msg = use_msg;
+        pvscsi_setup_all_rings(adapter);
+        pvscsi_unmask_intr(adapter);
+
+        spin_unlock_irqrestore(&adapter->hw_lock, flags);
+
+        return SUCCESS;
+}
+
+static int pvscsi_bus_reset(struct scsi_cmnd *cmd)
+{
+        struct Scsi_Host *host = cmd->device->host;
+        struct pvscsi_adapter *adapter = shost_priv(host);
+        unsigned long flags;
+
+        scmd_printk(KERN_INFO, cmd, "SCSI Bus reset\n");
+
+        /*
+         * We don't want to queue new requests for this bus after
+         * flushing all pending requests to emulation, since new
+         * requests could then sneak in during this bus reset phase,
+         * so take the lock now.
+         */
+        spin_lock_irqsave(&adapter->hw_lock, flags);
+
+        pvscsi_process_request_ring(adapter);
+        ll_bus_reset(adapter);
+        pvscsi_process_completion_ring(adapter);
+
+        spin_unlock_irqrestore(&adapter->hw_lock, flags);
+
+        return SUCCESS;
+}
+
+static int pvscsi_device_reset(struct scsi_cmnd *cmd)
+{
+        struct Scsi_Host *host = cmd->device->host;
+        struct pvscsi_adapter *adapter = shost_priv(host);
+        unsigned long flags;
+
+        scmd_printk(KERN_INFO, cmd, "SCSI device reset on scsi%u:%u\n",
+                    host->host_no, cmd->device->id);
+
+        /*
+         * We don't want to queue new requests for this device after flushing
+         * all pending requests to emulation, since new requests could then
+         * sneak in during this device reset phase, so take the lock now.
+         */
+        spin_lock_irqsave(&adapter->hw_lock, flags);
+
+        pvscsi_process_request_ring(adapter);
+        ll_device_reset(adapter, cmd->device->id);
+        pvscsi_process_completion_ring(adapter);
+
+        spin_unlock_irqrestore(&adapter->hw_lock, flags);
+
+        return SUCCESS;
+}
+
+static struct scsi_host_template pvscsi_template;
+
+static const char *pvscsi_info(struct Scsi_Host *host)
+{
+        struct pvscsi_adapter *adapter = shost_priv(host);
+        static char buf[256];
+
+        sprintf(buf, "VMware PVSCSI storage adapter rev %d, req/cmp/msg rings: "
+                "%u/%u/%u pages, cmd_per_lun=%u", adapter->rev,
+                adapter->req_pages, adapter->cmp_pages, adapter->msg_pages,
+                pvscsi_template.cmd_per_lun);
+
+        return buf;
+}
+
+static struct scsi_host_template pvscsi_template = {
+        .module                         = THIS_MODULE,
+        .name                           = "VMware PVSCSI Host Adapter",
+        .proc_name                      = "vmw_pvscsi",
+        .info                           = pvscsi_info,
+        .queuecommand                   = pvscsi_queue,
+        .this_id                        = -1,
+        .sg_tablesize                   = PVSCSI_MAX_NUM_SG_ENTRIES_PER_SEGMENT,
+        .dma_boundary                   = UINT_MAX,
+        .max_sectors                    = 0xffff,
+        .use_clustering                 = ENABLE_CLUSTERING,
+        .eh_abort_handler               = pvscsi_abort,
+        .eh_device_reset_handler        = pvscsi_device_reset,
+        .eh_bus_reset_handler           = pvscsi_bus_reset,
+        .eh_host_reset_handler          = pvscsi_host_reset,
+};
+
+static void pvscsi_process_msg(const struct pvscsi_adapter *adapter,
+                               const struct PVSCSIRingMsgDesc *e)
+{
+        struct PVSCSIRingsState *s = adapter->rings_state;
+        struct Scsi_Host *host = adapter->host;
+        struct scsi_device *sdev;
+
+        printk(KERN_INFO "vmw_pvscsi: msg type: 0x%x - MSG RING: %u/%u (%u) \n",
+               e->type, s->msgProdIdx, s->msgConsIdx, s->msgNumEntriesLog2);
+
+        BUILD_BUG_ON(PVSCSI_MSG_LAST != 2);
+
+        if (e->type == PVSCSI_MSG_DEV_ADDED) {
+                struct PVSCSIMsgDescDevStatusChanged *desc;
+                desc = (struct PVSCSIMsgDescDevStatusChanged *)e;
+
+                printk(KERN_INFO
+                       "vmw_pvscsi: msg: device added at scsi%u:%u:%u\n",
+                       desc->bus, desc->target, desc->lun[1]);
+
+                if (!scsi_host_get(host))
+                        return;
+
+                sdev = scsi_device_lookup(host, desc->bus, desc->target,
+                                          desc->lun[1]);
+                if (sdev) {
+                        printk(KERN_INFO "vmw_pvscsi: device already exists\n");
+                        scsi_device_put(sdev);
+                } else
+                        scsi_add_device(adapter->host, desc->bus,
+                                        desc->target, desc->lun[1]);
+
+                scsi_host_put(host);
+        } else if (e->type == PVSCSI_MSG_DEV_REMOVED) {
+                struct PVSCSIMsgDescDevStatusChanged *desc;
+                desc = (struct PVSCSIMsgDescDevStatusChanged *)e;
+
+                printk(KERN_INFO
+                       "vmw_pvscsi: msg: device removed at scsi%u:%u:%u\n",
+                       desc->bus, desc->target, desc->lun[1]);
+
+                if (!scsi_host_get(host))
+                        return;
+
+                sdev = scsi_device_lookup(host, desc->bus, desc->target,
+                                          desc->lun[1]);
+                if (sdev) {
+                        scsi_remove_device(sdev);
+                        scsi_device_put(sdev);
+                } else
+                        printk(KERN_INFO
+                               "vmw_pvscsi: failed to lookup scsi%u:%u:%u\n",
+                               desc->bus, desc->target, desc->lun[1]);
+
+                scsi_host_put(host);
+        }
+}
+
+static int pvscsi_msg_pending(const struct pvscsi_adapter *adapter)
+{
+        struct PVSCSIRingsState *s = adapter->rings_state;
+
+        return s->msgProdIdx != s->msgConsIdx;
+}
+
+static void pvscsi_process_msg_ring(const struct pvscsi_adapter *adapter)
+{
+        struct PVSCSIRingsState *s = adapter->rings_state;
+        struct PVSCSIRingMsgDesc *ring = adapter->msg_ring;
+        u32 msg_entries = s->msgNumEntriesLog2;
+
+        while (pvscsi_msg_pending(adapter)) {
+                struct PVSCSIRingMsgDesc *e = ring + (s->msgConsIdx &
+                                                      MASK(msg_entries));
+
+                barrier();
+                pvscsi_process_msg(adapter, e);
+                barrier();
+                s->msgConsIdx++;
+        }
+}
+
+static void pvscsi_msg_workqueue_handler(struct work_struct *data)
+{
+        struct pvscsi_adapter *adapter;
+
+        adapter = container_of(data, struct pvscsi_adapter, work);
+
+        pvscsi_process_msg_ring(adapter);
+}
+
+static int pvscsi_setup_msg_workqueue(struct pvscsi_adapter *adapter)
+{
+        char name[32];
+
+        if (!pvscsi_use_msg)
+                return 0;
+
+        pvscsi_reg_write(adapter, PVSCSI_REG_OFFSET_COMMAND,
+                         PVSCSI_CMD_SETUP_MSG_RING);
+
+        if (pvscsi_reg_read(adapter, PVSCSI_REG_OFFSET_COMMAND_STATUS) == -1)
+                return 0;
+
+        snprintf(name, sizeof(name),
+                 "vmw_pvscsi_wq_%u", adapter->host->host_no);
+
+        adapter->workqueue = create_singlethread_workqueue(name);
+        if (!adapter->workqueue) {
+                printk(KERN_ERR "vmw_pvscsi: failed to create work queue\n");
+                return 0;
+        }
+        INIT_WORK(&adapter->work, pvscsi_msg_workqueue_handler);
+
+        return 1;
+}
+
+static irqreturn_t pvscsi_isr(int irq, void *devp)
+{
+        struct pvscsi_adapter *adapter = devp;
+        int handled;
+
+        if (adapter->use_msi || adapter->use_msix)
+                handled = true;
+        else {
+                u32 val = pvscsi_read_intr_status(adapter);
+                handled = (val & PVSCSI_INTR_ALL_SUPPORTED) != 0;
+                if (handled)
+                        pvscsi_write_intr_status(devp, val);
+        }
+
+        if (handled) {
+                unsigned long flags;
+
+                spin_lock_irqsave(&adapter->hw_lock, flags);
+
+                pvscsi_process_completion_ring(adapter);
+                if (adapter->use_msg && pvscsi_msg_pending(adapter))
+                        queue_work(adapter->workqueue, &adapter->work);
+
+                spin_unlock_irqrestore(&adapter->hw_lock, flags);
+        }
+
+        return IRQ_RETVAL(handled);
+}
+
+static void pvscsi_free_sgls(const struct pvscsi_adapter *adapter)
+{
+        struct pvscsi_ctx *ctx = adapter->cmd_map;
+        unsigned i;
+
+        for (i = 0; i < adapter->req_depth; ++i, ++ctx)
+                free_pages((unsigned long)ctx->sgl, get_order(SGL_SIZE));
+}
+
+static int pvscsi_setup_msix(const struct pvscsi_adapter *adapter,
+                             unsigned int *irq)
+{
+        struct msix_entry entry = { 0, PVSCSI_VECTOR_COMPLETION };
+        int ret;
+
+        ret = pci_enable_msix(adapter->dev, &entry, 1);
+        if (ret)
+                return ret;
+
+        *irq = entry.vector;
+
+        return 0;
+}
+
+static void pvscsi_shutdown_intr(struct pvscsi_adapter *adapter)
+{
+        if (adapter->irq) {
+                free_irq(adapter->irq, adapter);
+                adapter->irq = 0;
+        }
+        if (adapter->use_msi) {
+                pci_disable_msi(adapter->dev);
+                adapter->use_msi = 0;
+        } else if (adapter->use_msix) {
+                pci_disable_msix(adapter->dev);
+                adapter->use_msix = 0;
+        }
+}
+
+static void pvscsi_release_resources(struct pvscsi_adapter *adapter)
+{
+        pvscsi_shutdown_intr(adapter);
+
+        if (adapter->workqueue)
+                destroy_workqueue(adapter->workqueue);
+
+        if (adapter->mmioBase)
+                pci_iounmap(adapter->dev, adapter->mmioBase);
+
+        pci_release_regions(adapter->dev);
+
+        if (adapter->cmd_map) {
+                pvscsi_free_sgls(adapter);
+                kfree(adapter->cmd_map);
+        }
+
+        if (adapter->rings_state)
+                pci_free_consistent(adapter->dev, PAGE_SIZE,
+                                    adapter->rings_state, adapter->ringStatePA);
+
+        if (adapter->req_ring)
+                pci_free_consistent(adapter->dev,
+                                    adapter->req_pages * PAGE_SIZE,
+                                    adapter->req_ring, adapter->reqRingPA);
+
+        if (adapter->cmp_ring)
+                pci_free_consistent(adapter->dev,
+                                    adapter->cmp_pages * PAGE_SIZE,
+                                    adapter->cmp_ring, adapter->cmpRingPA);
+
+        if (adapter->msg_ring)
+                pci_free_consistent(adapter->dev,
+                                    adapter->msg_pages * PAGE_SIZE,
+                                    adapter->msg_ring, adapter->msgRingPA);
+}
+
+/*
+ * Allocate scatter gather lists.
+ *
+ * These are statically allocated.  Trying to be clever was not worth it.
+ *
+ * Dynamic allocation can fail, and we can't go deeep into the memory
+ * allocator, since we're a SCSI driver, and trying too hard to allocate
+ * memory might generate disk I/O.  We also don't want to fail disk I/O
+ * in that case because we can't get an allocation - the I/O could be
+ * trying to swap out data to free memory.  Since that is pathological,
+ * just use a statically allocated scatter list.
+ *
+ */
+static int __devinit pvscsi_allocate_sg(struct pvscsi_adapter *adapter)
+{
+        struct pvscsi_ctx *ctx;
+        int i;
+
+        ctx = adapter->cmd_map;
+        BUILD_BUG_ON(sizeof(struct pvscsi_sg_list) > SGL_SIZE);
+
+        for (i = 0; i < adapter->req_depth; ++i, ++ctx) {
+                ctx->sgl = (void *)__get_free_pages(GFP_KERNEL,
+                                                    get_order(SGL_SIZE));
+                ctx->sglPA = 0;
+                BUG_ON(!IS_ALIGNED(((unsigned long)ctx->sgl), PAGE_SIZE));
+                if (!ctx->sgl) {
+                        for (; i >= 0; --i, --ctx) {
+                                free_pages((unsigned long)ctx->sgl,
+                                           get_order(SGL_SIZE));
+                                ctx->sgl = NULL;
+                        }
+                        return -ENOMEM;
+                }
+        }
+
+        return 0;
+}
+
+static int __devinit pvscsi_probe(struct pci_dev *pdev,
+                                  const struct pci_device_id *id)
+{
+        struct pvscsi_adapter *adapter;
+        struct Scsi_Host *host;
+        unsigned int i;
+        unsigned long flags = 0;
+        int error;
+
+        error = -ENODEV;
+
+        if (pci_enable_device(pdev))
+                return error;
+
+        if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) == 0 &&
+            pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)) == 0) {
+                printk(KERN_INFO "vmw_pvscsi: using 64bit dma\n");
+        } else if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) == 0 &&
+                   pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)) == 0) {
+                printk(KERN_INFO "vmw_pvscsi: using 32bit dma\n");
+        } else {
+                printk(KERN_ERR "vmw_pvscsi: failed to set DMA mask\n");
+                goto out_disable_device;
+        }
+
+        pvscsi_template.can_queue =
+                min(PVSCSI_MAX_NUM_PAGES_REQ_RING, pvscsi_ring_pages) *
+                PVSCSI_MAX_NUM_REQ_ENTRIES_PER_PAGE;
+        pvscsi_template.cmd_per_lun =
+                min(pvscsi_template.can_queue, pvscsi_cmd_per_lun);
+        host = scsi_host_alloc(&pvscsi_template, sizeof(struct pvscsi_adapter));
+        if (!host) {
+                printk(KERN_ERR "vmw_pvscsi: failed to allocate host\n");
+                goto out_disable_device;
+        }
+
+        adapter = shost_priv(host);
+        memset(adapter, 0, sizeof(*adapter));
+        adapter->dev  = pdev;
+        adapter->host = host;
+
+        spin_lock_init(&adapter->hw_lock);
+
+        host->max_channel = 0;
+        host->max_id      = 16;
+        host->max_lun     = 1;
+        host->max_cmd_len = 16;
+
+        adapter->rev = pdev->revision;
+
+        if (pci_request_regions(pdev, "vmw_pvscsi")) {
+                printk(KERN_ERR "vmw_pvscsi: pci memory selection failed\n");
+                goto out_free_host;
+        }
+
+        for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
+                if ((pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE_IO))
+                        continue;
+
+                if (pci_resource_len(pdev, i) < PVSCSI_MEM_SPACE_SIZE)
+                        continue;
+
+                break;
+        }
+
+        if (i == DEVICE_COUNT_RESOURCE) {
+                printk(KERN_ERR
+                       "vmw_pvscsi: adapter has no suitable MMIO region\n");
+                goto out_release_resources;
+        }
+
+        adapter->mmioBase = pci_iomap(pdev, i, PVSCSI_MEM_SPACE_SIZE);
+
+        if (!adapter->mmioBase) {
+                printk(KERN_ERR
+                       "vmw_pvscsi: can't iomap for BAR %d memsize %lu\n",
+                       i, PVSCSI_MEM_SPACE_SIZE);
+                goto out_release_resources;
+        }
+
+        pci_set_master(pdev);
+        pci_set_drvdata(pdev, host);
+
+        ll_adapter_reset(adapter);
+
+        adapter->use_msg = pvscsi_setup_msg_workqueue(adapter);
+
+        error = pvscsi_allocate_rings(adapter);
+        if (error) {
+                printk(KERN_ERR "vmw_pvscsi: unable to allocate ring memory\n");
+                goto out_release_resources;
+        }
+
+        /*
+         * From this point on we should reset the adapter if anything goes
+         * wrong.
+         */
+        pvscsi_setup_all_rings(adapter);
+
+        adapter->cmd_map = kcalloc(adapter->req_depth,
+                                   sizeof(struct pvscsi_ctx), GFP_KERNEL);
+        if (!adapter->cmd_map) {
+                printk(KERN_ERR "vmw_pvscsi: failed to allocate memory.\n");
+                error = -ENOMEM;
+                goto out_reset_adapter;
+        }
+
+        INIT_LIST_HEAD(&adapter->cmd_pool);
+        for (i = 0; i < adapter->req_depth; i++) {
+                struct pvscsi_ctx *ctx = adapter->cmd_map + i;
+                list_add(&ctx->list, &adapter->cmd_pool);
+        }
+
+        error = pvscsi_allocate_sg(adapter);
+        if (error) {
+                printk(KERN_ERR "vmw_pvscsi: unable to allocate s/g table\n");
+                goto out_reset_adapter;
+        }
+
+        if (!pvscsi_disable_msix &&
+            pvscsi_setup_msix(adapter, &adapter->irq) == 0) {
+                printk(KERN_INFO "vmw_pvscsi: using MSI-X\n");
+                adapter->use_msix = 1;
+        } else if (!pvscsi_disable_msi && pci_enable_msi(pdev) == 0) {
+                printk(KERN_INFO "vmw_pvscsi: using MSI\n");
+                adapter->use_msi = 1;
+                adapter->irq = pdev->irq;
+        } else {
+                printk(KERN_INFO "vmw_pvscsi: using INTx\n");
+                adapter->irq = pdev->irq;
+                flags = IRQF_SHARED;
+        }
+
+        error = request_irq(adapter->irq, pvscsi_isr, flags,
+                            "vmw_pvscsi", adapter);
+        if (error) {
+                printk(KERN_ERR
+                       "vmw_pvscsi: unable to request IRQ: %d\n", error);
+                adapter->irq = 0;
+                goto out_reset_adapter;
+        }
+
+        error = scsi_add_host(host, &pdev->dev);
+        if (error) {
+                printk(KERN_ERR
+                       "vmw_pvscsi: scsi_add_host failed: %d\n", error);
+                goto out_reset_adapter;
+        }
+
+        dev_info(&pdev->dev, "VMware PVSCSI rev %d host #%u\n",
+                 adapter->rev, host->host_no);
+
+        pvscsi_unmask_intr(adapter);
+
+        scsi_scan_host(host);
+
+        return 0;
+
+out_reset_adapter:
+        ll_adapter_reset(adapter);
+out_release_resources:
+        pvscsi_release_resources(adapter);
+out_free_host:
+        scsi_host_put(host);
+out_disable_device:
+        pci_set_drvdata(pdev, NULL);
+        pci_disable_device(pdev);
+
+        return error;
+}
+
+static void __pvscsi_shutdown(struct pvscsi_adapter *adapter)
+{
+        pvscsi_mask_intr(adapter);
+
+        if (adapter->workqueue)
+                flush_workqueue(adapter->workqueue);
+
+        pvscsi_shutdown_intr(adapter);
+
+        pvscsi_process_request_ring(adapter);
+        pvscsi_process_completion_ring(adapter);
+        ll_adapter_reset(adapter);
+}
+
+static void pvscsi_shutdown(struct pci_dev *dev)
+{
+        struct Scsi_Host *host = pci_get_drvdata(dev);
+        struct pvscsi_adapter *adapter = shost_priv(host);
+
+        __pvscsi_shutdown(adapter);
+}
+
+static void pvscsi_remove(struct pci_dev *pdev)
+{
+        struct Scsi_Host *host = pci_get_drvdata(pdev);
+        struct pvscsi_adapter *adapter = shost_priv(host);
+
+        scsi_remove_host(host);
+
+        __pvscsi_shutdown(adapter);
+        pvscsi_release_resources(adapter);
+
+        scsi_host_put(host);
+
+        pci_set_drvdata(pdev, NULL);
+        pci_disable_device(pdev);
+}
+
+static struct pci_driver pvscsi_pci_driver = {
+        .name           = "vmw_pvscsi",
+        .id_table       = pvscsi_pci_tbl,
+        .probe          = pvscsi_probe,
+        .remove         = __devexit_p(pvscsi_remove),
+        .shutdown       = pvscsi_shutdown,
+};
+
+static int __init pvscsi_init(void)
+{
+        pr_info("%s - version %s\n",
+                PVSCSI_LINUX_DRIVER_DESC, PVSCSI_DRIVER_VERSION_STRING);
+        return pci_register_driver(&pvscsi_pci_driver);
+}
+
+static void __exit pvscsi_exit(void)
+{
+        pci_unregister_driver(&pvscsi_pci_driver);
+}
+
+module_init(pvscsi_init);
+module_exit(pvscsi_exit);
diff --git a/drivers/scsi/vmw_pvscsi.h b/drivers/scsi/vmw_pvscsi.h
new file mode 100644
index 000000000000..62e36e75715e
--- /dev/null
+++ b/drivers/scsi/vmw_pvscsi.h
@@ -0,0 +1,397 @@
+/*
+ * VMware PVSCSI header file
+ *
+ * Copyright (C) 2008-2009, VMware, Inc. All Rights Reserved.
+ *
+ * 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; version 2 of the License and no 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, GOOD TITLE or
+ * NON INFRINGEMENT.  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.
+ *
+ * Maintained by: Alok N Kataria <akataria@vmware.com>
+ *
+ */
+
+#ifndef _VMW_PVSCSI_H_
+#define _VMW_PVSCSI_H_
+
+#include <linux/types.h>
+
+#define PVSCSI_DRIVER_VERSION_STRING   "1.0.1.0-k"
+
+#define PVSCSI_MAX_NUM_SG_ENTRIES_PER_SEGMENT 128
+
+#define MASK(n)        ((1 << (n)) - 1)        /* make an n-bit mask */
+
+#define PCI_VENDOR_ID_VMWARE            0x15AD
+#define PCI_DEVICE_ID_VMWARE_PVSCSI     0x07C0
+
+/*
+ * host adapter status/error codes
+ */
+enum HostBusAdapterStatus {
+   BTSTAT_SUCCESS       = 0x00,  /* CCB complete normally with no errors */
+   BTSTAT_LINKED_COMMAND_COMPLETED           = 0x0a,
+   BTSTAT_LINKED_COMMAND_COMPLETED_WITH_FLAG = 0x0b,
+   BTSTAT_DATA_UNDERRUN = 0x0c,
+   BTSTAT_SELTIMEO      = 0x11,  /* SCSI selection timeout */
+   BTSTAT_DATARUN       = 0x12,  /* data overrun/underrun */
+   BTSTAT_BUSFREE       = 0x13,  /* unexpected bus free */
+   BTSTAT_INVPHASE      = 0x14,  /* invalid bus phase or sequence requested by target */
+   BTSTAT_LUNMISMATCH   = 0x17,  /* linked CCB has different LUN from first CCB */
+   BTSTAT_SENSFAILED    = 0x1b,  /* auto request sense failed */
+   BTSTAT_TAGREJECT     = 0x1c,  /* SCSI II tagged queueing message rejected by target */
+   BTSTAT_BADMSG        = 0x1d,  /* unsupported message received by the host adapter */
+   BTSTAT_HAHARDWARE    = 0x20,  /* host adapter hardware failed */
+   BTSTAT_NORESPONSE    = 0x21,  /* target did not respond to SCSI ATN, sent a SCSI RST */
+   BTSTAT_SENTRST       = 0x22,  /* host adapter asserted a SCSI RST */
+   BTSTAT_RECVRST       = 0x23,  /* other SCSI devices asserted a SCSI RST */
+   BTSTAT_DISCONNECT    = 0x24,  /* target device reconnected improperly (w/o tag) */
+   BTSTAT_BUSRESET      = 0x25,  /* host adapter issued BUS device reset */
+   BTSTAT_ABORTQUEUE    = 0x26,  /* abort queue generated */
+   BTSTAT_HASOFTWARE    = 0x27,  /* host adapter software error */
+   BTSTAT_HATIMEOUT     = 0x30,  /* host adapter hardware timeout error */
+   BTSTAT_SCSIPARITY    = 0x34,  /* SCSI parity error detected */
+};
+
+/*
+ * Register offsets.
+ *
+ * These registers are accessible both via i/o space and mm i/o.
+ */
+
+enum PVSCSIRegOffset {
+        PVSCSI_REG_OFFSET_COMMAND        =    0x0,
+        PVSCSI_REG_OFFSET_COMMAND_DATA   =    0x4,
+        PVSCSI_REG_OFFSET_COMMAND_STATUS =    0x8,
+        PVSCSI_REG_OFFSET_LAST_STS_0     =  0x100,
+        PVSCSI_REG_OFFSET_LAST_STS_1     =  0x104,
+        PVSCSI_REG_OFFSET_LAST_STS_2     =  0x108,
+        PVSCSI_REG_OFFSET_LAST_STS_3     =  0x10c,
+        PVSCSI_REG_OFFSET_INTR_STATUS    = 0x100c,
+        PVSCSI_REG_OFFSET_INTR_MASK      = 0x2010,
+        PVSCSI_REG_OFFSET_KICK_NON_RW_IO = 0x3014,
+        PVSCSI_REG_OFFSET_DEBUG          = 0x3018,
+        PVSCSI_REG_OFFSET_KICK_RW_IO     = 0x4018,
+};
+
+/*
+ * Virtual h/w commands.
+ */
+
+enum PVSCSICommands {
+        PVSCSI_CMD_FIRST             = 0, /* has to be first */
+
+        PVSCSI_CMD_ADAPTER_RESET     = 1,
+        PVSCSI_CMD_ISSUE_SCSI        = 2,
+        PVSCSI_CMD_SETUP_RINGS       = 3,
+        PVSCSI_CMD_RESET_BUS         = 4,
+        PVSCSI_CMD_RESET_DEVICE      = 5,
+        PVSCSI_CMD_ABORT_CMD         = 6,
+        PVSCSI_CMD_CONFIG            = 7,
+        PVSCSI_CMD_SETUP_MSG_RING    = 8,
+        PVSCSI_CMD_DEVICE_UNPLUG     = 9,
+
+        PVSCSI_CMD_LAST              = 10  /* has to be last */
+};
+
+/*
+ * Command descriptor for PVSCSI_CMD_RESET_DEVICE --
+ */
+
+struct PVSCSICmdDescResetDevice {
+        u32     target;
+        u8      lun[8];
+} __packed;
+
+/*
+ * Command descriptor for PVSCSI_CMD_ABORT_CMD --
+ *
+ * - currently does not support specifying the LUN.
+ * - _pad should be 0.
+ */
+
+struct PVSCSICmdDescAbortCmd {
+        u64     context;
+        u32     target;
+        u32     _pad;
+} __packed;
+
+/*
+ * Command descriptor for PVSCSI_CMD_SETUP_RINGS --
+ *
+ * Notes:
+ * - reqRingNumPages and cmpRingNumPages need to be power of two.
+ * - reqRingNumPages and cmpRingNumPages need to be different from 0,
+ * - reqRingNumPages and cmpRingNumPages need to be inferior to
+ *   PVSCSI_SETUP_RINGS_MAX_NUM_PAGES.
+ */
+
+#define PVSCSI_SETUP_RINGS_MAX_NUM_PAGES        32
+struct PVSCSICmdDescSetupRings {
+        u32     reqRingNumPages;
+        u32     cmpRingNumPages;
+        u64     ringsStatePPN;
+        u64     reqRingPPNs[PVSCSI_SETUP_RINGS_MAX_NUM_PAGES];
+        u64     cmpRingPPNs[PVSCSI_SETUP_RINGS_MAX_NUM_PAGES];
+} __packed;
+
+/*
+ * Command descriptor for PVSCSI_CMD_SETUP_MSG_RING --
+ *
+ * Notes:
+ * - this command was not supported in the initial revision of the h/w
+ *   interface. Before using it, you need to check that it is supported by
+ *   writing PVSCSI_CMD_SETUP_MSG_RING to the 'command' register, then
+ *   immediately after read the 'command status' register:
+ *       * a value of -1 means that the cmd is NOT supported,
+ *       * a value != -1 means that the cmd IS supported.
+ *   If it's supported the 'command status' register should return:
+ *      sizeof(PVSCSICmdDescSetupMsgRing) / sizeof(u32).
+ * - this command should be issued _after_ the usual SETUP_RINGS so that the
+ *   RingsState page is already setup. If not, the command is a nop.
+ * - numPages needs to be a power of two,
+ * - numPages needs to be different from 0,
+ * - _pad should be zero.
+ */
+
+#define PVSCSI_SETUP_MSG_RING_MAX_NUM_PAGES  16
+
+struct PVSCSICmdDescSetupMsgRing {
+        u32     numPages;
+        u32     _pad;
+        u64     ringPPNs[PVSCSI_SETUP_MSG_RING_MAX_NUM_PAGES];
+} __packed;
+
+enum PVSCSIMsgType {
+        PVSCSI_MSG_DEV_ADDED          = 0,
+        PVSCSI_MSG_DEV_REMOVED        = 1,
+        PVSCSI_MSG_LAST               = 2,
+};
+
+/*
+ * Msg descriptor.
+ *
+ * sizeof(struct PVSCSIRingMsgDesc) == 128.
+ *
+ * - type is of type enum PVSCSIMsgType.
+ * - the content of args depend on the type of event being delivered.
+ */
+
+struct PVSCSIRingMsgDesc {
+        u32     type;
+        u32     args[31];
+} __packed;
+
+struct PVSCSIMsgDescDevStatusChanged {
+        u32     type;  /* PVSCSI_MSG_DEV _ADDED / _REMOVED */
+        u32     bus;
+        u32     target;
+        u8      lun[8];
+        u32     pad[27];
+} __packed;
+
+/*
+ * Rings state.
+ *
+ * - the fields:
+ *    . msgProdIdx,
+ *    . msgConsIdx,
+ *    . msgNumEntriesLog2,
+ *   .. are only used once the SETUP_MSG_RING cmd has been issued.
+ * - '_pad' helps to ensure that the msg related fields are on their own
+ *   cache-line.
+ */
+
+struct PVSCSIRingsState {
+        u32     reqProdIdx;
+        u32     reqConsIdx;
+        u32     reqNumEntriesLog2;
+
+        u32     cmpProdIdx;
+        u32     cmpConsIdx;
+        u32     cmpNumEntriesLog2;
+
+        u8      _pad[104];
+
+        u32     msgProdIdx;
+        u32     msgConsIdx;
+        u32     msgNumEntriesLog2;
+} __packed;
+
+/*
+ * Request descriptor.
+ *
+ * sizeof(RingReqDesc) = 128
+ *
+ * - context: is a unique identifier of a command. It could normally be any
+ *   64bit value, however we currently store it in the serialNumber variable
+ *   of struct SCSI_Command, so we have the following restrictions due to the
+ *   way this field is handled in the vmkernel storage stack:
+ *    * this value can't be 0,
+ *    * the upper 32bit need to be 0 since serialNumber is as a u32.
+ *   Currently tracked as PR 292060.
+ * - dataLen: contains the total number of bytes that need to be transferred.
+ * - dataAddr:
+ *   * if PVSCSI_FLAG_CMD_WITH_SG_LIST is set: dataAddr is the PA of the first
+ *     s/g table segment, each s/g segment is entirely contained on a single
+ *     page of physical memory,
+ *   * if PVSCSI_FLAG_CMD_WITH_SG_LIST is NOT set, then dataAddr is the PA of
+ *     the buffer used for the DMA transfer,
+ * - flags:
+ *   * PVSCSI_FLAG_CMD_WITH_SG_LIST: see dataAddr above,
+ *   * PVSCSI_FLAG_CMD_DIR_NONE: no DMA involved,
+ *   * PVSCSI_FLAG_CMD_DIR_TOHOST: transfer from device to main memory,
+ *   * PVSCSI_FLAG_CMD_DIR_TODEVICE: transfer from main memory to device,
+ *   * PVSCSI_FLAG_CMD_OUT_OF_BAND_CDB: reserved to handle CDBs larger than
+ *     16bytes. To be specified.
+ * - vcpuHint: vcpuId of the processor that will be most likely waiting for the
+ *   completion of the i/o. For guest OSes that use lowest priority message
+ *   delivery mode (such as windows), we use this "hint" to deliver the
+ *   completion action to the proper vcpu. For now, we can use the vcpuId of
+ *   the processor that initiated the i/o as a likely candidate for the vcpu
+ *   that will be waiting for the completion..
+ * - bus should be 0: we currently only support bus 0 for now.
+ * - unused should be zero'd.
+ */
+
+#define PVSCSI_FLAG_CMD_WITH_SG_LIST        (1 << 0)
+#define PVSCSI_FLAG_CMD_OUT_OF_BAND_CDB     (1 << 1)
+#define PVSCSI_FLAG_CMD_DIR_NONE            (1 << 2)
+#define PVSCSI_FLAG_CMD_DIR_TOHOST          (1 << 3)
+#define PVSCSI_FLAG_CMD_DIR_TODEVICE        (1 << 4)
+
+struct PVSCSIRingReqDesc {
+        u64     context;
+        u64     dataAddr;
+        u64     dataLen;
+        u64     senseAddr;
+        u32     senseLen;
+        u32     flags;
+        u8      cdb[16];
+        u8      cdbLen;
+        u8      lun[8];
+        u8      tag;
+        u8      bus;
+        u8      target;
+        u8      vcpuHint;
+        u8      unused[59];
+} __packed;
+
+/*
+ * Scatter-gather list management.
+ *
+ * As described above, when PVSCSI_FLAG_CMD_WITH_SG_LIST is set in the
+ * RingReqDesc.flags, then RingReqDesc.dataAddr is the PA of the first s/g
+ * table segment.
+ *
+ * - each segment of the s/g table contain a succession of struct
+ *   PVSCSISGElement.
+ * - each segment is entirely contained on a single physical page of memory.
+ * - a "chain" s/g element has the flag PVSCSI_SGE_FLAG_CHAIN_ELEMENT set in
+ *   PVSCSISGElement.flags and in this case:
+ *     * addr is the PA of the next s/g segment,
+ *     * length is undefined, assumed to be 0.
+ */
+
+struct PVSCSISGElement {
+        u64     addr;
+        u32     length;
+        u32     flags;
+} __packed;
+
+/*
+ * Completion descriptor.
+ *
+ * sizeof(RingCmpDesc) = 32
+ *
+ * - context: identifier of the command. The same thing that was specified
+ *   under "context" as part of struct RingReqDesc at initiation time,
+ * - dataLen: number of bytes transferred for the actual i/o operation,
+ * - senseLen: number of bytes written into the sense buffer,
+ * - hostStatus: adapter status,
+ * - scsiStatus: device status,
+ * - _pad should be zero.
+ */
+
+struct PVSCSIRingCmpDesc {
+        u64     context;
+        u64     dataLen;
+        u32     senseLen;
+        u16     hostStatus;
+        u16     scsiStatus;
+        u32     _pad[2];
+} __packed;
+
+/*
+ * Interrupt status / IRQ bits.
+ */
+
+#define PVSCSI_INTR_CMPL_0                 (1 << 0)
+#define PVSCSI_INTR_CMPL_1                 (1 << 1)
+#define PVSCSI_INTR_CMPL_MASK              MASK(2)
+
+#define PVSCSI_INTR_MSG_0                  (1 << 2)
+#define PVSCSI_INTR_MSG_1                  (1 << 3)
+#define PVSCSI_INTR_MSG_MASK               (MASK(2) << 2)
+
+#define PVSCSI_INTR_ALL_SUPPORTED          MASK(4)
+
+/*
+ * Number of MSI-X vectors supported.
+ */
+#define PVSCSI_MAX_INTRS        24
+
+/*
+ * Enumeration of supported MSI-X vectors
+ */
+#define PVSCSI_VECTOR_COMPLETION   0
+
+/*
+ * Misc constants for the rings.
+ */
+
+#define PVSCSI_MAX_NUM_PAGES_REQ_RING   PVSCSI_SETUP_RINGS_MAX_NUM_PAGES
+#define PVSCSI_MAX_NUM_PAGES_CMP_RING   PVSCSI_SETUP_RINGS_MAX_NUM_PAGES
+#define PVSCSI_MAX_NUM_PAGES_MSG_RING   PVSCSI_SETUP_MSG_RING_MAX_NUM_PAGES
+
+#define PVSCSI_MAX_NUM_REQ_ENTRIES_PER_PAGE \
+                                (PAGE_SIZE / sizeof(struct PVSCSIRingReqDesc))
+
+#define PVSCSI_MAX_REQ_QUEUE_DEPTH \
+        (PVSCSI_MAX_NUM_PAGES_REQ_RING * PVSCSI_MAX_NUM_REQ_ENTRIES_PER_PAGE)
+
+#define PVSCSI_MEM_SPACE_COMMAND_NUM_PAGES     1
+#define PVSCSI_MEM_SPACE_INTR_STATUS_NUM_PAGES 1
+#define PVSCSI_MEM_SPACE_MISC_NUM_PAGES        2
+#define PVSCSI_MEM_SPACE_KICK_IO_NUM_PAGES     2
+#define PVSCSI_MEM_SPACE_MSIX_NUM_PAGES        2
+
+enum PVSCSIMemSpace {
+        PVSCSI_MEM_SPACE_COMMAND_PAGE           = 0,
+        PVSCSI_MEM_SPACE_INTR_STATUS_PAGE       = 1,
+        PVSCSI_MEM_SPACE_MISC_PAGE              = 2,
+        PVSCSI_MEM_SPACE_KICK_IO_PAGE           = 4,
+        PVSCSI_MEM_SPACE_MSIX_TABLE_PAGE        = 6,
+        PVSCSI_MEM_SPACE_MSIX_PBA_PAGE          = 7,
+};
+
+#define PVSCSI_MEM_SPACE_NUM_PAGES \
+        (PVSCSI_MEM_SPACE_COMMAND_NUM_PAGES +       \
+         PVSCSI_MEM_SPACE_INTR_STATUS_NUM_PAGES +   \
+         PVSCSI_MEM_SPACE_MISC_NUM_PAGES +          \
+         PVSCSI_MEM_SPACE_KICK_IO_NUM_PAGES +       \
+         PVSCSI_MEM_SPACE_MSIX_NUM_PAGES)
+
+#define PVSCSI_MEM_SPACE_SIZE        (PVSCSI_MEM_SPACE_NUM_PAGES * PAGE_SIZE)
+
+#endif /* _VMW_PVSCSI_H_ */
diff --git a/drivers/scsi/wd7000.c b/drivers/scsi/wd7000.c
index 093610bcfcce..333580bf37c5 100644
--- a/drivers/scsi/wd7000.c
+++ b/drivers/scsi/wd7000.c
@@ -161,7 +161,7 @@
  *
  * 2003/02/12 - Christoph Hellwig <hch@infradead.org>
  *
- * Cleaned up host template defintion
+ * Cleaned up host template definition
  * Removed now obsolete wd7000.h
  */
 
@@ -171,7 +171,6 @@
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/string.h>
-#include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/ioport.h>
 #include <linux/proc_fs.h>
@@ -1588,7 +1587,7 @@ static int wd7000_host_reset(struct scsi_cmnd *SCpnt)
 {
         Adapter *host = (Adapter *) SCpnt->device->host->hostdata;
 
-        spin_unlock_irq(SCpnt->device->host->host_lock);
+        spin_lock_irq(SCpnt->device->host->host_lock);
 
         if (wd7000_adapter_reset(host) < 0) {
                 spin_unlock_irq(SCpnt->device->host->host_lock);
diff --git a/drivers/scsi/zorro7xx.c b/drivers/scsi/zorro7xx.c
index 64d40a2d4d4d..105449c15fa9 100644
--- a/drivers/scsi/zorro7xx.c
+++ b/drivers/scsi/zorro7xx.c
@@ -13,6 +13,7 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/zorro.h>
+#include <linux/slab.h>
 
 #include <asm/amigahw.h>
 #include <asm/amigaints.h>