Merge branch 'next' into for-linus

Prepare first round of input updates for 4.1 merge window.

102 files changed, 5173 insertions, 3516 deletions

diff --git a/drivers/scsi/3w-9xxx.c b/drivers/scsi/3w-9xxx.c
index cd4129ff7ae4..7600639db4c4 100644
--- a/drivers/scsi/3w-9xxx.c
+++ b/drivers/scsi/3w-9xxx.c
@@ -608,7 +608,8 @@ static int twa_check_srl(TW_Device_Extension *tw_dev, int *flashed)
         }
 
         /* Load rest of compatibility struct */
-        strncpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
+        strlcpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION,
+                sizeof(tw_dev->tw_compat_info.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;
diff --git a/drivers/scsi/BusLogic.c b/drivers/scsi/BusLogic.c
index 8d66a6469e29..c7be7bb37209 100644
--- a/drivers/scsi/BusLogic.c
+++ b/drivers/scsi/BusLogic.c
@@ -3485,7 +3485,7 @@ static int blogic_show_info(struct seq_file *m, struct Scsi_Host *shost)
         seq_printf(m, "\n\
 Current Driver Queue Depth:     %d\n\
 Currently Allocated CCBs:       %d\n", adapter->drvr_qdepth, adapter->alloc_ccbs);
-        seq_printf(m, "\n\n\
+        seq_puts(m, "\n\n\
                            DATA TRANSFER STATISTICS\n\
 \n\
 Target  Tagged Queuing  Queue Depth  Active  Attempted  Completed\n\
@@ -3500,7 +3500,7 @@ Target	Tagged Queuing	Queue Depth  Active  Attempted	Completed\n\
                 seq_printf(m,
                                   "         %3d       %3u    %9u        %9u\n", adapter->qdepth[tgt], adapter->active_cmds[tgt], tgt_stats[tgt].cmds_tried, tgt_stats[tgt].cmds_complete);
         }
-        seq_printf(m, "\n\
+        seq_puts(m, "\n\
 Target  Read Commands  Write Commands   Total Bytes Read    Total Bytes Written\n\
 ======  =============  ==============  ===================  ===================\n");
         for (tgt = 0; tgt < adapter->maxdev; tgt++) {
@@ -3517,7 +3517,7 @@ Target  Read Commands  Write Commands   Total Bytes Read    Total Bytes Written\
                 else
                         seq_printf(m, "      %9u\n", tgt_stats[tgt].byteswritten.units);
         }
-        seq_printf(m, "\n\
+        seq_puts(m, "\n\
 Target  Command    0-1KB      1-2KB      2-4KB      4-8KB     8-16KB\n\
 ======  =======  =========  =========  =========  =========  =========\n");
         for (tgt = 0; tgt < adapter->maxdev; tgt++) {
@@ -3533,7 +3533,7 @@ Target  Command    0-1KB      1-2KB      2-4KB      4-8KB     8-16KB\n\
                             tgt_stats[tgt].write_sz_buckets[0],
                             tgt_stats[tgt].write_sz_buckets[1], tgt_stats[tgt].write_sz_buckets[2], tgt_stats[tgt].write_sz_buckets[3], tgt_stats[tgt].write_sz_buckets[4]);
         }
-        seq_printf(m, "\n\
+        seq_puts(m, "\n\
 Target  Command   16-32KB    32-64KB   64-128KB   128-256KB   256KB+\n\
 ======  =======  =========  =========  =========  =========  =========\n");
         for (tgt = 0; tgt < adapter->maxdev; tgt++) {
@@ -3549,7 +3549,7 @@ Target  Command   16-32KB    32-64KB   64-128KB   128-256KB   256KB+\n\
                             tgt_stats[tgt].write_sz_buckets[5],
                             tgt_stats[tgt].write_sz_buckets[6], tgt_stats[tgt].write_sz_buckets[7], tgt_stats[tgt].write_sz_buckets[8], tgt_stats[tgt].write_sz_buckets[9]);
         }
-        seq_printf(m, "\n\n\
+        seq_puts(m, "\n\n\
                            ERROR RECOVERY STATISTICS\n\
 \n\
           Command Aborts      Bus Device Resets   Host Adapter Resets\n\
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index 9c92f415229f..b021bcb88537 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -201,12 +201,12 @@ config SCSI_ENCLOSURE
           certain enclosure conditions to be reported and is not required.
 
 config SCSI_CONSTANTS
-        bool "Verbose SCSI error reporting (kernel size +=12K)"
+        bool "Verbose SCSI error reporting (kernel size +=75K)"
         depends on SCSI
         help
           The error messages regarding your SCSI hardware will be easier to
           understand if you say Y here; it will enlarge your kernel by about
-          12 KB. If in doubt, say Y.
+          75 KB. If in doubt, say Y.
 
 config SCSI_LOGGING
         bool "SCSI logging facility"
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 58158f11ed7b..dee160a4f163 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -159,15 +159,15 @@ obj-$(CONFIG_SCSI_OSD_INITIATOR) += osd/
 
 # This goes last, so that "real" scsi devices probe earlier
 obj-$(CONFIG_SCSI_DEBUG)        += scsi_debug.o
-
-scsi_mod-y                      += scsi.o hosts.o scsi_ioctl.o constants.o \
+scsi_mod-y                      += scsi.o hosts.o scsi_ioctl.o \
                                    scsicam.o scsi_error.o scsi_lib.o
+scsi_mod-$(CONFIG_SCSI_CONSTANTS) += constants.o
 scsi_mod-$(CONFIG_SCSI_DMA)     += scsi_lib_dma.o
 scsi_mod-y                      += scsi_scan.o scsi_sysfs.o scsi_devinfo.o
 scsi_mod-$(CONFIG_SCSI_NETLINK) += scsi_netlink.o
 scsi_mod-$(CONFIG_SYSCTL)       += scsi_sysctl.o
 scsi_mod-$(CONFIG_SCSI_PROC_FS) += scsi_proc.o
-scsi_mod-y                      += scsi_trace.o
+scsi_mod-y                      += scsi_trace.o scsi_logging.o
 scsi_mod-$(CONFIG_PM)           += scsi_pm.o
 
 hv_storvsc-y                    := storvsc_drv.o
diff --git a/drivers/scsi/NCR5380.c b/drivers/scsi/NCR5380.c
index 36244d63def2..8981701802ca 100644
--- a/drivers/scsi/NCR5380.c
+++ b/drivers/scsi/NCR5380.c
@@ -716,8 +716,6 @@ static int __maybe_unused NCR5380_write_info(struct Scsi_Host *instance,
 }
 #endif
 
-#undef SPRINTF
-#define SPRINTF(args...) seq_printf(m, ## args)
 static
 void lprint_Scsi_Cmnd(struct scsi_cmnd *cmd, struct seq_file *m);
 static
@@ -734,19 +732,19 @@ static int __maybe_unused NCR5380_show_info(struct seq_file *m,
         hostdata = (struct NCR5380_hostdata *) instance->hostdata;
 
 #ifdef PSEUDO_DMA
-        SPRINTF("Highwater I/O busy spin counts: write %d, read %d\n",
+        seq_printf(m, "Highwater I/O busy spin counts: write %d, read %d\n",
                 hostdata->spin_max_w, hostdata->spin_max_r);
 #endif
         spin_lock_irq(instance->host_lock);
         if (!hostdata->connected)
-                SPRINTF("scsi%d: no currently connected command\n", instance->host_no);
+                seq_printf(m, "scsi%d: no currently connected command\n", instance->host_no);
         else
                 lprint_Scsi_Cmnd((struct scsi_cmnd *) hostdata->connected, m);
-        SPRINTF("scsi%d: issue_queue\n", instance->host_no);
+        seq_printf(m, "scsi%d: issue_queue\n", instance->host_no);
         for (ptr = (struct scsi_cmnd *) hostdata->issue_queue; ptr; ptr = (struct scsi_cmnd *) ptr->host_scribble)
                 lprint_Scsi_Cmnd(ptr, m);
 
-        SPRINTF("scsi%d: disconnected_queue\n", instance->host_no);
+        seq_printf(m, "scsi%d: disconnected_queue\n", instance->host_no);
         for (ptr = (struct scsi_cmnd *) hostdata->disconnected_queue; ptr; ptr = (struct scsi_cmnd *) ptr->host_scribble)
                 lprint_Scsi_Cmnd(ptr, m);
         spin_unlock_irq(instance->host_lock);
@@ -755,8 +753,8 @@ static int __maybe_unused NCR5380_show_info(struct seq_file *m,
 
 static void lprint_Scsi_Cmnd(struct scsi_cmnd *cmd, struct seq_file *m)
 {
-        SPRINTF("scsi%d : destination target %d, lun %llu\n", cmd->device->host->host_no, cmd->device->id, cmd->device->lun);
-        SPRINTF("        command = ");
+        seq_printf(m, "scsi%d : destination target %d, lun %llu\n", cmd->device->host->host_no, cmd->device->id, cmd->device->lun);
+        seq_puts(m, "        command = ");
         lprint_command(cmd->cmnd, m);
 }
 
@@ -765,13 +763,13 @@ static void lprint_command(unsigned char *command, struct seq_file *m)
         int i, s;
         lprint_opcode(command[0], m);
         for (i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i)
-                SPRINTF("%02x ", command[i]);
-        SPRINTF("\n");
+                seq_printf(m, "%02x ", command[i]);
+        seq_putc(m, '\n');
 }
 
 static void lprint_opcode(int opcode, struct seq_file *m)
 {
-        SPRINTF("%2d (0x%02x)", opcode, opcode);
+        seq_printf(m, "%2d (0x%02x)", opcode, opcode);
 }
 
 
diff --git a/drivers/scsi/advansys.c b/drivers/scsi/advansys.c
index 2c5ce48c8f95..ae95e347f37d 100644
--- a/drivers/scsi/advansys.c
+++ b/drivers/scsi/advansys.c
@@ -2880,7 +2880,7 @@ static void asc_prt_board_devices(struct seq_file *m, struct Scsi_Host *shost)
                 chip_scsi_id = boardp->dvc_var.adv_dvc_var.chip_scsi_id;
         }
 
-        seq_printf(m, "Target IDs Detected:");
+        seq_puts(m, "Target IDs Detected:");
         for (i = 0; i <= ADV_MAX_TID; i++) {
                 if (boardp->init_tidmask & ADV_TID_TO_TIDMASK(i))
                         seq_printf(m, " %X,", i);
@@ -2896,18 +2896,16 @@ static void asc_prt_adv_bios(struct seq_file *m, struct Scsi_Host *shost)
         struct asc_board *boardp = shost_priv(shost);
         ushort major, minor, letter;
 
-        seq_printf(m, "\nROM BIOS Version: ");
+        seq_puts(m, "\nROM BIOS Version: ");
 
         /*
          * If the BIOS saved a valid signature, then fill in
          * the BIOS code segment base address.
          */
         if (boardp->bios_signature != 0x55AA) {
-                seq_printf(m, "Disabled or Pre-3.1\n");
-                seq_printf(m,
-                          "BIOS either disabled or Pre-3.1. If it is pre-3.1, then a newer version\n");
-                seq_printf(m,
-                          "can be found at the ConnectCom FTP site: ftp://ftp.connectcom.net/pub\n");
+                seq_puts(m, "Disabled or Pre-3.1\n"
+                        "BIOS either disabled or Pre-3.1. If it is pre-3.1, then a newer version\n"
+                        "can be found at the ConnectCom FTP site: ftp://ftp.connectcom.net/pub\n");
         } else {
                 major = (boardp->bios_version >> 12) & 0xF;
                 minor = (boardp->bios_version >> 8) & 0xF;
@@ -2923,10 +2921,8 @@ static void asc_prt_adv_bios(struct seq_file *m, struct Scsi_Host *shost)
                  */
                 if (major < 3 || (major <= 3 && minor < 1) ||
                     (major <= 3 && minor <= 1 && letter < ('I' - 'A'))) {
-                        seq_printf(m,
-                                   "Newer version of ROM BIOS is available at the ConnectCom FTP site:\n");
-                        seq_printf(m,
-                                   "ftp://ftp.connectcom.net/pub\n");
+                        seq_puts(m, "Newer version of ROM BIOS is available at the ConnectCom FTP site:\n"
+                                "ftp://ftp.connectcom.net/pub\n");
                 }
         }
 }
@@ -3056,11 +3052,10 @@ static void asc_prt_asc_board_eeprom(struct seq_file *m, struct Scsi_Host *shost
             == ASC_TRUE)
                 seq_printf(m, " Serial Number: %s\n", serialstr);
         else if (ep->adapter_info[5] == 0xBB)
-                seq_printf(m,
-                           " Default Settings Used for EEPROM-less Adapter.\n");
+                seq_puts(m,
+                         " Default Settings Used for EEPROM-less Adapter.\n");
         else
-                seq_printf(m,
-                           " Serial Number Signature Not Present.\n");
+                seq_puts(m, " Serial Number Signature Not Present.\n");
 
         seq_printf(m,
                    " Host SCSI ID: %u, Host Queue Size: %u, Device Queue Size: %u\n",
@@ -3070,34 +3065,30 @@ static void asc_prt_asc_board_eeprom(struct seq_file *m, struct Scsi_Host *shost
         seq_printf(m,
                    " cntl 0x%x, no_scam 0x%x\n", ep->cntl, ep->no_scam);
 
-        seq_printf(m, " Target ID:           ");
+        seq_puts(m, " Target ID:           ");
         for (i = 0; i <= ASC_MAX_TID; i++)
                 seq_printf(m, " %d", i);
-        seq_printf(m, "\n");
 
-        seq_printf(m, " Disconnects:         ");
+        seq_puts(m, "\n Disconnects:         ");
         for (i = 0; i <= ASC_MAX_TID; i++)
                 seq_printf(m, " %c",
                            (ep->disc_enable & ADV_TID_TO_TIDMASK(i)) ? 'Y' : 'N');
-        seq_printf(m, "\n");
 
-        seq_printf(m, " Command Queuing:     ");
+        seq_puts(m, "\n Command Queuing:     ");
         for (i = 0; i <= ASC_MAX_TID; i++)
                 seq_printf(m, " %c",
                            (ep->use_cmd_qng & ADV_TID_TO_TIDMASK(i)) ? 'Y' : 'N');
-        seq_printf(m, "\n");
 
-        seq_printf(m, " Start Motor:         ");
+        seq_puts(m, "\n Start Motor:         ");
         for (i = 0; i <= ASC_MAX_TID; i++)
                 seq_printf(m, " %c",
                            (ep->start_motor & ADV_TID_TO_TIDMASK(i)) ? 'Y' : 'N');
-        seq_printf(m, "\n");
 
-        seq_printf(m, " Synchronous Transfer:");
+        seq_puts(m, "\n Synchronous Transfer:");
         for (i = 0; i <= ASC_MAX_TID; i++)
                 seq_printf(m, " %c",
                            (ep->init_sdtr & ADV_TID_TO_TIDMASK(i)) ? 'Y' : 'N');
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
 #ifdef CONFIG_ISA
         if (asc_dvc_varp->bus_type & ASC_IS_ISA) {
@@ -3151,7 +3142,7 @@ static void asc_prt_adv_board_eeprom(struct seq_file *m, struct Scsi_Host *shost
         if (asc_get_eeprom_string(wordp, serialstr) == ASC_TRUE)
                 seq_printf(m, " Serial Number: %s\n", serialstr);
         else
-                seq_printf(m, " Serial Number Signature Not Present.\n");
+                seq_puts(m, " Serial Number Signature Not Present.\n");
 
         if (adv_dvc_varp->chip_type == ADV_CHIP_ASC3550)
                 seq_printf(m,
@@ -3209,10 +3200,10 @@ static void asc_prt_adv_board_eeprom(struct seq_file *m, struct Scsi_Host *shost
                            ep_38C1600->termination_lvd, termstr,
                            ep_38C1600->bios_ctrl);
 
-        seq_printf(m, " Target ID:           ");
+        seq_puts(m, " Target ID:           ");
         for (i = 0; i <= ADV_MAX_TID; i++)
                 seq_printf(m, " %X", i);
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         if (adv_dvc_varp->chip_type == ADV_CHIP_ASC3550) {
                 word = ep_3550->disc_enable;
@@ -3221,11 +3212,11 @@ static void asc_prt_adv_board_eeprom(struct seq_file *m, struct Scsi_Host *shost
         } else {
                 word = ep_38C1600->disc_enable;
         }
-        seq_printf(m, " Disconnects:         ");
+        seq_puts(m, " Disconnects:         ");
         for (i = 0; i <= ADV_MAX_TID; i++)
                 seq_printf(m, " %c",
                            (word & ADV_TID_TO_TIDMASK(i)) ? 'Y' : 'N');
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         if (adv_dvc_varp->chip_type == ADV_CHIP_ASC3550) {
                 word = ep_3550->tagqng_able;
@@ -3234,11 +3225,11 @@ static void asc_prt_adv_board_eeprom(struct seq_file *m, struct Scsi_Host *shost
         } else {
                 word = ep_38C1600->tagqng_able;
         }
-        seq_printf(m, " Command Queuing:     ");
+        seq_puts(m, " Command Queuing:     ");
         for (i = 0; i <= ADV_MAX_TID; i++)
                 seq_printf(m, " %c",
                            (word & ADV_TID_TO_TIDMASK(i)) ? 'Y' : 'N');
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         if (adv_dvc_varp->chip_type == ADV_CHIP_ASC3550) {
                 word = ep_3550->start_motor;
@@ -3247,28 +3238,28 @@ static void asc_prt_adv_board_eeprom(struct seq_file *m, struct Scsi_Host *shost
         } else {
                 word = ep_38C1600->start_motor;
         }
-        seq_printf(m, " Start Motor:         ");
+        seq_puts(m, " Start Motor:         ");
         for (i = 0; i <= ADV_MAX_TID; i++)
                 seq_printf(m, " %c",
                            (word & ADV_TID_TO_TIDMASK(i)) ? 'Y' : 'N');
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         if (adv_dvc_varp->chip_type == ADV_CHIP_ASC3550) {
-                seq_printf(m, " Synchronous Transfer:");
+                seq_puts(m, " Synchronous Transfer:");
                 for (i = 0; i <= ADV_MAX_TID; i++)
                         seq_printf(m, " %c",
                                    (ep_3550->sdtr_able & ADV_TID_TO_TIDMASK(i)) ?
                                    'Y' : 'N');
-                seq_printf(m, "\n");
+                seq_putc(m, '\n');
         }
 
         if (adv_dvc_varp->chip_type == ADV_CHIP_ASC3550) {
-                seq_printf(m, " Ultra Transfer:      ");
+                seq_puts(m, " Ultra Transfer:      ");
                 for (i = 0; i <= ADV_MAX_TID; i++)
                         seq_printf(m, " %c",
                                    (ep_3550->ultra_able & ADV_TID_TO_TIDMASK(i))
                                    ? 'Y' : 'N');
-                seq_printf(m, "\n");
+                seq_putc(m, '\n');
         }
 
         if (adv_dvc_varp->chip_type == ADV_CHIP_ASC3550) {
@@ -3278,16 +3269,15 @@ static void asc_prt_adv_board_eeprom(struct seq_file *m, struct Scsi_Host *shost
         } else {
                 word = ep_38C1600->wdtr_able;
         }
-        seq_printf(m, " Wide Transfer:       ");
+        seq_puts(m, " Wide Transfer:       ");
         for (i = 0; i <= ADV_MAX_TID; i++)
                 seq_printf(m, " %c",
                            (word & ADV_TID_TO_TIDMASK(i)) ? 'Y' : 'N');
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         if (adv_dvc_varp->chip_type == ADV_CHIP_ASC38C0800 ||
             adv_dvc_varp->chip_type == ADV_CHIP_ASC38C1600) {
-                seq_printf(m,
-                           " Synchronous Transfer Speed (Mhz):\n  ");
+                seq_puts(m, " Synchronous Transfer Speed (Mhz):\n  ");
                 for (i = 0; i <= ADV_MAX_TID; i++) {
                         char *speed_str;
 
@@ -3325,10 +3315,10 @@ static void asc_prt_adv_board_eeprom(struct seq_file *m, struct Scsi_Host *shost
                         }
                         seq_printf(m, "%X:%s ", i, speed_str);
                         if (i == 7)
-                                seq_printf(m, "\n  ");
+                                seq_puts(m, "\n  ");
                         sdtr_speed >>= 4;
                 }
-                seq_printf(m, "\n");
+                seq_putc(m, '\n');
         }
 }
 
@@ -3403,7 +3393,7 @@ static void asc_prt_asc_board_info(struct seq_file *m, struct Scsi_Host *shost)
         seq_printf(m,
                    " Total Command Pending: %d\n", v->cur_total_qng);
 
-        seq_printf(m, " Command Queuing:");
+        seq_puts(m, " Command Queuing:");
         for (i = 0; i <= ASC_MAX_TID; i++) {
                 if ((chip_scsi_id == i) ||
                     ((boardp->init_tidmask & ADV_TID_TO_TIDMASK(i)) == 0)) {
@@ -3413,10 +3403,9 @@ static void asc_prt_asc_board_info(struct seq_file *m, struct Scsi_Host *shost)
                            i,
                            (v->use_tagged_qng & ADV_TID_TO_TIDMASK(i)) ? 'Y' : 'N');
         }
-        seq_printf(m, "\n");
 
         /* Current number of commands waiting for a device. */
-        seq_printf(m, " Command Queue Pending:");
+        seq_puts(m, "\n Command Queue Pending:");
         for (i = 0; i <= ASC_MAX_TID; i++) {
                 if ((chip_scsi_id == i) ||
                     ((boardp->init_tidmask & ADV_TID_TO_TIDMASK(i)) == 0)) {
@@ -3424,10 +3413,9 @@ static void asc_prt_asc_board_info(struct seq_file *m, struct Scsi_Host *shost)
                 }
                 seq_printf(m, " %X:%u", i, v->cur_dvc_qng[i]);
         }
-        seq_printf(m, "\n");
 
         /* Current limit on number of commands that can be sent to a device. */
-        seq_printf(m, " Command Queue Limit:");
+        seq_puts(m, "\n Command Queue Limit:");
         for (i = 0; i <= ASC_MAX_TID; i++) {
                 if ((chip_scsi_id == i) ||
                     ((boardp->init_tidmask & ADV_TID_TO_TIDMASK(i)) == 0)) {
@@ -3435,10 +3423,9 @@ static void asc_prt_asc_board_info(struct seq_file *m, struct Scsi_Host *shost)
                 }
                 seq_printf(m, " %X:%u", i, v->max_dvc_qng[i]);
         }
-        seq_printf(m, "\n");
 
         /* Indicate whether the device has returned queue full status. */
-        seq_printf(m, " Command Queue Full:");
+        seq_puts(m, "\n Command Queue Full:");
         for (i = 0; i <= ASC_MAX_TID; i++) {
                 if ((chip_scsi_id == i) ||
                     ((boardp->init_tidmask & ADV_TID_TO_TIDMASK(i)) == 0)) {
@@ -3450,9 +3437,8 @@ static void asc_prt_asc_board_info(struct seq_file *m, struct Scsi_Host *shost)
                 else
                         seq_printf(m, " %X:N", i);
         }
-        seq_printf(m, "\n");
 
-        seq_printf(m, " Synchronous Transfer:");
+        seq_puts(m, "\n Synchronous Transfer:");
         for (i = 0; i <= ASC_MAX_TID; i++) {
                 if ((chip_scsi_id == i) ||
                     ((boardp->init_tidmask & ADV_TID_TO_TIDMASK(i)) == 0)) {
@@ -3462,7 +3448,7 @@ static void asc_prt_asc_board_info(struct seq_file *m, struct Scsi_Host *shost)
                            i,
                            (v->sdtr_done & ADV_TID_TO_TIDMASK(i)) ? 'Y' : 'N');
         }
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         for (i = 0; i <= ASC_MAX_TID; i++) {
                 uchar syn_period_ix;
@@ -3476,7 +3462,7 @@ static void asc_prt_asc_board_info(struct seq_file *m, struct Scsi_Host *shost)
                 seq_printf(m, "  %X:", i);
 
                 if ((boardp->sdtr_data[i] & ASC_SYN_MAX_OFFSET) == 0) {
-                        seq_printf(m, " Asynchronous");
+                        seq_puts(m, " Asynchronous");
                 } else {
                         syn_period_ix =
                             (boardp->sdtr_data[i] >> 4) & (v->max_sdtr_index -
@@ -3494,16 +3480,15 @@ static void asc_prt_asc_board_info(struct seq_file *m, struct Scsi_Host *shost)
                 }
 
                 if ((v->sdtr_done & ADV_TID_TO_TIDMASK(i)) == 0) {
-                        seq_printf(m, "*\n");
+                        seq_puts(m, "*\n");
                         renegotiate = 1;
                 } else {
-                        seq_printf(m, "\n");
+                        seq_putc(m, '\n');
                 }
         }
 
         if (renegotiate) {
-                seq_printf(m,
-                           " * = Re-negotiation pending before next command.\n");
+                seq_puts(m, " * = Re-negotiation pending before next command.\n");
         }
 }
 
@@ -3548,7 +3533,7 @@ static void asc_prt_adv_board_info(struct seq_file *m, struct Scsi_Host *shost)
                    c->mcode_date, c->mcode_version);
 
         AdvReadWordLram(iop_base, ASC_MC_TAGQNG_ABLE, tagqng_able);
-        seq_printf(m, " Queuing Enabled:");
+        seq_puts(m, " Queuing Enabled:");
         for (i = 0; i <= ADV_MAX_TID; i++) {
                 if ((chip_scsi_id == i) ||
                     ((boardp->init_tidmask & ADV_TID_TO_TIDMASK(i)) == 0)) {
@@ -3559,9 +3544,8 @@ static void asc_prt_adv_board_info(struct seq_file *m, struct Scsi_Host *shost)
                            i,
                            (tagqng_able & ADV_TID_TO_TIDMASK(i)) ? 'Y' : 'N');
         }
-        seq_printf(m, "\n");
 
-        seq_printf(m, " Queue Limit:");
+        seq_puts(m, "\n Queue Limit:");
         for (i = 0; i <= ADV_MAX_TID; i++) {
                 if ((chip_scsi_id == i) ||
                     ((boardp->init_tidmask & ADV_TID_TO_TIDMASK(i)) == 0)) {
@@ -3573,9 +3557,8 @@ static void asc_prt_adv_board_info(struct seq_file *m, struct Scsi_Host *shost)
 
                 seq_printf(m, " %X:%d", i, lrambyte);
         }
-        seq_printf(m, "\n");
 
-        seq_printf(m, " Command Pending:");
+        seq_puts(m, "\n Command Pending:");
         for (i = 0; i <= ADV_MAX_TID; i++) {
                 if ((chip_scsi_id == i) ||
                     ((boardp->init_tidmask & ADV_TID_TO_TIDMASK(i)) == 0)) {
@@ -3587,10 +3570,10 @@ static void asc_prt_adv_board_info(struct seq_file *m, struct Scsi_Host *shost)
 
                 seq_printf(m, " %X:%d", i, lrambyte);
         }
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         AdvReadWordLram(iop_base, ASC_MC_WDTR_ABLE, wdtr_able);
-        seq_printf(m, " Wide Enabled:");
+        seq_puts(m, " Wide Enabled:");
         for (i = 0; i <= ADV_MAX_TID; i++) {
                 if ((chip_scsi_id == i) ||
                     ((boardp->init_tidmask & ADV_TID_TO_TIDMASK(i)) == 0)) {
@@ -3601,10 +3584,10 @@ static void asc_prt_adv_board_info(struct seq_file *m, struct Scsi_Host *shost)
                            i,
                            (wdtr_able & ADV_TID_TO_TIDMASK(i)) ? 'Y' : 'N');
         }
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         AdvReadWordLram(iop_base, ASC_MC_WDTR_DONE, wdtr_done);
-        seq_printf(m, " Transfer Bit Width:");
+        seq_puts(m, " Transfer Bit Width:");
         for (i = 0; i <= ADV_MAX_TID; i++) {
                 if ((chip_scsi_id == i) ||
                     ((boardp->init_tidmask & ADV_TID_TO_TIDMASK(i)) == 0)) {
@@ -3620,14 +3603,14 @@ static void asc_prt_adv_board_info(struct seq_file *m, struct Scsi_Host *shost)
 
                 if ((wdtr_able & ADV_TID_TO_TIDMASK(i)) &&
                     (wdtr_done & ADV_TID_TO_TIDMASK(i)) == 0) {
-                        seq_printf(m, "*");
+                        seq_putc(m, '*');
                         renegotiate = 1;
                 }
         }
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         AdvReadWordLram(iop_base, ASC_MC_SDTR_ABLE, sdtr_able);
-        seq_printf(m, " Synchronous Enabled:");
+        seq_puts(m, " Synchronous Enabled:");
         for (i = 0; i <= ADV_MAX_TID; i++) {
                 if ((chip_scsi_id == i) ||
                     ((boardp->init_tidmask & ADV_TID_TO_TIDMASK(i)) == 0)) {
@@ -3638,7 +3621,7 @@ static void asc_prt_adv_board_info(struct seq_file *m, struct Scsi_Host *shost)
                            i,
                            (sdtr_able & ADV_TID_TO_TIDMASK(i)) ? 'Y' : 'N');
         }
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         AdvReadWordLram(iop_base, ASC_MC_SDTR_DONE, sdtr_done);
         for (i = 0; i <= ADV_MAX_TID; i++) {
@@ -3657,14 +3640,14 @@ static void asc_prt_adv_board_info(struct seq_file *m, struct Scsi_Host *shost)
                 seq_printf(m, "  %X:", i);
 
                 if ((lramword & 0x1F) == 0) {   /* Check for REQ/ACK Offset 0. */
-                        seq_printf(m, " Asynchronous");
+                        seq_puts(m, " Asynchronous");
                 } else {
-                        seq_printf(m, " Transfer Period Factor: ");
+                        seq_puts(m, " Transfer Period Factor: ");
 
                         if ((lramword & 0x1F00) == 0x1100) {    /* 80 Mhz */
-                                seq_printf(m, "9 (80.0 Mhz),");
+                                seq_puts(m, "9 (80.0 Mhz),");
                         } else if ((lramword & 0x1F00) == 0x1000) {     /* 40 Mhz */
-                                seq_printf(m, "10 (40.0 Mhz),");
+                                seq_puts(m, "10 (40.0 Mhz),");
                         } else {        /* 20 Mhz or below. */
 
                                 period = (((lramword >> 8) * 25) + 50) / 4;
@@ -3684,16 +3667,15 @@ static void asc_prt_adv_board_info(struct seq_file *m, struct Scsi_Host *shost)
                 }
 
                 if ((sdtr_done & ADV_TID_TO_TIDMASK(i)) == 0) {
-                        seq_printf(m, "*\n");
+                        seq_puts(m, "*\n");
                         renegotiate = 1;
                 } else {
-                        seq_printf(m, "\n");
+                        seq_putc(m, '\n');
                 }
         }
 
         if (renegotiate) {
-                seq_printf(m,
-                           " * = Re-negotiation pending before next command.\n");
+                seq_puts(m, " * = Re-negotiation pending before next command.\n");
         }
 }
 
diff --git a/drivers/scsi/aha152x.c b/drivers/scsi/aha152x.c
index 2b960b326daf..e31c460a1335 100644
--- a/drivers/scsi/aha152x.c
+++ b/drivers/scsi/aha152x.c
@@ -2490,299 +2490,296 @@ static void show_queues(struct Scsi_Host *shpnt)
         disp_enintr(shpnt);
 }
 
-#undef SPRINTF
-#define SPRINTF(args...) seq_printf(m, ##args)
-
 static void get_command(struct seq_file *m, Scsi_Cmnd * ptr)
 {
         int i;
 
-        SPRINTF("%p: target=%d; lun=%d; cmnd=( ",
+        seq_printf(m, "%p: target=%d; lun=%d; cmnd=( ",
                 ptr, ptr->device->id, (u8)ptr->device->lun);
 
         for (i = 0; i < COMMAND_SIZE(ptr->cmnd[0]); i++)
-                SPRINTF("0x%02x ", ptr->cmnd[i]);
+                seq_printf(m, "0x%02x ", ptr->cmnd[i]);
 
-        SPRINTF("); resid=%d; residual=%d; buffers=%d; phase |",
+        seq_printf(m, "); resid=%d; residual=%d; buffers=%d; phase |",
                 scsi_get_resid(ptr), ptr->SCp.this_residual,
                 ptr->SCp.buffers_residual);
 
         if (ptr->SCp.phase & not_issued)
-                SPRINTF("not issued|");
+                seq_puts(m, "not issued|");
         if (ptr->SCp.phase & selecting)
-                SPRINTF("selecting|");
+                seq_puts(m, "selecting|");
         if (ptr->SCp.phase & disconnected)
-                SPRINTF("disconnected|");
+                seq_puts(m, "disconnected|");
         if (ptr->SCp.phase & aborted)
-                SPRINTF("aborted|");
+                seq_puts(m, "aborted|");
         if (ptr->SCp.phase & identified)
-                SPRINTF("identified|");
+                seq_puts(m, "identified|");
         if (ptr->SCp.phase & completed)
-                SPRINTF("completed|");
+                seq_puts(m, "completed|");
         if (ptr->SCp.phase & spiordy)
-                SPRINTF("spiordy|");
+                seq_puts(m, "spiordy|");
         if (ptr->SCp.phase & syncneg)
-                SPRINTF("syncneg|");
-        SPRINTF("; next=0x%p\n", SCNEXT(ptr));
+                seq_puts(m, "syncneg|");
+        seq_printf(m, "; next=0x%p\n", SCNEXT(ptr));
 }
 
 static void get_ports(struct seq_file *m, struct Scsi_Host *shpnt)
 {
         int s;
 
-        SPRINTF("\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
+        seq_printf(m, "\n%s: %s(%s) ", CURRENT_SC ? "on bus" : "waiting", states[STATE].name, states[PREVSTATE].name);
 
         s = GETPORT(SCSISEQ);
-        SPRINTF("SCSISEQ( ");
+        seq_puts(m, "SCSISEQ( ");
         if (s & TEMODEO)
-                SPRINTF("TARGET MODE ");
+                seq_puts(m, "TARGET MODE ");
         if (s & ENSELO)
-                SPRINTF("SELO ");
+                seq_puts(m, "SELO ");
         if (s & ENSELI)
-                SPRINTF("SELI ");
+                seq_puts(m, "SELI ");
         if (s & ENRESELI)
-                SPRINTF("RESELI ");
+                seq_puts(m, "RESELI ");
         if (s & ENAUTOATNO)
-                SPRINTF("AUTOATNO ");
+                seq_puts(m, "AUTOATNO ");
         if (s & ENAUTOATNI)
-                SPRINTF("AUTOATNI ");
+                seq_puts(m, "AUTOATNI ");
         if (s & ENAUTOATNP)
-                SPRINTF("AUTOATNP ");
+                seq_puts(m, "AUTOATNP ");
         if (s & SCSIRSTO)
-                SPRINTF("SCSIRSTO ");
-        SPRINTF(");");
+                seq_puts(m, "SCSIRSTO ");
+        seq_puts(m, ");");
 
-        SPRINTF(" SCSISIG(");
+        seq_puts(m, " SCSISIG(");
         s = GETPORT(SCSISIG);
         switch (s & P_MASK) {
         case P_DATAO:
-                SPRINTF("DATA OUT");
+                seq_puts(m, "DATA OUT");
                 break;
         case P_DATAI:
-                SPRINTF("DATA IN");
+                seq_puts(m, "DATA IN");
                 break;
         case P_CMD:
-                SPRINTF("COMMAND");
+                seq_puts(m, "COMMAND");
                 break;
         case P_STATUS:
-                SPRINTF("STATUS");
+                seq_puts(m, "STATUS");
                 break;
         case P_MSGO:
-                SPRINTF("MESSAGE OUT");
+                seq_puts(m, "MESSAGE OUT");
                 break;
         case P_MSGI:
-                SPRINTF("MESSAGE IN");
+                seq_puts(m, "MESSAGE IN");
                 break;
         default:
-                SPRINTF("*invalid*");
+                seq_puts(m, "*invalid*");
                 break;
         }
 
-        SPRINTF("); ");
+        seq_puts(m, "); ");
 
-        SPRINTF("INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
+        seq_printf(m, "INTSTAT (%s); ", TESTHI(DMASTAT, INTSTAT) ? "hi" : "lo");
 
-        SPRINTF("SSTAT( ");
+        seq_puts(m, "SSTAT( ");
         s = GETPORT(SSTAT0);
         if (s & TARGET)
-                SPRINTF("TARGET ");
+                seq_puts(m, "TARGET ");
         if (s & SELDO)
-                SPRINTF("SELDO ");
+                seq_puts(m, "SELDO ");
         if (s & SELDI)
-                SPRINTF("SELDI ");
+                seq_puts(m, "SELDI ");
         if (s & SELINGO)
-                SPRINTF("SELINGO ");
+                seq_puts(m, "SELINGO ");
         if (s & SWRAP)
-                SPRINTF("SWRAP ");
+                seq_puts(m, "SWRAP ");
         if (s & SDONE)
-                SPRINTF("SDONE ");
+                seq_puts(m, "SDONE ");
         if (s & SPIORDY)
-                SPRINTF("SPIORDY ");
+                seq_puts(m, "SPIORDY ");
         if (s & DMADONE)
-                SPRINTF("DMADONE ");
+                seq_puts(m, "DMADONE ");
 
         s = GETPORT(SSTAT1);
         if (s & SELTO)
-                SPRINTF("SELTO ");
+                seq_puts(m, "SELTO ");
         if (s & ATNTARG)
-                SPRINTF("ATNTARG ");
+                seq_puts(m, "ATNTARG ");
         if (s & SCSIRSTI)
-                SPRINTF("SCSIRSTI ");
+                seq_puts(m, "SCSIRSTI ");
         if (s & PHASEMIS)
-                SPRINTF("PHASEMIS ");
+                seq_puts(m, "PHASEMIS ");
         if (s & BUSFREE)
-                SPRINTF("BUSFREE ");
+                seq_puts(m, "BUSFREE ");
         if (s & SCSIPERR)
-                SPRINTF("SCSIPERR ");
+                seq_puts(m, "SCSIPERR ");
         if (s & PHASECHG)
-                SPRINTF("PHASECHG ");
+                seq_puts(m, "PHASECHG ");
         if (s & REQINIT)
-                SPRINTF("REQINIT ");
-        SPRINTF("); ");
+                seq_puts(m, "REQINIT ");
+        seq_puts(m, "); ");
 
 
-        SPRINTF("SSTAT( ");
+        seq_puts(m, "SSTAT( ");
 
         s = GETPORT(SSTAT0) & GETPORT(SIMODE0);
 
         if (s & TARGET)
-                SPRINTF("TARGET ");
+                seq_puts(m, "TARGET ");
         if (s & SELDO)
-                SPRINTF("SELDO ");
+                seq_puts(m, "SELDO ");
         if (s & SELDI)
-                SPRINTF("SELDI ");
+                seq_puts(m, "SELDI ");
         if (s & SELINGO)
-                SPRINTF("SELINGO ");
+                seq_puts(m, "SELINGO ");
         if (s & SWRAP)
-                SPRINTF("SWRAP ");
+                seq_puts(m, "SWRAP ");
         if (s & SDONE)
-                SPRINTF("SDONE ");
+                seq_puts(m, "SDONE ");
         if (s & SPIORDY)
-                SPRINTF("SPIORDY ");
+                seq_puts(m, "SPIORDY ");
         if (s & DMADONE)
-                SPRINTF("DMADONE ");
+                seq_puts(m, "DMADONE ");
 
         s = GETPORT(SSTAT1) & GETPORT(SIMODE1);
 
         if (s & SELTO)
-                SPRINTF("SELTO ");
+                seq_puts(m, "SELTO ");
         if (s & ATNTARG)
-                SPRINTF("ATNTARG ");
+                seq_puts(m, "ATNTARG ");
         if (s & SCSIRSTI)
-                SPRINTF("SCSIRSTI ");
+                seq_puts(m, "SCSIRSTI ");
         if (s & PHASEMIS)
-                SPRINTF("PHASEMIS ");
+                seq_puts(m, "PHASEMIS ");
         if (s & BUSFREE)
-                SPRINTF("BUSFREE ");
+                seq_puts(m, "BUSFREE ");
         if (s & SCSIPERR)
-                SPRINTF("SCSIPERR ");
+                seq_puts(m, "SCSIPERR ");
         if (s & PHASECHG)
-                SPRINTF("PHASECHG ");
+                seq_puts(m, "PHASECHG ");
         if (s & REQINIT)
-                SPRINTF("REQINIT ");
-        SPRINTF("); ");
+                seq_puts(m, "REQINIT ");
+        seq_puts(m, "); ");
 
-        SPRINTF("SXFRCTL0( ");
+        seq_puts(m, "SXFRCTL0( ");
 
         s = GETPORT(SXFRCTL0);
         if (s & SCSIEN)
-                SPRINTF("SCSIEN ");
+                seq_puts(m, "SCSIEN ");
         if (s & DMAEN)
-                SPRINTF("DMAEN ");
+                seq_puts(m, "DMAEN ");
         if (s & CH1)
-                SPRINTF("CH1 ");
+                seq_puts(m, "CH1 ");
         if (s & CLRSTCNT)
-                SPRINTF("CLRSTCNT ");
+                seq_puts(m, "CLRSTCNT ");
         if (s & SPIOEN)
-                SPRINTF("SPIOEN ");
+                seq_puts(m, "SPIOEN ");
         if (s & CLRCH1)
-                SPRINTF("CLRCH1 ");
-        SPRINTF("); ");
+                seq_puts(m, "CLRCH1 ");
+        seq_puts(m, "); ");
 
-        SPRINTF("SIGNAL( ");
+        seq_puts(m, "SIGNAL( ");
 
         s = GETPORT(SCSISIG);
         if (s & SIG_ATNI)
-                SPRINTF("ATNI ");
+                seq_puts(m, "ATNI ");
         if (s & SIG_SELI)
-                SPRINTF("SELI ");
+                seq_puts(m, "SELI ");
         if (s & SIG_BSYI)
-                SPRINTF("BSYI ");
+                seq_puts(m, "BSYI ");
         if (s & SIG_REQI)
-                SPRINTF("REQI ");
+                seq_puts(m, "REQI ");
         if (s & SIG_ACKI)
-                SPRINTF("ACKI ");
-        SPRINTF("); ");
+                seq_puts(m, "ACKI ");
+        seq_puts(m, "); ");
 
-        SPRINTF("SELID(%02x), ", GETPORT(SELID));
+        seq_printf(m, "SELID(%02x), ", GETPORT(SELID));
 
-        SPRINTF("STCNT(%d), ", GETSTCNT());
+        seq_printf(m, "STCNT(%d), ", GETSTCNT());
 
-        SPRINTF("SSTAT2( ");
+        seq_puts(m, "SSTAT2( ");
 
         s = GETPORT(SSTAT2);
         if (s & SOFFSET)
-                SPRINTF("SOFFSET ");
+                seq_puts(m, "SOFFSET ");
         if (s & SEMPTY)
-                SPRINTF("SEMPTY ");
+                seq_puts(m, "SEMPTY ");
         if (s & SFULL)
-                SPRINTF("SFULL ");
-        SPRINTF("); SFCNT (%d); ", s & (SFULL | SFCNT));
+                seq_puts(m, "SFULL ");
+        seq_printf(m, "); SFCNT (%d); ", s & (SFULL | SFCNT));
 
         s = GETPORT(SSTAT3);
-        SPRINTF("SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
+        seq_printf(m, "SCSICNT (%d), OFFCNT(%d), ", (s & 0xf0) >> 4, s & 0x0f);
 
-        SPRINTF("SSTAT4( ");
+        seq_puts(m, "SSTAT4( ");
         s = GETPORT(SSTAT4);
         if (s & SYNCERR)
-                SPRINTF("SYNCERR ");
+                seq_puts(m, "SYNCERR ");
         if (s & FWERR)
-                SPRINTF("FWERR ");
+                seq_puts(m, "FWERR ");
         if (s & FRERR)
-                SPRINTF("FRERR ");
-        SPRINTF("); ");
+                seq_puts(m, "FRERR ");
+        seq_puts(m, "); ");
 
-        SPRINTF("DMACNTRL0( ");
+        seq_puts(m, "DMACNTRL0( ");
         s = GETPORT(DMACNTRL0);
-        SPRINTF("%s ", s & _8BIT ? "8BIT" : "16BIT");
-        SPRINTF("%s ", s & DMA ? "DMA" : "PIO");
-        SPRINTF("%s ", s & WRITE_READ ? "WRITE" : "READ");
+        seq_printf(m, "%s ", s & _8BIT ? "8BIT" : "16BIT");
+        seq_printf(m, "%s ", s & DMA ? "DMA" : "PIO");
+        seq_printf(m, "%s ", s & WRITE_READ ? "WRITE" : "READ");
         if (s & ENDMA)
-                SPRINTF("ENDMA ");
+                seq_puts(m, "ENDMA ");
         if (s & INTEN)
-                SPRINTF("INTEN ");
+                seq_puts(m, "INTEN ");
         if (s & RSTFIFO)
-                SPRINTF("RSTFIFO ");
+                seq_puts(m, "RSTFIFO ");
         if (s & SWINT)
-                SPRINTF("SWINT ");
-        SPRINTF("); ");
+                seq_puts(m, "SWINT ");
+        seq_puts(m, "); ");
 
-        SPRINTF("DMASTAT( ");
+        seq_puts(m, "DMASTAT( ");
         s = GETPORT(DMASTAT);
         if (s & ATDONE)
-                SPRINTF("ATDONE ");
+                seq_puts(m, "ATDONE ");
         if (s & WORDRDY)
-                SPRINTF("WORDRDY ");
+                seq_puts(m, "WORDRDY ");
         if (s & DFIFOFULL)
-                SPRINTF("DFIFOFULL ");
+                seq_puts(m, "DFIFOFULL ");
         if (s & DFIFOEMP)
-                SPRINTF("DFIFOEMP ");
-        SPRINTF(")\n");
+                seq_puts(m, "DFIFOEMP ");
+        seq_puts(m, ")\n");
 
-        SPRINTF("enabled interrupts( ");
+        seq_puts(m, "enabled interrupts( ");
 
         s = GETPORT(SIMODE0);
         if (s & ENSELDO)
-                SPRINTF("ENSELDO ");
+                seq_puts(m, "ENSELDO ");
         if (s & ENSELDI)
-                SPRINTF("ENSELDI ");
+                seq_puts(m, "ENSELDI ");
         if (s & ENSELINGO)
-                SPRINTF("ENSELINGO ");
+                seq_puts(m, "ENSELINGO ");
         if (s & ENSWRAP)
-                SPRINTF("ENSWRAP ");
+                seq_puts(m, "ENSWRAP ");
         if (s & ENSDONE)
-                SPRINTF("ENSDONE ");
+                seq_puts(m, "ENSDONE ");
         if (s & ENSPIORDY)
-                SPRINTF("ENSPIORDY ");
+                seq_puts(m, "ENSPIORDY ");
         if (s & ENDMADONE)
-                SPRINTF("ENDMADONE ");
+                seq_puts(m, "ENDMADONE ");
 
         s = GETPORT(SIMODE1);
         if (s & ENSELTIMO)
-                SPRINTF("ENSELTIMO ");
+                seq_puts(m, "ENSELTIMO ");
         if (s & ENATNTARG)
-                SPRINTF("ENATNTARG ");
+                seq_puts(m, "ENATNTARG ");
         if (s & ENPHASEMIS)
-                SPRINTF("ENPHASEMIS ");
+                seq_puts(m, "ENPHASEMIS ");
         if (s & ENBUSFREE)
-                SPRINTF("ENBUSFREE ");
+                seq_puts(m, "ENBUSFREE ");
         if (s & ENSCSIPERR)
-                SPRINTF("ENSCSIPERR ");
+                seq_puts(m, "ENSCSIPERR ");
         if (s & ENPHASECHG)
-                SPRINTF("ENPHASECHG ");
+                seq_puts(m, "ENPHASECHG ");
         if (s & ENREQINIT)
-                SPRINTF("ENREQINIT ");
-        SPRINTF(")\n");
+                seq_puts(m, "ENREQINIT ");
+        seq_puts(m, ")\n");
 }
 
 static int aha152x_set_info(struct Scsi_Host *shpnt, char *buffer, int length)
@@ -2825,56 +2822,56 @@ static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
         Scsi_Cmnd *ptr;
         unsigned long flags;
 
-        SPRINTF(AHA152X_REVID "\n");
+        seq_puts(m, AHA152X_REVID "\n");
 
-        SPRINTF("ioports 0x%04lx to 0x%04lx\n",
+        seq_printf(m, "ioports 0x%04lx to 0x%04lx\n",
                 shpnt->io_port, shpnt->io_port + shpnt->n_io_port - 1);
-        SPRINTF("interrupt 0x%02x\n", shpnt->irq);
-        SPRINTF("disconnection/reconnection %s\n",
+        seq_printf(m, "interrupt 0x%02x\n", shpnt->irq);
+        seq_printf(m, "disconnection/reconnection %s\n",
                 RECONNECT ? "enabled" : "disabled");
-        SPRINTF("parity checking %s\n",
+        seq_printf(m, "parity checking %s\n",
                 PARITY ? "enabled" : "disabled");
-        SPRINTF("synchronous transfers %s\n",
+        seq_printf(m, "synchronous transfers %s\n",
                 SYNCHRONOUS ? "enabled" : "disabled");
-        SPRINTF("%d commands currently queued\n", HOSTDATA(shpnt)->commands);
+        seq_printf(m, "%d commands currently queued\n", HOSTDATA(shpnt)->commands);
 
         if(SYNCHRONOUS) {
-                SPRINTF("synchronously operating targets (tick=50 ns):\n");
+                seq_puts(m, "synchronously operating targets (tick=50 ns):\n");
                 for (i = 0; i < 8; i++)
                         if (HOSTDATA(shpnt)->syncrate[i] & 0x7f)
-                                SPRINTF("target %d: period %dT/%dns; req/ack offset %d\n",
+                                seq_printf(m, "target %d: period %dT/%dns; req/ack offset %d\n",
                                         i,
                                         (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2),
                                         (((HOSTDATA(shpnt)->syncrate[i] & 0x70) >> 4) + 2) * 50,
                                     HOSTDATA(shpnt)->syncrate[i] & 0x0f);
         }
-        SPRINTF("\nqueue status:\n");
+        seq_puts(m, "\nqueue status:\n");
         DO_LOCK(flags);
         if (ISSUE_SC) {
-                SPRINTF("not yet issued commands:\n");
+                seq_puts(m, "not yet issued commands:\n");
                 for (ptr = ISSUE_SC; ptr; ptr = SCNEXT(ptr))
                         get_command(m, ptr);
         } else
-                SPRINTF("no not yet issued commands\n");
+                seq_puts(m, "no not yet issued commands\n");
         DO_UNLOCK(flags);
 
         if (CURRENT_SC) {
-                SPRINTF("current command:\n");
+                seq_puts(m, "current command:\n");
                 get_command(m, CURRENT_SC);
         } else
-                SPRINTF("no current command\n");
+                seq_puts(m, "no current command\n");
 
         if (DISCONNECTED_SC) {
-                SPRINTF("disconnected commands:\n");
+                seq_puts(m, "disconnected commands:\n");
                 for (ptr = DISCONNECTED_SC; ptr; ptr = SCNEXT(ptr))
                         get_command(m, ptr);
         } else
-                SPRINTF("no disconnected commands\n");
+                seq_puts(m, "no disconnected commands\n");
 
         get_ports(m, shpnt);
 
 #if defined(AHA152X_STAT)
-        SPRINTF("statistics:\n"
+        seq_printf(m, "statistics:\n"
                 "total commands:               %d\n"
                 "disconnections:               %d\n"
                 "busfree with check condition: %d\n"
@@ -2894,7 +2891,7 @@ static int aha152x_show_info(struct seq_file *m, struct Scsi_Host *shpnt)
                 HOSTDATA(shpnt)->busfree_without_done_command,
                 HOSTDATA(shpnt)->busfree_without_any_action);
         for(i=0; i<maxstate; i++) {
-                SPRINTF("%-10s %-12d %-12d %-12ld\n",
+                seq_printf(m, "%-10s %-12d %-12d %-12ld\n",
                         states[i].name,
                         HOSTDATA(shpnt)->count_trans[i],
                         HOSTDATA(shpnt)->count[i],
diff --git a/drivers/scsi/aic7xxx/aic79xx_core.c b/drivers/scsi/aic7xxx/aic79xx_core.c
index 0bcacf71aef8..97f2accd3dbb 100644
--- a/drivers/scsi/aic7xxx/aic79xx_core.c
+++ b/drivers/scsi/aic7xxx/aic79xx_core.c
@@ -1298,7 +1298,7 @@ rescan_fifos:
 
         /*
          * Wait for any inprogress DMA to complete and clear DMA state
-         * if this if for an SCB in the qinfifo.
+         * if this is for an SCB in the qinfifo.
          */
         while (((ccscbctl = ahd_inb(ahd, CCSCBCTL)) & (CCARREN|CCSCBEN)) != 0) {
 
diff --git a/drivers/scsi/aic7xxx/aic79xx_proc.c b/drivers/scsi/aic7xxx/aic79xx_proc.c
index 27dbfccea774..add2da581d66 100644
--- a/drivers/scsi/aic7xxx/aic79xx_proc.c
+++ b/drivers/scsi/aic7xxx/aic79xx_proc.c
@@ -97,7 +97,7 @@ ahd_format_transinfo(struct seq_file *m, struct ahd_transinfo *tinfo)
         u_int mb;
 
         if (tinfo->period == AHD_PERIOD_UNKNOWN) {
-                seq_printf(m, "Renegotiation Pending\n");
+                seq_puts(m, "Renegotiation Pending\n");
                 return;
         }
         speed = 3300;
@@ -119,40 +119,38 @@ ahd_format_transinfo(struct seq_file *m, struct ahd_transinfo *tinfo)
                 printed_options = 0;
                 seq_printf(m, " (%d.%03dMHz", freq / 1000, freq % 1000);
                 if ((tinfo->ppr_options & MSG_EXT_PPR_RD_STRM) != 0) {
-                        seq_printf(m, " RDSTRM");
+                        seq_puts(m, " RDSTRM");
                         printed_options++;
                 }
                 if ((tinfo->ppr_options & MSG_EXT_PPR_DT_REQ) != 0) {
-                        seq_printf(m, "%s", printed_options ? "|DT" : " DT");
+                        seq_puts(m, printed_options ? "|DT" : " DT");
                         printed_options++;
                 }
                 if ((tinfo->ppr_options & MSG_EXT_PPR_IU_REQ) != 0) {
-                        seq_printf(m, "%s", printed_options ? "|IU" : " IU");
+                        seq_puts(m, printed_options ? "|IU" : " IU");
                         printed_options++;
                 }
                 if ((tinfo->ppr_options & MSG_EXT_PPR_RTI) != 0) {
-                        seq_printf(m, "%s",
-                                  printed_options ? "|RTI" : " RTI");
+                        seq_puts(m, printed_options ? "|RTI" : " RTI");
                         printed_options++;
                 }
                 if ((tinfo->ppr_options & MSG_EXT_PPR_QAS_REQ) != 0) {
-                        seq_printf(m, "%s",
-                                  printed_options ? "|QAS" : " QAS");
+                        seq_puts(m, printed_options ? "|QAS" : " QAS");
                         printed_options++;
                 }
         }
 
         if (tinfo->width > 0) {
                 if (freq != 0) {
-                        seq_printf(m, ", ");
+                        seq_puts(m, ", ");
                 } else {
-                        seq_printf(m, " (");
+                        seq_puts(m, " (");
                 }
                 seq_printf(m, "%dbit)", 8 * (0x01 << tinfo->width));
         } else if (freq != 0) {
-                seq_printf(m, ")");
+                seq_putc(m, ')');
         }
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 }
 
 static void
@@ -167,15 +165,15 @@ ahd_dump_target_state(struct ahd_softc *ahd, struct seq_file *m,
         tinfo = ahd_fetch_transinfo(ahd, channel, our_id,
                                     target_id, &tstate);
         seq_printf(m, "Target %d Negotiation Settings\n", target_id);
-        seq_printf(m, "\tUser: ");
+        seq_puts(m, "\tUser: ");
         ahd_format_transinfo(m, &tinfo->user);
         starget = ahd->platform_data->starget[target_id];
         if (starget == NULL)
                 return;
 
-        seq_printf(m, "\tGoal: ");
+        seq_puts(m, "\tGoal: ");
         ahd_format_transinfo(m, &tinfo->goal);
-        seq_printf(m, "\tCurr: ");
+        seq_puts(m, "\tCurr: ");
         ahd_format_transinfo(m, &tinfo->curr);
 
         for (lun = 0; lun < AHD_NUM_LUNS; lun++) {
@@ -291,19 +289,19 @@ ahd_linux_show_info(struct seq_file *m, struct Scsi_Host *shost)
         max_targ = 16;
 
         if (ahd->seep_config == NULL)
-                seq_printf(m, "No Serial EEPROM\n");
+                seq_puts(m, "No Serial EEPROM\n");
         else {
-                seq_printf(m, "Serial EEPROM:\n");
+                seq_puts(m, "Serial EEPROM:\n");
                 for (i = 0; i < sizeof(*ahd->seep_config)/2; i++) {
                         if (((i % 8) == 0) && (i != 0)) {
-                                seq_printf(m, "\n");
+                                seq_putc(m, '\n');
                         }
                         seq_printf(m, "0x%.4x ",
                                   ((uint16_t*)ahd->seep_config)[i]);
                 }
-                seq_printf(m, "\n");
+                seq_putc(m, '\n');
         }
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         if ((ahd->features & AHD_WIDE) == 0)
                 max_targ = 8;
diff --git a/drivers/scsi/aic7xxx/aic7xxx_proc.c b/drivers/scsi/aic7xxx/aic7xxx_proc.c
index 64eec6c07a83..18459605d991 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_proc.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_proc.c
@@ -119,15 +119,15 @@ ahc_format_transinfo(struct seq_file *m, struct ahc_transinfo *tinfo)
 
         if (tinfo->width > 0) {
                 if (freq != 0) {
-                        seq_printf(m, ", ");
+                        seq_puts(m, ", ");
                 } else {
-                        seq_printf(m, " (");
+                        seq_puts(m, " (");
                 }
                 seq_printf(m, "%dbit)", 8 * (0x01 << tinfo->width));
         } else if (freq != 0) {
-                seq_printf(m, ")");
+                seq_putc(m, ')');
         }
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 }
 
 static void
@@ -145,15 +145,15 @@ ahc_dump_target_state(struct ahc_softc *ahc, struct seq_file *m,
         if ((ahc->features & AHC_TWIN) != 0)
                 seq_printf(m, "Channel %c ", channel);
         seq_printf(m, "Target %d Negotiation Settings\n", target_id);
-        seq_printf(m, "\tUser: ");
+        seq_puts(m, "\tUser: ");
         ahc_format_transinfo(m, &tinfo->user);
         starget = ahc->platform_data->starget[target_offset];
         if (!starget)
                 return;
 
-        seq_printf(m, "\tGoal: ");
+        seq_puts(m, "\tGoal: ");
         ahc_format_transinfo(m, &tinfo->goal);
-        seq_printf(m, "\tCurr: ");
+        seq_puts(m, "\tCurr: ");
         ahc_format_transinfo(m, &tinfo->curr);
 
         for (lun = 0; lun < AHC_NUM_LUNS; lun++) {
@@ -303,19 +303,19 @@ ahc_linux_show_info(struct seq_file *m, struct Scsi_Host *shost)
 
 
         if (ahc->seep_config == NULL)
-                seq_printf(m, "No Serial EEPROM\n");
+                seq_puts(m, "No Serial EEPROM\n");
         else {
-                seq_printf(m, "Serial EEPROM:\n");
+                seq_puts(m, "Serial EEPROM:\n");
                 for (i = 0; i < sizeof(*ahc->seep_config)/2; i++) {
                         if (((i % 8) == 0) && (i != 0)) {
-                                seq_printf(m, "\n");
+                                seq_putc(m, '\n');
                         }
                         seq_printf(m, "0x%.4x ",
                                   ((uint16_t*)ahc->seep_config)[i]);
                 }
-                seq_printf(m, "\n");
+                seq_putc(m, '\n');
         }
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         max_targ = 16;
         if ((ahc->features & (AHC_WIDE|AHC_TWIN)) == 0)
diff --git a/drivers/scsi/am53c974.c b/drivers/scsi/am53c974.c
index aa3e2c7cd83c..a6f5ee80fadc 100644
--- a/drivers/scsi/am53c974.c
+++ b/drivers/scsi/am53c974.c
@@ -178,12 +178,6 @@ static void pci_esp_dma_drain(struct esp *esp)
                         break;
                 cpu_relax();
         }
-        if (resid > 1) {
-                /* FIFO not cleared */
-                shost_printk(KERN_INFO, esp->host,
-                             "FIFO not cleared, %d bytes left\n",
-                             resid);
-        }
 
         /*
          * When there is a residual BCMPLT will never be set
diff --git a/drivers/scsi/arm/fas216.c b/drivers/scsi/arm/fas216.c
index e64c3af7c1a0..decdc71b6b86 100644
--- a/drivers/scsi/arm/fas216.c
+++ b/drivers/scsi/arm/fas216.c
@@ -2990,7 +2990,7 @@ void fas216_print_devices(FAS216_Info *info, struct seq_file *m)
         struct fas216_device *dev;
         struct scsi_device *scd;
 
-        seq_printf(m, "Device/Lun TaggedQ       Parity   Sync\n");
+        seq_puts(m, "Device/Lun TaggedQ       Parity   Sync\n");
 
         shost_for_each_device(scd, info->host) {
                 dev = &info->device[scd->id];
@@ -3000,7 +3000,7 @@ void fas216_print_devices(FAS216_Info *info, struct seq_file *m)
                                      scd->simple_tags ? "en" : "dis",
                                      scd->current_tag);
                 else
-                        seq_printf(m, "unsupported   ");
+                        seq_puts(m, "unsupported   ");
 
                 seq_printf(m, "%3sabled ", dev->parity_enabled ? "en" : "dis");
 
@@ -3008,7 +3008,7 @@ void fas216_print_devices(FAS216_Info *info, struct seq_file *m)
                         seq_printf(m, "offset %d, %d ns\n",
                                      dev->sof, dev->period * 4);
                 else
-                        seq_printf(m, "async\n");
+                        seq_puts(m, "async\n");
         }
 }
 
diff --git a/drivers/scsi/atari_NCR5380.c b/drivers/scsi/atari_NCR5380.c
index 6daed6b386d4..a70255413e7f 100644
--- a/drivers/scsi/atari_NCR5380.c
+++ b/drivers/scsi/atari_NCR5380.c
@@ -711,12 +711,12 @@ static void show_Scsi_Cmnd(struct scsi_cmnd *cmd, struct seq_file *m)
         unsigned char *command;
         seq_printf(m, "scsi%d: destination target %d, lun %llu\n",
                 H_NO(cmd), cmd->device->id, cmd->device->lun);
-        seq_printf(m, "        command = ");
+        seq_puts(m, "        command = ");
         command = cmd->cmnd;
         seq_printf(m, "%2d (0x%02x)", command[0], command[0]);
         for (i = 1, s = COMMAND_SIZE(command[0]); i < s; ++i)
                 seq_printf(m, " %02x", command[i]);
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 }
 
 static int __maybe_unused NCR5380_show_info(struct seq_file *m,
diff --git a/drivers/scsi/atp870u.c b/drivers/scsi/atp870u.c
index a795d81ef875..0836433e3a2d 100644
--- a/drivers/scsi/atp870u.c
+++ b/drivers/scsi/atp870u.c
@@ -3101,9 +3101,8 @@ static const char *atp870u_info(struct Scsi_Host *notused)
 
 static int atp870u_show_info(struct seq_file *m, struct Scsi_Host *HBAptr)
 {
-        seq_printf(m, "ACARD AEC-671X Driver Version: 2.6+ac\n");
-        seq_printf(m, "\n");
-        seq_printf(m, "Adapter Configuration:\n");
+        seq_puts(m, "ACARD AEC-671X Driver Version: 2.6+ac\n\n"
+                "Adapter Configuration:\n");
         seq_printf(m, "               Base IO: %#.4lx\n", HBAptr->io_port);
         seq_printf(m, "                   IRQ: %d\n", HBAptr->irq);
         return 0;
diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index f3193406776c..a7cc61837818 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -48,7 +48,6 @@ static unsigned int be_iopoll_budget = 10;
 static unsigned int be_max_phys_size = 64;
 static unsigned int enable_msix = 1;
 
-MODULE_DEVICE_TABLE(pci, beiscsi_pci_id_table);
 MODULE_DESCRIPTION(DRV_DESC " " BUILD_STR);
 MODULE_VERSION(BUILD_STR);
 MODULE_AUTHOR("Emulex Corporation");
@@ -586,7 +585,6 @@ static struct beiscsi_hba *beiscsi_hba_alloc(struct pci_dev *pcidev)
                         "beiscsi_hba_alloc - iscsi_host_alloc failed\n");
                 return NULL;
         }
-        shost->dma_boundary = pcidev->dma_mask;
         shost->max_id = BE2_MAX_SESSIONS;
         shost->max_channel = 0;
         shost->max_cmd_len = BEISCSI_MAX_CMD_LEN;
diff --git a/drivers/scsi/ch.c b/drivers/scsi/ch.c
index 6bac8a746ee2..0045742fab7d 100644
--- a/drivers/scsi/ch.c
+++ b/drivers/scsi/ch.c
@@ -194,16 +194,10 @@ ch_do_scsi(scsi_changer *ch, unsigned char *cmd, int cmd_len,
 
  retry:
         errno = 0;
-        if (debug) {
-                DPRINTK("command: ");
-                __scsi_print_command(cmd, cmd_len);
-        }
-
         result = scsi_execute_req(ch->device, cmd, direction, buffer,
                                   buflength, &sshdr, timeout * HZ,
                                   MAX_RETRIES, NULL);
 
-        DPRINTK("result: 0x%x\n",result);
         if (driver_byte(result) & DRIVER_SENSE) {
                 if (debug)
                         scsi_print_sense_hdr(ch->device, ch->name, &sshdr);
diff --git a/drivers/scsi/constants.c b/drivers/scsi/constants.c
index e2068a2621c4..fa09d4be2b53 100644
--- a/drivers/scsi/constants.c
+++ b/drivers/scsi/constants.c
@@ -18,14 +18,10 @@
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_dbg.h>
 
-
-
 /* Commands with service actions that change the command name */
 #define THIRD_PARTY_COPY_OUT 0x83
 #define THIRD_PARTY_COPY_IN 0x84
 
-#define VENDOR_SPECIFIC_CDB 0xc0
-
 struct sa_name_list {
         int opcode;
         const struct value_name_pair *arr;
@@ -37,7 +33,6 @@ struct value_name_pair {
         const char * name;
 };
 
-#ifdef CONFIG_SCSI_CONSTANTS
 static const char * cdb_byte0_names[] = {
 /* 00-03 */ "Test Unit Ready", "Rezero Unit/Rewind", NULL, "Request Sense",
 /* 04-07 */ "Format Unit/Medium", "Read Block Limits", NULL,
@@ -261,28 +256,8 @@ static struct sa_name_list sa_names_arr[] = {
         {0, NULL, 0},
 };
 
-#else /* ifndef CONFIG_SCSI_CONSTANTS */
-static const char *cdb_byte0_names[0];
-
-static struct sa_name_list sa_names_arr[] = {
-        {VARIABLE_LENGTH_CMD, NULL, 0},
-        {MAINTENANCE_IN, NULL, 0},
-        {MAINTENANCE_OUT, NULL, 0},
-        {PERSISTENT_RESERVE_IN, NULL, 0},
-        {PERSISTENT_RESERVE_OUT, NULL, 0},
-        {SERVICE_ACTION_IN_12, NULL, 0},
-        {SERVICE_ACTION_OUT_12, NULL, 0},
-        {SERVICE_ACTION_BIDIRECTIONAL, NULL, 0},
-        {SERVICE_ACTION_IN_16, NULL, 0},
-        {SERVICE_ACTION_OUT_16, NULL, 0},
-        {THIRD_PARTY_COPY_IN, NULL, 0},
-        {THIRD_PARTY_COPY_OUT, NULL, 0},
-        {0, NULL, 0},
-};
-#endif /* CONFIG_SCSI_CONSTANTS */
-
-static bool scsi_opcode_sa_name(int opcode, int service_action,
-                                const char **cdb_name, const char **sa_name)
+bool scsi_opcode_sa_name(int opcode, int service_action,
+                         const char **cdb_name, const char **sa_name)
 {
         struct sa_name_list *sa_name_ptr;
         const struct value_name_pair *arr = NULL;
@@ -315,76 +290,6 @@ static bool scsi_opcode_sa_name(int opcode, int service_action,
         return true;
 }
 
-static void print_opcode_name(const unsigned char *cdbp, size_t cdb_len)
-{
-        int sa, cdb0;
-        const char *cdb_name = NULL, *sa_name = NULL;
-
-        cdb0 = cdbp[0];
-        if (cdb0 == VARIABLE_LENGTH_CMD) {
-                if (cdb_len < 10) {
-                        printk("short variable length command, len=%zu",
-                               cdb_len);
-                        return;
-                }
-                sa = (cdbp[8] << 8) + cdbp[9];
-        } else
-                sa = cdbp[1] & 0x1f;
-
-        if (!scsi_opcode_sa_name(cdb0, sa, &cdb_name, &sa_name)) {
-                if (cdb_name)
-                        printk("%s", cdb_name);
-                else if (cdb0 >= VENDOR_SPECIFIC_CDB)
-                        printk("cdb[0]=0x%x (vendor)", cdb0);
-                else if (cdb0 >= 0x60 && cdb0 < 0x7e)
-                        printk("cdb[0]=0x%x (reserved)", cdb0);
-                else
-                        printk("cdb[0]=0x%x", cdb0);
-        } else {
-                if (sa_name)
-                        printk("%s", sa_name);
-                else if (cdb_name)
-                        printk("%s, sa=0x%x", cdb_name, sa);
-                else
-                        printk("cdb[0]=0x%x, sa=0x%x", cdb0, sa);
-        }
-}
-
-void __scsi_print_command(const unsigned char *cdb, size_t cdb_len)
-{
-        int k, len;
-
-        print_opcode_name(cdb, cdb_len);
-        len = scsi_command_size(cdb);
-        if (cdb_len < len)
-                len = cdb_len;
-        /* print out all bytes in cdb */
-        for (k = 0; k < len; ++k)
-                printk(" %02x", cdb[k]);
-        printk("\n");
-}
-EXPORT_SYMBOL(__scsi_print_command);
-
-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);
-
-        /* print out all bytes in cdb */
-        printk(":");
-        for (k = 0; k < cmd->cmd_len; ++k)
-                printk(" %02x", cmd->cmnd[k]);
-        printk("\n");
-}
-EXPORT_SYMBOL(scsi_print_command);
-
-#ifdef CONFIG_SCSI_CONSTANTS
-
 struct error_info {
         unsigned short code12;  /* 0x0302 looks better than 0x03,0x02 */
         const char * text;
@@ -392,7 +297,7 @@ struct error_info {
 
 /*
  * The canonical list of T10 Additional Sense Codes is available at:
- * http://www.t10.org/lists/asc-num.txt [most recent: 20130605]
+ * http://www.t10.org/lists/asc-num.txt [most recent: 20141221]
  */
 
 static const struct error_info additional[] =
@@ -421,6 +326,7 @@ static const struct error_info additional[] =
         {0x001E, "Conflicting SA creation request"},
         {0x001F, "Logical unit transitioning to another power condition"},
         {0x0020, "Extended copy information available"},
+        {0x0021, "Atomic command aborted due to ACA"},
 
         {0x0100, "No index/sector signal"},
 
@@ -446,6 +352,7 @@ static const struct error_info additional[] =
         {0x040C, "Logical unit not accessible, target port in unavailable "
          "state"},
         {0x040D, "Logical unit not ready, structure check required"},
+        {0x040E, "Logical unit not ready, security session in progress"},
         {0x0410, "Logical unit not ready, auxiliary memory not accessible"},
         {0x0411, "Logical unit not ready, notify (enable spinup) required"},
         {0x0412, "Logical unit not ready, offline"},
@@ -462,6 +369,11 @@ static const struct error_info additional[] =
         {0x041C, "Logical unit not ready, additional power use not yet "
          "granted"},
         {0x041D, "Logical unit not ready, configuration in progress"},
+        {0x041E, "Logical unit not ready, microcode activation required"},
+        {0x041F, "Logical unit not ready, microcode download required"},
+        {0x0420, "Logical unit not ready, logical unit reset required"},
+        {0x0421, "Logical unit not ready, hard reset required"},
+        {0x0422, "Logical unit not ready, power cycle required"},
 
         {0x0500, "Logical unit does not respond to selection"},
 
@@ -480,6 +392,7 @@ static const struct error_info additional[] =
         {0x0902, "Focus servo failure"},
         {0x0903, "Spindle servo failure"},
         {0x0904, "Head select fault"},
+        {0x0905, "Vibration induced tracking error"},
 
         {0x0A00, "Error log overflow"},
 
@@ -510,6 +423,7 @@ static const struct error_info additional[] =
         {0x0C0D, "Write error - not enough unsolicited data"},
         {0x0C0E, "Multiple write errors"},
         {0x0C0F, "Defects in error window"},
+        {0x0C10, "Incomplete multiple atomic write operations"},
 
         {0x0D00, "Error detected by third party temporary initiator"},
         {0x0D01, "Third party device failure"},
@@ -635,6 +549,10 @@ static const struct error_info additional[] =
         {0x2101, "Invalid element address"},
         {0x2102, "Invalid address for write"},
         {0x2103, "Invalid write crossing layer jump"},
+        {0x2104, "Unaligned write command"},
+        {0x2105, "Write boundary violation"},
+        {0x2106, "Attempt to read invalid data"},
+        {0x2107, "Read boundary violation"},
 
         {0x2200, "Illegal function (use 20 00, 24 00, or 26 00)"},
 
@@ -691,6 +609,7 @@ static const struct error_info additional[] =
         {0x2705, "Permanent write protect"},
         {0x2706, "Conditional write protect"},
         {0x2707, "Space allocation failed write protect"},
+        {0x2708, "Zone is read only"},
 
         {0x2800, "Not ready to ready change, medium may have changed"},
         {0x2801, "Import or export element accessed"},
@@ -743,10 +662,15 @@ static const struct error_info additional[] =
         {0x2C0A, "Partition or collection contains user objects"},
         {0x2C0B, "Not reserved"},
         {0x2C0C, "Orwrite generation does not match"},
+        {0x2C0D, "Reset write pointer not allowed"},
+        {0x2C0E, "Zone is offline"},
 
         {0x2D00, "Overwrite error on update in place"},
 
         {0x2E00, "Insufficient time for operation"},
+        {0x2E01, "Command timeout before processing"},
+        {0x2E02, "Command timeout during processing"},
+        {0x2E03, "Command timeout during processing due to error recovery"},
 
         {0x2F00, "Commands cleared by another initiator"},
         {0x2F01, "Commands cleared by power loss notification"},
@@ -868,6 +792,7 @@ static const struct error_info additional[] =
         {0x3F13, "iSCSI IP address removed"},
         {0x3F14, "iSCSI IP address changed"},
         {0x3F15, "Inspect referrals sense descriptors"},
+        {0x3F16, "Microcode has been changed without reset"},
 /*
  *      {0x40NN, "Ram failure"},
  *      {0x40NN, "Diagnostic failure on component nn"},
@@ -946,6 +871,11 @@ static const struct error_info additional[] =
         {0x5306, "Volume identifier missing"},
         {0x5307, "Duplicate volume identifier"},
         {0x5308, "Element status unknown"},
+        {0x5309, "Data transfer device error - load failed"},
+        {0x530a, "Data transfer device error - unload failed"},
+        {0x530b, "Data transfer device error - unload missing"},
+        {0x530c, "Data transfer device error - eject failed"},
+        {0x530d, "Data transfer device error - library communication failed"},
 
         {0x5400, "Scsi to host system interface failure"},
 
@@ -963,6 +893,7 @@ static const struct error_info additional[] =
         {0x550B, "Insufficient power for operation"},
         {0x550C, "Insufficient resources to create rod"},
         {0x550D, "Insufficient resources to create rod token"},
+        {0x550E, "Insufficient zone resources"},
 
         {0x5700, "Unable to recover table-of-contents"},
 
@@ -1247,15 +1178,12 @@ static const char * const snstext[] = {
         "Completed",        /* F: command completed sense data reported,
                                   may occur for successful command */
 };
-#endif
 
 /* Get sense key string or NULL if not available */
 const char *
 scsi_sense_key_string(unsigned char key) {
-#ifdef CONFIG_SCSI_CONSTANTS
         if (key <= 0xE)
                 return snstext[key];
-#endif
         return NULL;
 }
 EXPORT_SYMBOL(scsi_sense_key_string);
@@ -1267,7 +1195,6 @@ EXPORT_SYMBOL(scsi_sense_key_string);
 const char *
 scsi_extd_sense_format(unsigned char asc, unsigned char ascq, const char **fmt)
 {
-#ifdef CONFIG_SCSI_CONSTANTS
         int i;
         unsigned short code = ((asc << 8) | ascq);
 
@@ -1283,122 +1210,10 @@ scsi_extd_sense_format(unsigned char asc, unsigned char ascq, const char **fmt)
                         return additional2[i].str;
                 }
         }
-#else
-        *fmt = NULL;
-#endif
         return NULL;
 }
 EXPORT_SYMBOL(scsi_extd_sense_format);
 
-void
-scsi_show_extd_sense(const struct scsi_device *sdev, const char *name,
-                     unsigned char asc, unsigned char ascq)
-{
-        const char *extd_sense_fmt = NULL;
-        const char *extd_sense_str = scsi_extd_sense_format(asc, ascq,
-                                                            &extd_sense_fmt);
-
-        if (extd_sense_str) {
-                if (extd_sense_fmt)
-                        sdev_prefix_printk(KERN_INFO, sdev, name,
-                                           "Add. Sense: %s (%s%x)",
-                                           extd_sense_str, extd_sense_fmt,
-                                           ascq);
-                else
-                        sdev_prefix_printk(KERN_INFO, sdev, name,
-                                           "Add. Sense: %s", extd_sense_str);
-
-        } else {
-                sdev_prefix_printk(KERN_INFO, sdev, name,
-                                   "%sASC=0x%x %sASCQ=0x%x\n",
-                                   asc >= 0x80 ? "<<vendor>> " : "", asc,
-                                   ascq >= 0x80 ? "<<vendor>> " : "", ascq);
-        }
-}
-EXPORT_SYMBOL(scsi_show_extd_sense);
-
-void
-scsi_show_sense_hdr(const struct scsi_device *sdev, const char *name,
-                    const struct scsi_sense_hdr *sshdr)
-{
-        const char *sense_txt;
-
-        sense_txt = scsi_sense_key_string(sshdr->sense_key);
-        if (sense_txt)
-                sdev_prefix_printk(KERN_INFO, sdev, name,
-                                   "Sense Key : %s [%s]%s\n", sense_txt,
-                                   scsi_sense_is_deferred(sshdr) ?
-                                   "deferred" : "current",
-                                   sshdr->response_code >= 0x72 ?
-                                   " [descriptor]" : "");
-        else
-                sdev_prefix_printk(KERN_INFO, sdev, name,
-                                   "Sense Key : 0x%x [%s]%s", sshdr->sense_key,
-                                   scsi_sense_is_deferred(sshdr) ?
-                                   "deferred" : "current",
-                                   sshdr->response_code >= 0x72 ?
-                                   " [descriptor]" : "");
-}
-EXPORT_SYMBOL(scsi_show_sense_hdr);
-
-/*
- * Print normalized SCSI sense header with a prefix.
- */
-void
-scsi_print_sense_hdr(const struct scsi_device *sdev, const char *name,
-                     const struct scsi_sense_hdr *sshdr)
-{
-        scsi_show_sense_hdr(sdev, name, sshdr);
-        scsi_show_extd_sense(sdev, name, sshdr->asc, sshdr->ascq);
-}
-EXPORT_SYMBOL(scsi_print_sense_hdr);
-
-static void
-scsi_dump_sense_buffer(const unsigned char *sense_buffer, int sense_len)
-{
-        int k, num;
-
-        num = (sense_len < 32) ? sense_len : 32;
-        printk("Unrecognized sense data (in hex):");
-        for (k = 0; k < num; ++k) {
-                if (0 == (k % 16)) {
-                        printk("\n");
-                        printk(KERN_INFO "        ");
-                }
-                printk("%02x ", sense_buffer[k]);
-        }
-        printk("\n");
-        return;
-}
-
-/* Normalize and print sense buffer with name prefix */
-void __scsi_print_sense(const struct scsi_device *sdev, const char *name,
-                        const unsigned char *sense_buffer, int sense_len)
-{
-        struct scsi_sense_hdr sshdr;
-
-        if (!scsi_normalize_sense(sense_buffer, sense_len, &sshdr)) {
-                scsi_dump_sense_buffer(sense_buffer, sense_len);
-                return;
-        }
-        scsi_show_sense_hdr(sdev, name, &sshdr);
-        scsi_show_extd_sense(sdev, name, sshdr.asc, sshdr.ascq);
-}
-EXPORT_SYMBOL(__scsi_print_sense);
-
-/* Normalize and print sense buffer in SCSI command */
-void scsi_print_sense(const struct scsi_cmnd *cmd)
-{
-        struct gendisk *disk = cmd->request->rq_disk;
-        const char *disk_name = disk ? disk->disk_name : NULL;
-
-        __scsi_print_sense(cmd->device, disk_name, cmd->sense_buffer,
-                           SCSI_SENSE_BUFFERSIZE);
-}
-EXPORT_SYMBOL(scsi_print_sense);
-
-#ifdef CONFIG_SCSI_CONSTANTS
-
 static const char * const hostbyte_table[]={
 "DID_OK", "DID_NO_CONNECT", "DID_BUS_BUSY", "DID_TIME_OUT", "DID_BAD_TARGET",
 "DID_ABORT", "DID_PARITY", "DID_ERROR", "DID_RESET", "DID_BAD_INTR",
@@ -1410,17 +1225,13 @@ static const char * const driverbyte_table[]={
 "DRIVER_OK", "DRIVER_BUSY", "DRIVER_SOFT",  "DRIVER_MEDIA", "DRIVER_ERROR",
 "DRIVER_INVALID", "DRIVER_TIMEOUT", "DRIVER_HARD", "DRIVER_SENSE"};
 
-#endif
-
 const char *scsi_hostbyte_string(int result)
 {
         const char *hb_string = NULL;
-#ifdef CONFIG_SCSI_CONSTANTS
         int hb = host_byte(result);
 
         if (hb < ARRAY_SIZE(hostbyte_table))
                 hb_string = hostbyte_table[hb];
-#endif
         return hb_string;
 }
 EXPORT_SYMBOL(scsi_hostbyte_string);
@@ -1428,17 +1239,14 @@ EXPORT_SYMBOL(scsi_hostbyte_string);
 const char *scsi_driverbyte_string(int result)
 {
         const char *db_string = NULL;
-#ifdef CONFIG_SCSI_CONSTANTS
         int db = driver_byte(result);
 
         if (db < ARRAY_SIZE(driverbyte_table))
                 db_string = driverbyte_table[db];
-#endif
         return db_string;
 }
 EXPORT_SYMBOL(scsi_driverbyte_string);
 
-#ifdef CONFIG_SCSI_CONSTANTS
 #define scsi_mlreturn_name(result)      { result, #result }
 static const struct value_name_pair scsi_mlreturn_arr[] = {
         scsi_mlreturn_name(NEEDS_RETRY),
@@ -1451,11 +1259,9 @@ static const struct value_name_pair scsi_mlreturn_arr[] = {
         scsi_mlreturn_name(SCSI_RETURN_NOT_HANDLED),
         scsi_mlreturn_name(FAST_IO_FAIL)
 };
-#endif
 
 const char *scsi_mlreturn_string(int result)
 {
-#ifdef CONFIG_SCSI_CONSTANTS
         const struct value_name_pair *arr = scsi_mlreturn_arr;
         int k;
 
@@ -1463,29 +1269,6 @@ const char *scsi_mlreturn_string(int result)
                 if (result == arr->value)
                         return arr->name;
         }
-#endif
         return NULL;
 }
 EXPORT_SYMBOL(scsi_mlreturn_string);
-
-void scsi_print_result(struct scsi_cmnd *cmd, const char *msg, int disposition)
-{
-        const char *mlret_string = scsi_mlreturn_string(disposition);
-        const char *hb_string = scsi_hostbyte_string(cmd->result);
-        const char *db_string = scsi_driverbyte_string(cmd->result);
-
-        if (hb_string || db_string)
-                scmd_printk(KERN_INFO, cmd,
-                            "%s%s Result: hostbyte=%s driverbyte=%s",
-                            msg ? msg : "",
-                            mlret_string ? mlret_string : "UNKNOWN",
-                            hb_string ? hb_string : "invalid",
-                            db_string ? db_string : "invalid");
-        else
-                scmd_printk(KERN_INFO, cmd,
-                            "%s%s Result: hostbyte=0x%02x driverbyte=0x%02x",
-                            msg ? msg : "",
-                            mlret_string ? mlret_string : "UNKNOWN",
-                            host_byte(cmd->result), driver_byte(cmd->result));
-}
-EXPORT_SYMBOL(scsi_print_result);
diff --git a/drivers/scsi/csiostor/Makefile b/drivers/scsi/csiostor/Makefile
index 913b9a92fb06..3681a3fbd499 100644
--- a/drivers/scsi/csiostor/Makefile
+++ b/drivers/scsi/csiostor/Makefile
@@ -8,5 +8,5 @@ ccflags-y += -I$(srctree)/drivers/net/ethernet/chelsio/cxgb4
 obj-$(CONFIG_SCSI_CHELSIO_FCOE) += csiostor.o
 
 csiostor-objs := csio_attr.o csio_init.o csio_lnode.o csio_scsi.o \
-                csio_hw.o csio_hw_t4.o csio_hw_t5.o csio_isr.o \
+                csio_hw.o csio_hw_t5.o csio_isr.o \
                 csio_mb.o csio_rnode.o csio_wr.o
diff --git a/drivers/scsi/csiostor/csio_hw.c b/drivers/scsi/csiostor/csio_hw.c
index 9ab997e18b20..2e66f34ebb79 100644
--- a/drivers/scsi/csiostor/csio_hw.c
+++ b/drivers/scsi/csiostor/csio_hw.c
@@ -60,37 +60,10 @@ int csio_msi = 2;
 static int dev_num;
 
 /* FCoE Adapter types & its description */
-static const struct csio_adap_desc csio_t4_fcoe_adapters[] = {
-        {"T440-Dbg 10G", "Chelsio T440-Dbg 10G [FCoE]"},
-        {"T420-CR 10G", "Chelsio T420-CR 10G [FCoE]"},
-        {"T422-CR 10G/1G", "Chelsio T422-CR 10G/1G [FCoE]"},
-        {"T440-CR 10G", "Chelsio T440-CR 10G [FCoE]"},
-        {"T420-BCH 10G", "Chelsio T420-BCH 10G [FCoE]"},
-        {"T440-BCH 10G", "Chelsio T440-BCH 10G [FCoE]"},
-        {"T440-CH 10G", "Chelsio T440-CH 10G [FCoE]"},
-        {"T420-SO 10G", "Chelsio T420-SO 10G [FCoE]"},
-        {"T420-CX4 10G", "Chelsio T420-CX4 10G [FCoE]"},
-        {"T420-BT 10G", "Chelsio T420-BT 10G [FCoE]"},
-        {"T404-BT 1G", "Chelsio T404-BT 1G [FCoE]"},
-        {"B420-SR 10G", "Chelsio B420-SR 10G [FCoE]"},
-        {"B404-BT 1G", "Chelsio B404-BT 1G [FCoE]"},
-        {"T480-CR 10G", "Chelsio T480-CR 10G [FCoE]"},
-        {"T440-LP-CR 10G", "Chelsio T440-LP-CR 10G [FCoE]"},
-        {"AMSTERDAM 10G", "Chelsio AMSTERDAM 10G [FCoE]"},
-        {"HUAWEI T480 10G", "Chelsio HUAWEI T480 10G [FCoE]"},
-        {"HUAWEI T440 10G", "Chelsio HUAWEI T440 10G [FCoE]"},
-        {"HUAWEI STG 10G", "Chelsio HUAWEI STG 10G [FCoE]"},
-        {"ACROMAG XAUI 10G", "Chelsio ACROMAG XAUI 10G [FCoE]"},
-        {"ACROMAG SFP+ 10G", "Chelsio ACROMAG SFP+ 10G [FCoE]"},
-        {"QUANTA SFP+ 10G", "Chelsio QUANTA SFP+ 10G [FCoE]"},
-        {"HUAWEI 10Gbase-T", "Chelsio HUAWEI 10Gbase-T [FCoE]"},
-        {"HUAWEI T4TOE 10G", "Chelsio HUAWEI T4TOE 10G [FCoE]"}
-};
-
 static const struct csio_adap_desc csio_t5_fcoe_adapters[] = {
         {"T580-Dbg 10G", "Chelsio T580-Dbg 10G [FCoE]"},
         {"T520-CR 10G", "Chelsio T520-CR 10G [FCoE]"},
-        {"T522-CR 10G/1G", "Chelsio T452-CR 10G/1G [FCoE]"},
+        {"T522-CR 10G/1G", "Chelsio T522-CR 10G/1G [FCoE]"},
         {"T540-CR 10G", "Chelsio T540-CR 10G [FCoE]"},
         {"T520-BCH 10G", "Chelsio T520-BCH 10G [FCoE]"},
         {"T540-BCH 10G", "Chelsio T540-BCH 10G [FCoE]"},
@@ -107,7 +80,9 @@ static const struct csio_adap_desc csio_t5_fcoe_adapters[] = {
         {"T580-LP-CR 40G", "Chelsio T580-LP-CR 40G [FCoE]"},
         {"T520-LL-CR 10G", "Chelsio T520-LL-CR 10G [FCoE]"},
         {"T560-CR 40G", "Chelsio T560-CR 40G [FCoE]"},
-        {"T580-CR 40G", "Chelsio T580-CR 40G [FCoE]"}
+        {"T580-CR 40G", "Chelsio T580-CR 40G [FCoE]"},
+        {"T580-SO 40G", "Chelsio T580-SO 40G [FCoE]"},
+        {"T502-BT 1G", "Chelsio T502-BT 1G [FCoE]"}
 };
 
 static void csio_mgmtm_cleanup(struct csio_mgmtm *);
@@ -188,9 +163,9 @@ void
 csio_hw_tp_wr_bits_indirect(struct csio_hw *hw, unsigned int addr,
                         unsigned int mask, unsigned int val)
 {
-        csio_wr_reg32(hw, addr, TP_PIO_ADDR);
-        val |= csio_rd_reg32(hw, TP_PIO_DATA) & ~mask;
-        csio_wr_reg32(hw, val, TP_PIO_DATA);
+        csio_wr_reg32(hw, addr, TP_PIO_ADDR_A);
+        val |= csio_rd_reg32(hw, TP_PIO_DATA_A) & ~mask;
+        csio_wr_reg32(hw, val, TP_PIO_DATA_A);
 }
 
 void
@@ -256,7 +231,7 @@ csio_hw_seeprom_read(struct csio_hw *hw, uint32_t addr, uint32_t *data)
         }
 
         pci_read_config_dword(hw->pdev, base + PCI_VPD_DATA, data);
-        *data = le32_to_cpu(*data);
+        *data = le32_to_cpu(*(__le32 *)data);
 
         return 0;
 }
@@ -421,17 +396,15 @@ csio_hw_sf1_read(struct csio_hw *hw, uint32_t byte_cnt, int32_t cont,
 
         if (!byte_cnt || byte_cnt > 4)
                 return -EINVAL;
-        if (csio_rd_reg32(hw, SF_OP) & SF_BUSY)
+        if (csio_rd_reg32(hw, SF_OP_A) & SF_BUSY_F)
                 return -EBUSY;
 
-        cont = cont ? SF_CONT : 0;
-        lock = lock ? SF_LOCK : 0;
-
-        csio_wr_reg32(hw, lock | cont | BYTECNT(byte_cnt - 1), SF_OP);
-        ret = csio_hw_wait_op_done_val(hw, SF_OP, SF_BUSY, 0, SF_ATTEMPTS,
-                                         10, NULL);
+        csio_wr_reg32(hw,  SF_LOCK_V(lock) | SF_CONT_V(cont) |
+                      BYTECNT_V(byte_cnt - 1), SF_OP_A);
+        ret = csio_hw_wait_op_done_val(hw, SF_OP_A, SF_BUSY_F, 0, SF_ATTEMPTS,
+                                       10, NULL);
         if (!ret)
-                *valp = csio_rd_reg32(hw, SF_DATA);
+                *valp = csio_rd_reg32(hw, SF_DATA_A);
         return ret;
 }
 
@@ -453,16 +426,14 @@ csio_hw_sf1_write(struct csio_hw *hw, uint32_t byte_cnt, uint32_t cont,
 {
         if (!byte_cnt || byte_cnt > 4)
                 return -EINVAL;
-        if (csio_rd_reg32(hw, SF_OP) & SF_BUSY)
+        if (csio_rd_reg32(hw, SF_OP_A) & SF_BUSY_F)
                 return -EBUSY;
 
-        cont = cont ? SF_CONT : 0;
-        lock = lock ? SF_LOCK : 0;
-
-        csio_wr_reg32(hw, val, SF_DATA);
-        csio_wr_reg32(hw, cont | BYTECNT(byte_cnt - 1) | OP_WR | lock, SF_OP);
+        csio_wr_reg32(hw, val, SF_DATA_A);
+        csio_wr_reg32(hw, SF_CONT_V(cont) | BYTECNT_V(byte_cnt - 1) |
+                      OP_V(1) | SF_LOCK_V(lock), SF_OP_A);
 
-        return csio_hw_wait_op_done_val(hw, SF_OP, SF_BUSY, 0, SF_ATTEMPTS,
+        return csio_hw_wait_op_done_val(hw, SF_OP_A, SF_BUSY_F, 0, SF_ATTEMPTS,
                                         10, NULL);
 }
 
@@ -533,11 +504,11 @@ csio_hw_read_flash(struct csio_hw *hw, uint32_t addr, uint32_t nwords,
         for ( ; nwords; nwords--, data++) {
                 ret = csio_hw_sf1_read(hw, 4, nwords > 1, nwords == 1, data);
                 if (nwords == 1)
-                        csio_wr_reg32(hw, 0, SF_OP);    /* unlock SF */
+                        csio_wr_reg32(hw, 0, SF_OP_A);    /* unlock SF */
                 if (ret)
                         return ret;
                 if (byte_oriented)
-                        *data = htonl(*data);
+                        *data = (__force __u32) htonl(*data);
         }
         return 0;
 }
@@ -586,7 +557,7 @@ csio_hw_write_flash(struct csio_hw *hw, uint32_t addr,
         if (ret)
                 goto unlock;
 
-        csio_wr_reg32(hw, 0, SF_OP);    /* unlock SF */
+        csio_wr_reg32(hw, 0, SF_OP_A);    /* unlock SF */
 
         /* Read the page to verify the write succeeded */
         ret = csio_hw_read_flash(hw, addr & ~0xff, ARRAY_SIZE(buf), buf, 1);
@@ -603,7 +574,7 @@ csio_hw_write_flash(struct csio_hw *hw, uint32_t addr,
         return 0;
 
 unlock:
-        csio_wr_reg32(hw, 0, SF_OP);    /* unlock SF */
+        csio_wr_reg32(hw, 0, SF_OP_A);    /* unlock SF */
         return ret;
 }
 
@@ -641,7 +612,7 @@ out:
         if (ret)
                 csio_err(hw, "erase of flash sector %d failed, error %d\n",
                          start, ret);
-        csio_wr_reg32(hw, 0, SF_OP);    /* unlock SF */
+        csio_wr_reg32(hw, 0, SF_OP_A);    /* unlock SF */
         return 0;
 }
 
@@ -665,7 +636,7 @@ csio_hw_print_fw_version(struct csio_hw *hw, char *str)
 static int
 csio_hw_get_fw_version(struct csio_hw *hw, uint32_t *vers)
 {
-        return csio_hw_read_flash(hw, FW_IMG_START +
+        return csio_hw_read_flash(hw, FLASH_FW_START +
                                   offsetof(struct fw_hdr, fw_ver), 1,
                                   vers, 0);
 }
@@ -686,43 +657,6 @@ csio_hw_get_tp_version(struct csio_hw *hw, u32 *vers)
 }
 
 /*
- *      csio_hw_check_fw_version - check if the FW is compatible with
- *                                 this driver
- *      @hw: HW module
- *
- *      Checks if an adapter's FW is compatible with the driver.  Returns 0
- *      if there's exact match, a negative error if the version could not be
- *      read or there's a major/minor version mismatch/minor.
- */
-static int
-csio_hw_check_fw_version(struct csio_hw *hw)
-{
-        int ret, major, minor, micro;
-
-        ret = csio_hw_get_fw_version(hw, &hw->fwrev);
-        if (!ret)
-                ret = csio_hw_get_tp_version(hw, &hw->tp_vers);
-        if (ret)
-                return ret;
-
-        major = FW_HDR_FW_VER_MAJOR_G(hw->fwrev);
-        minor = FW_HDR_FW_VER_MINOR_G(hw->fwrev);
-        micro = FW_HDR_FW_VER_MICRO_G(hw->fwrev);
-
-        if (major != FW_VERSION_MAJOR(hw)) {    /* major mismatch - fail */
-                csio_err(hw, "card FW has major version %u, driver wants %u\n",
-                         major, FW_VERSION_MAJOR(hw));
-                return -EINVAL;
-        }
-
-        if (minor == FW_VERSION_MINOR(hw) && micro == FW_VERSION_MICRO(hw))
-                return 0;        /* perfect match */
-
-        /* Minor/micro version mismatch */
-        return -EINVAL;
-}
-
-/*
  * csio_hw_fw_dload - download firmware.
  * @hw: HW module
  * @fw_data: firmware image to write.
@@ -762,9 +696,9 @@ csio_hw_fw_dload(struct csio_hw *hw, uint8_t *fw_data, uint32_t size)
                 return -EINVAL;
         }
 
-        if (size > FW_MAX_SIZE) {
+        if (size > FLASH_FW_MAX_SIZE) {
                 csio_err(hw, "FW image too large, max is %u bytes\n",
-                            FW_MAX_SIZE);
+                            FLASH_FW_MAX_SIZE);
                 return -EINVAL;
         }
 
@@ -780,10 +714,10 @@ csio_hw_fw_dload(struct csio_hw *hw, uint8_t *fw_data, uint32_t size)
         i = DIV_ROUND_UP(size, sf_sec_size);        /* # of sectors spanned */
 
         csio_dbg(hw, "Erasing sectors... start:%d end:%d\n",
-                          FW_START_SEC, FW_START_SEC + i - 1);
+                          FLASH_FW_START_SEC, FLASH_FW_START_SEC + i - 1);
 
-        ret = csio_hw_flash_erase_sectors(hw, FW_START_SEC,
-                                          FW_START_SEC + i - 1);
+        ret = csio_hw_flash_erase_sectors(hw, FLASH_FW_START_SEC,
+                                          FLASH_FW_START_SEC + i - 1);
         if (ret) {
                 csio_err(hw, "Flash Erase failed\n");
                 goto out;
@@ -796,14 +730,14 @@ csio_hw_fw_dload(struct csio_hw *hw, uint8_t *fw_data, uint32_t size)
          */
         memcpy(first_page, fw_data, SF_PAGE_SIZE);
         ((struct fw_hdr *)first_page)->fw_ver = htonl(0xffffffff);
-        ret = csio_hw_write_flash(hw, FW_IMG_START, SF_PAGE_SIZE, first_page);
+        ret = csio_hw_write_flash(hw, FLASH_FW_START, SF_PAGE_SIZE, first_page);
         if (ret)
                 goto out;
 
         csio_dbg(hw, "Writing Flash .. start:%d end:%d\n",
                     FW_IMG_START, FW_IMG_START + size);
 
-        addr = FW_IMG_START;
+        addr = FLASH_FW_START;
         for (size -= SF_PAGE_SIZE; size; size -= SF_PAGE_SIZE) {
                 addr += SF_PAGE_SIZE;
                 fw_data += SF_PAGE_SIZE;
@@ -813,7 +747,7 @@ csio_hw_fw_dload(struct csio_hw *hw, uint8_t *fw_data, uint32_t size)
         }
 
         ret = csio_hw_write_flash(hw,
-                                  FW_IMG_START +
+                                  FLASH_FW_START +
                                         offsetof(struct fw_hdr, fw_ver),
                                   sizeof(hdr->fw_ver),
                                   (const uint8_t *)&hdr->fw_ver);
@@ -833,7 +767,7 @@ csio_hw_get_flash_params(struct csio_hw *hw)
         ret = csio_hw_sf1_write(hw, 1, 1, 0, SF_RD_ID);
         if (!ret)
                 ret = csio_hw_sf1_read(hw, 3, 0, 1, &info);
-        csio_wr_reg32(hw, 0, SF_OP);    /* unlock SF */
+        csio_wr_reg32(hw, 0, SF_OP_A);    /* unlock SF */
         if (ret != 0)
                 return ret;
 
@@ -861,17 +795,17 @@ csio_hw_dev_ready(struct csio_hw *hw)
         uint32_t reg;
         int cnt = 6;
 
-        while (((reg = csio_rd_reg32(hw, PL_WHOAMI)) == 0xFFFFFFFF) &&
-                                                                (--cnt != 0))
+        while (((reg = csio_rd_reg32(hw, PL_WHOAMI_A)) == 0xFFFFFFFF) &&
+               (--cnt != 0))
                 mdelay(100);
 
-        if ((cnt == 0) && (((int32_t)(SOURCEPF_GET(reg)) < 0) ||
-                            (SOURCEPF_GET(reg) >= CSIO_MAX_PFN))) {
+        if ((cnt == 0) && (((int32_t)(SOURCEPF_G(reg)) < 0) ||
+                           (SOURCEPF_G(reg) >= CSIO_MAX_PFN))) {
                 csio_err(hw, "PL_WHOAMI returned 0x%x, cnt:%d\n", reg, cnt);
                 return -EIO;
         }
 
-        hw->pfn = SOURCEPF_GET(reg);
+        hw->pfn = SOURCEPF_G(reg);
 
         return 0;
 }
@@ -959,8 +893,8 @@ retry:
                          * timeout ... and then retry if we haven't exhausted
                          * our retries ...
                          */
-                        pcie_fw = csio_rd_reg32(hw, PCIE_FW);
-                        if (!(pcie_fw & (PCIE_FW_ERR|PCIE_FW_INIT))) {
+                        pcie_fw = csio_rd_reg32(hw, PCIE_FW_A);
+                        if (!(pcie_fw & (PCIE_FW_ERR_F|PCIE_FW_INIT_F))) {
                                 if (waiting <= 0) {
                                         if (retries-- > 0)
                                                 goto retry;
@@ -976,10 +910,10 @@ retry:
                          * report errors preferentially.
                          */
                         if (state) {
-                                if (pcie_fw & PCIE_FW_ERR) {
+                                if (pcie_fw & PCIE_FW_ERR_F) {
                                         *state = CSIO_DEV_STATE_ERR;
                                         rv = -ETIMEDOUT;
-                                } else if (pcie_fw & PCIE_FW_INIT)
+                                } else if (pcie_fw & PCIE_FW_INIT_F)
                                         *state = CSIO_DEV_STATE_INIT;
                         }
 
@@ -988,9 +922,9 @@ retry:
                          * there's not a valid Master PF, grab its identity
                          * for our caller.
                          */
-                        if (mpfn == PCIE_FW_MASTER_MASK &&
-                            (pcie_fw & PCIE_FW_MASTER_VLD))
-                                mpfn = PCIE_FW_MASTER_GET(pcie_fw);
+                        if (mpfn == PCIE_FW_MASTER_M &&
+                            (pcie_fw & PCIE_FW_MASTER_VLD_F))
+                                mpfn = PCIE_FW_MASTER_G(pcie_fw);
                         break;
                 }
                 hw->flags &= ~CSIO_HWF_MASTER;
@@ -1078,7 +1012,7 @@ csio_do_reset(struct csio_hw *hw, bool fw_rst)
 
         if (!fw_rst) {
                 /* PIO reset */
-                csio_wr_reg32(hw, PIORSTMODE | PIORST, PL_RST);
+                csio_wr_reg32(hw, PIORSTMODE_F | PIORST_F, PL_RST_A);
                 mdelay(2000);
                 return 0;
         }
@@ -1090,7 +1024,7 @@ csio_do_reset(struct csio_hw *hw, bool fw_rst)
         }
 
         csio_mb_reset(hw, mbp, CSIO_MB_DEFAULT_TMO,
-                      PIORSTMODE | PIORST, 0, NULL);
+                      PIORSTMODE_F | PIORST_F, 0, NULL);
 
         if (csio_mb_issue(hw, mbp)) {
                 csio_err(hw, "Issue of RESET command failed.n");
@@ -1156,7 +1090,7 @@ csio_hw_fw_halt(struct csio_hw *hw, uint32_t mbox, int32_t force)
          * If a legitimate mailbox is provided, issue a RESET command
          * with a HALT indication.
          */
-        if (mbox <= PCIE_FW_MASTER_MASK) {
+        if (mbox <= PCIE_FW_MASTER_M) {
                 struct csio_mb  *mbp;
 
                 mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
@@ -1166,7 +1100,7 @@ csio_hw_fw_halt(struct csio_hw *hw, uint32_t mbox, int32_t force)
                 }
 
                 csio_mb_reset(hw, mbp, CSIO_MB_DEFAULT_TMO,
-                              PIORSTMODE | PIORST, FW_RESET_CMD_HALT_F,
+                              PIORSTMODE_F | PIORST_F, FW_RESET_CMD_HALT_F,
                               NULL);
 
                 if (csio_mb_issue(hw, mbp)) {
@@ -1193,8 +1127,9 @@ csio_hw_fw_halt(struct csio_hw *hw, uint32_t mbox, int32_t force)
          * rather than a RESET ... if it's new enough to understand that ...
          */
         if (retval == 0 || force) {
-                csio_set_reg_field(hw, CIM_BOOT_CFG, UPCRST, UPCRST);
-                csio_set_reg_field(hw, PCIE_FW, PCIE_FW_HALT, PCIE_FW_HALT);
+                csio_set_reg_field(hw, CIM_BOOT_CFG_A, UPCRST_F, UPCRST_F);
+                csio_set_reg_field(hw, PCIE_FW_A, PCIE_FW_HALT_F,
+                                   PCIE_FW_HALT_F);
         }
 
         /*
@@ -1234,7 +1169,7 @@ csio_hw_fw_restart(struct csio_hw *hw, uint32_t mbox, int32_t reset)
                  * doing it automatically, we need to clear the PCIE_FW.HALT
                  * bit.
                  */
-                csio_set_reg_field(hw, PCIE_FW, PCIE_FW_HALT, 0);
+                csio_set_reg_field(hw, PCIE_FW_A, PCIE_FW_HALT_F, 0);
 
                 /*
                  * If we've been given a valid mailbox, first try to get the
@@ -1243,21 +1178,21 @@ csio_hw_fw_restart(struct csio_hw *hw, uint32_t mbox, int32_t reset)
                  * valid mailbox or the RESET command failed, fall back to
                  * hitting the chip with a hammer.
                  */
-                if (mbox <= PCIE_FW_MASTER_MASK) {
-                        csio_set_reg_field(hw, CIM_BOOT_CFG, UPCRST, 0);
+                if (mbox <= PCIE_FW_MASTER_M) {
+                        csio_set_reg_field(hw, CIM_BOOT_CFG_A, UPCRST_F, 0);
                         msleep(100);
                         if (csio_do_reset(hw, true) == 0)
                                 return 0;
                 }
 
-                csio_wr_reg32(hw, PIORSTMODE | PIORST, PL_RST);
+                csio_wr_reg32(hw, PIORSTMODE_F | PIORST_F, PL_RST_A);
                 msleep(2000);
         } else {
                 int ms;
 
-                csio_set_reg_field(hw, CIM_BOOT_CFG, UPCRST, 0);
+                csio_set_reg_field(hw, CIM_BOOT_CFG_A, UPCRST_F, 0);
                 for (ms = 0; ms < FW_CMD_MAX_TIMEOUT; ) {
-                        if (!(csio_rd_reg32(hw, PCIE_FW) & PCIE_FW_HALT))
+                        if (!(csio_rd_reg32(hw, PCIE_FW_A) & PCIE_FW_HALT_F))
                                 return 0;
                         msleep(100);
                         ms += 100;
@@ -1315,116 +1250,6 @@ csio_hw_fw_upgrade(struct csio_hw *hw, uint32_t mbox,
         return csio_hw_fw_restart(hw, mbox, reset);
 }
 
-
-/*
- *      csio_hw_fw_config_file - setup an adapter via a Configuration File
- *      @hw: the HW module
- *      @mbox: mailbox to use for the FW command
- *      @mtype: the memory type where the Configuration File is located
- *      @maddr: the memory address where the Configuration File is located
- *      @finiver: return value for CF [fini] version
- *      @finicsum: return value for CF [fini] checksum
- *      @cfcsum: return value for CF computed checksum
- *
- *      Issue a command to get the firmware to process the Configuration
- *      File located at the specified mtype/maddress.  If the Configuration
- *      File is processed successfully and return value pointers are
- *      provided, the Configuration File "[fini] section version and
- *      checksum values will be returned along with the computed checksum.
- *      It's up to the caller to decide how it wants to respond to the
- *      checksums not matching but it recommended that a prominant warning
- *      be emitted in order to help people rapidly identify changed or
- *      corrupted Configuration Files.
- *
- *      Also note that it's possible to modify things like "niccaps",
- *      "toecaps",etc. between processing the Configuration File and telling
- *      the firmware to use the new configuration.  Callers which want to
- *      do this will need to "hand-roll" their own CAPS_CONFIGS commands for
- *      Configuration Files if they want to do this.
- */
-static int
-csio_hw_fw_config_file(struct csio_hw *hw,
-                      unsigned int mtype, unsigned int maddr,
-                      uint32_t *finiver, uint32_t *finicsum, uint32_t *cfcsum)
-{
-        struct csio_mb  *mbp;
-        struct fw_caps_config_cmd *caps_cmd;
-        int rv = -EINVAL;
-        enum fw_retval ret;
-
-        mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
-        if (!mbp) {
-                CSIO_INC_STATS(hw, n_err_nomem);
-                return -ENOMEM;
-        }
-        /*
-         * Tell the firmware to process the indicated Configuration File.
-         * If there are no errors and the caller has provided return value
-         * pointers for the [fini] section version, checksum and computed
-         * checksum, pass those back to the caller.
-         */
-        caps_cmd = (struct fw_caps_config_cmd *)(mbp->mb);
-        CSIO_INIT_MBP(mbp, caps_cmd, CSIO_MB_DEFAULT_TMO, hw, NULL, 1);
-        caps_cmd->op_to_write =
-                htonl(FW_CMD_OP_V(FW_CAPS_CONFIG_CMD) |
-                      FW_CMD_REQUEST_F |
-                      FW_CMD_READ_F);
-        caps_cmd->cfvalid_to_len16 =
-                htonl(FW_CAPS_CONFIG_CMD_CFVALID_F |
-                      FW_CAPS_CONFIG_CMD_MEMTYPE_CF_V(mtype) |
-                      FW_CAPS_CONFIG_CMD_MEMADDR64K_CF_V(maddr >> 16) |
-                      FW_LEN16(*caps_cmd));
-
-        if (csio_mb_issue(hw, mbp)) {
-                csio_err(hw, "Issue of FW_CAPS_CONFIG_CMD failed!\n");
-                goto out;
-        }
-
-        ret = csio_mb_fw_retval(mbp);
-        if (ret != FW_SUCCESS) {
-                csio_dbg(hw, "FW_CAPS_CONFIG_CMD returned %d!\n", rv);
-                goto out;
-        }
-
-        if (finiver)
-                *finiver = ntohl(caps_cmd->finiver);
-        if (finicsum)
-                *finicsum = ntohl(caps_cmd->finicsum);
-        if (cfcsum)
-                *cfcsum = ntohl(caps_cmd->cfcsum);
-
-        /* Validate device capabilities */
-        if (csio_hw_validate_caps(hw, mbp)) {
-                rv = -ENOENT;
-                goto out;
-        }
-
-        /*
-         * And now tell the firmware to use the configuration we just loaded.
-         */
-        caps_cmd->op_to_write =
-                htonl(FW_CMD_OP_V(FW_CAPS_CONFIG_CMD) |
-                      FW_CMD_REQUEST_F |
-                      FW_CMD_WRITE_F);
-        caps_cmd->cfvalid_to_len16 = htonl(FW_LEN16(*caps_cmd));
-
-        if (csio_mb_issue(hw, mbp)) {
-                csio_err(hw, "Issue of FW_CAPS_CONFIG_CMD failed!\n");
-                goto out;
-        }
-
-        ret = csio_mb_fw_retval(mbp);
-        if (ret != FW_SUCCESS) {
-                csio_dbg(hw, "FW_CAPS_CONFIG_CMD returned %d!\n", rv);
-                goto out;
-        }
-
-        rv = 0;
-out:
-        mempool_free(mbp, hw->mb_mempool);
-        return rv;
-}
-
 /*
  * csio_get_device_params - Get device parameters.
  * @hw: HW module
@@ -1547,7 +1372,8 @@ csio_config_device_caps(struct csio_hw *hw)
         }
 
         /* Validate device capabilities */
-        if (csio_hw_validate_caps(hw, mbp))
+        rv = csio_hw_validate_caps(hw, mbp);
+        if (rv != 0)
                 goto out;
 
         /* Don't config device capabilities if already configured */
@@ -1756,9 +1582,9 @@ csio_hw_flash_config(struct csio_hw *hw, u32 *fw_cfg_param, char *path)
         uint32_t *cfg_data;
         int value_to_add = 0;
 
-        if (request_firmware(&cf, CSIO_CF_FNAME(hw), dev) < 0) {
+        if (request_firmware(&cf, FW_CFG_NAME_T5, dev) < 0) {
                 csio_err(hw, "could not find config file %s, err: %d\n",
-                         CSIO_CF_FNAME(hw), ret);
+                         FW_CFG_NAME_T5, ret);
                 return -ENOENT;
         }
 
@@ -1798,8 +1624,8 @@ csio_hw_flash_config(struct csio_hw *hw, u32 *fw_cfg_param, char *path)
         }
         if (ret == 0) {
                 csio_info(hw, "config file upgraded to %s\n",
-                          CSIO_CF_FNAME(hw));
-                snprintf(path, 64, "%s%s", "/lib/firmware/", CSIO_CF_FNAME(hw));
+                          FW_CFG_NAME_T5);
+                snprintf(path, 64, "%s%s", "/lib/firmware/", FW_CFG_NAME_T5);
         }
 
 leave:
@@ -1827,11 +1653,13 @@ leave:
 static int
 csio_hw_use_fwconfig(struct csio_hw *hw, int reset, u32 *fw_cfg_param)
 {
+        struct csio_mb  *mbp = NULL;
+        struct fw_caps_config_cmd *caps_cmd;
         unsigned int mtype, maddr;
-        int rv;
+        int rv = -EINVAL;
         uint32_t finiver = 0, finicsum = 0, cfcsum = 0;
-        int using_flash;
         char path[64];
+        char *config_name = NULL;
 
         /*
          * Reset device if necessary
@@ -1851,51 +1679,107 @@ csio_hw_use_fwconfig(struct csio_hw *hw, int reset, u32 *fw_cfg_param)
         rv = csio_hw_flash_config(hw, fw_cfg_param, path);
         spin_lock_irq(&hw->lock);
         if (rv != 0) {
-                if (rv == -ENOENT) {
-                        /*
-                         * config file was not found. Use default
-                         * config file from flash.
-                         */
-                        mtype = FW_MEMTYPE_CF_FLASH;
-                        maddr = hw->chip_ops->chip_flash_cfg_addr(hw);
-                        using_flash = 1;
-                } else {
-                        /*
-                         * we revert back to the hardwired config if
-                         * flashing failed.
-                         */
-                        goto bye;
-                }
+                /*
+                 * config file was not found. Use default
+                 * config file from flash.
+                 */
+                config_name = "On FLASH";
+                mtype = FW_MEMTYPE_CF_FLASH;
+                maddr = hw->chip_ops->chip_flash_cfg_addr(hw);
         } else {
+                config_name = path;
                 mtype = FW_PARAMS_PARAM_Y_G(*fw_cfg_param);
                 maddr = FW_PARAMS_PARAM_Z_G(*fw_cfg_param) << 16;
-                using_flash = 0;
         }
 
-        hw->cfg_store = (uint8_t)mtype;
+        mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
+        if (!mbp) {
+                CSIO_INC_STATS(hw, n_err_nomem);
+                return -ENOMEM;
+        }
+        /*
+         * Tell the firmware to process the indicated Configuration File.
+         * If there are no errors and the caller has provided return value
+         * pointers for the [fini] section version, checksum and computed
+         * checksum, pass those back to the caller.
+         */
+        caps_cmd = (struct fw_caps_config_cmd *)(mbp->mb);
+        CSIO_INIT_MBP(mbp, caps_cmd, CSIO_MB_DEFAULT_TMO, hw, NULL, 1);
+        caps_cmd->op_to_write =
+                htonl(FW_CMD_OP_V(FW_CAPS_CONFIG_CMD) |
+                      FW_CMD_REQUEST_F |
+                      FW_CMD_READ_F);
+        caps_cmd->cfvalid_to_len16 =
+                htonl(FW_CAPS_CONFIG_CMD_CFVALID_F |
+                      FW_CAPS_CONFIG_CMD_MEMTYPE_CF_V(mtype) |
+                      FW_CAPS_CONFIG_CMD_MEMADDR64K_CF_V(maddr >> 16) |
+                      FW_LEN16(*caps_cmd));
+
+        if (csio_mb_issue(hw, mbp)) {
+                rv = -EINVAL;
+                goto bye;
+        }
+
+        rv = csio_mb_fw_retval(mbp);
+         /* If the CAPS_CONFIG failed with an ENOENT (for a Firmware
+          * Configuration File in FLASH), our last gasp effort is to use the
+          * Firmware Configuration File which is embedded in the
+          * firmware.  A very few early versions of the firmware didn't
+          * have one embedded but we can ignore those.
+          */
+        if (rv == ENOENT) {
+                CSIO_INIT_MBP(mbp, caps_cmd, CSIO_MB_DEFAULT_TMO, hw, NULL, 1);
+                caps_cmd->op_to_write = htonl(FW_CMD_OP_V(FW_CAPS_CONFIG_CMD) |
+                                              FW_CMD_REQUEST_F |
+                                              FW_CMD_READ_F);
+                caps_cmd->cfvalid_to_len16 = htonl(FW_LEN16(*caps_cmd));
+
+                if (csio_mb_issue(hw, mbp)) {
+                        rv = -EINVAL;
+                        goto bye;
+                }
+
+                rv = csio_mb_fw_retval(mbp);
+                config_name = "Firmware Default";
+        }
+        if (rv != FW_SUCCESS)
+                goto bye;
+
+        finiver = ntohl(caps_cmd->finiver);
+        finicsum = ntohl(caps_cmd->finicsum);
+        cfcsum = ntohl(caps_cmd->cfcsum);
 
         /*
-         * Issue a Capability Configuration command to the firmware to get it
-         * to parse the Configuration File.
+         * And now tell the firmware to use the configuration we just loaded.
          */
-        rv = csio_hw_fw_config_file(hw, mtype, maddr, &finiver,
-                &finicsum, &cfcsum);
-        if (rv != 0)
+        caps_cmd->op_to_write =
+                htonl(FW_CMD_OP_V(FW_CAPS_CONFIG_CMD) |
+                      FW_CMD_REQUEST_F |
+                      FW_CMD_WRITE_F);
+        caps_cmd->cfvalid_to_len16 = htonl(FW_LEN16(*caps_cmd));
+
+        if (csio_mb_issue(hw, mbp)) {
+                rv = -EINVAL;
                 goto bye;
+        }
 
-        hw->cfg_finiver         = finiver;
-        hw->cfg_finicsum        = finicsum;
-        hw->cfg_cfcsum          = cfcsum;
-        hw->cfg_csum_status     = true;
+        rv = csio_mb_fw_retval(mbp);
+        if (rv != FW_SUCCESS) {
+                csio_dbg(hw, "FW_CAPS_CONFIG_CMD returned %d!\n", rv);
+                goto bye;
+        }
 
+        mempool_free(mbp, hw->mb_mempool);
         if (finicsum != cfcsum) {
                 csio_warn(hw,
                       "Config File checksum mismatch: csum=%#x, computed=%#x\n",
                       finicsum, cfcsum);
-
-                hw->cfg_csum_status = false;
         }
 
+        /* Validate device capabilities */
+        rv = csio_hw_validate_caps(hw, mbp);
+        if (rv != 0)
+                goto bye;
         /*
          * Note that we're operating with parameters
          * not supplied by the driver, rather than from hard-wired
@@ -1918,56 +1802,184 @@ csio_hw_use_fwconfig(struct csio_hw *hw, int reset, u32 *fw_cfg_param)
         /* Post event to notify completion of configuration */
         csio_post_event(&hw->sm, CSIO_HWE_INIT);
 
-        csio_info(hw,
-         "Firmware Configuration File %s, version %#x, computed checksum %#x\n",
-                  (using_flash ? "in device FLASH" : path), finiver, cfcsum);
-
+        csio_info(hw, "Successfully configure using Firmware "
+                  "Configuration File %s, version %#x, computed checksum %#x\n",
+                  config_name, finiver, cfcsum);
         return 0;
 
         /*
          * Something bad happened.  Return the error ...
          */
 bye:
+        if (mbp)
+                mempool_free(mbp, hw->mb_mempool);
         hw->flags &= ~CSIO_HWF_USING_SOFT_PARAMS;
-        csio_dbg(hw, "Configuration file error %d\n", rv);
+        csio_warn(hw, "Configuration file error %d\n", rv);
         return rv;
 }
 
-/*
- * Attempt to initialize the adapter via hard-coded, driver supplied
- * parameters ...
+/* Is the given firmware API compatible with the one the driver was compiled
+ * with?
  */
-static int
-csio_hw_no_fwconfig(struct csio_hw *hw, int reset)
+static int fw_compatible(const struct fw_hdr *hdr1, const struct fw_hdr *hdr2)
 {
-        int             rv;
-        /*
-         * Reset device if necessary
-         */
-        if (reset) {
-                rv = csio_do_reset(hw, true);
-                if (rv != 0)
-                        goto out;
+
+        /* short circuit if it's the exact same firmware version */
+        if (hdr1->chip == hdr2->chip && hdr1->fw_ver == hdr2->fw_ver)
+                return 1;
+
+#define SAME_INTF(x) (hdr1->intfver_##x == hdr2->intfver_##x)
+        if (hdr1->chip == hdr2->chip && SAME_INTF(nic) && SAME_INTF(vnic) &&
+            SAME_INTF(ri) && SAME_INTF(iscsi) && SAME_INTF(fcoe))
+                return 1;
+#undef SAME_INTF
+
+        return 0;
+}
+
+/* The firmware in the filesystem is usable, but should it be installed?
+ * This routine explains itself in detail if it indicates the filesystem
+ * firmware should be installed.
+ */
+static int csio_should_install_fs_fw(struct csio_hw *hw, int card_fw_usable,
+                                int k, int c)
+{
+        const char *reason;
+
+        if (!card_fw_usable) {
+                reason = "incompatible or unusable";
+                goto install;
         }
 
-        /* Get and set device capabilities */
-        rv = csio_config_device_caps(hw);
-        if (rv != 0)
-                goto out;
+        if (k > c) {
+                reason = "older than the version supported with this driver";
+                goto install;
+        }
 
-        /* device parameters */
-        rv = csio_get_device_params(hw);
-        if (rv != 0)
-                goto out;
+        return 0;
 
-        /* Configure SGE */
-        csio_wr_sge_init(hw);
+install:
+        csio_err(hw, "firmware on card (%u.%u.%u.%u) is %s, "
+                "installing firmware %u.%u.%u.%u on card.\n",
+                FW_HDR_FW_VER_MAJOR_G(c), FW_HDR_FW_VER_MINOR_G(c),
+                FW_HDR_FW_VER_MICRO_G(c), FW_HDR_FW_VER_BUILD_G(c), reason,
+                FW_HDR_FW_VER_MAJOR_G(k), FW_HDR_FW_VER_MINOR_G(k),
+                FW_HDR_FW_VER_MICRO_G(k), FW_HDR_FW_VER_BUILD_G(k));
 
-        /* Post event to notify completion of configuration */
-        csio_post_event(&hw->sm, CSIO_HWE_INIT);
+        return 1;
+}
 
-out:
-        return rv;
+static struct fw_info fw_info_array[] = {
+        {
+                .chip = CHELSIO_T5,
+                .fs_name = FW_CFG_NAME_T5,
+                .fw_mod_name = FW_FNAME_T5,
+                .fw_hdr = {
+                        .chip = FW_HDR_CHIP_T5,
+                        .fw_ver = __cpu_to_be32(FW_VERSION(T5)),
+                        .intfver_nic = FW_INTFVER(T5, NIC),
+                        .intfver_vnic = FW_INTFVER(T5, VNIC),
+                        .intfver_ri = FW_INTFVER(T5, RI),
+                        .intfver_iscsi = FW_INTFVER(T5, ISCSI),
+                        .intfver_fcoe = FW_INTFVER(T5, FCOE),
+                },
+        }
+};
+
+static struct fw_info *find_fw_info(int chip)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(fw_info_array); i++) {
+                if (fw_info_array[i].chip == chip)
+                        return &fw_info_array[i];
+        }
+        return NULL;
+}
+
+static int csio_hw_prep_fw(struct csio_hw *hw, struct fw_info *fw_info,
+               const u8 *fw_data, unsigned int fw_size,
+               struct fw_hdr *card_fw, enum csio_dev_state state,
+               int *reset)
+{
+        int ret, card_fw_usable, fs_fw_usable;
+        const struct fw_hdr *fs_fw;
+        const struct fw_hdr *drv_fw;
+
+        drv_fw = &fw_info->fw_hdr;
+
+        /* Read the header of the firmware on the card */
+        ret = csio_hw_read_flash(hw, FLASH_FW_START,
+                            sizeof(*card_fw) / sizeof(uint32_t),
+                            (uint32_t *)card_fw, 1);
+        if (ret == 0) {
+                card_fw_usable = fw_compatible(drv_fw, (const void *)card_fw);
+        } else {
+                csio_err(hw,
+                        "Unable to read card's firmware header: %d\n", ret);
+                card_fw_usable = 0;
+        }
+
+        if (fw_data != NULL) {
+                fs_fw = (const void *)fw_data;
+                fs_fw_usable = fw_compatible(drv_fw, fs_fw);
+        } else {
+                fs_fw = NULL;
+                fs_fw_usable = 0;
+        }
+
+        if (card_fw_usable && card_fw->fw_ver == drv_fw->fw_ver &&
+            (!fs_fw_usable || fs_fw->fw_ver == drv_fw->fw_ver)) {
+                /* Common case: the firmware on the card is an exact match and
+                 * the filesystem one is an exact match too, or the filesystem
+                 * one is absent/incompatible.
+                 */
+        } else if (fs_fw_usable && state == CSIO_DEV_STATE_UNINIT &&
+                   csio_should_install_fs_fw(hw, card_fw_usable,
+                                        be32_to_cpu(fs_fw->fw_ver),
+                                        be32_to_cpu(card_fw->fw_ver))) {
+                ret = csio_hw_fw_upgrade(hw, hw->pfn, fw_data,
+                                     fw_size, 0);
+                if (ret != 0) {
+                        csio_err(hw,
+                                "failed to install firmware: %d\n", ret);
+                        goto bye;
+                }
+
+                /* Installed successfully, update the cached header too. */
+                memcpy(card_fw, fs_fw, sizeof(*card_fw));
+                card_fw_usable = 1;
+                *reset = 0;     /* already reset as part of load_fw */
+        }
+
+        if (!card_fw_usable) {
+                uint32_t d, c, k;
+
+                d = be32_to_cpu(drv_fw->fw_ver);
+                c = be32_to_cpu(card_fw->fw_ver);
+                k = fs_fw ? be32_to_cpu(fs_fw->fw_ver) : 0;
+
+                csio_err(hw, "Cannot find a usable firmware: "
+                        "chip state %d, "
+                        "driver compiled with %d.%d.%d.%d, "
+                        "card has %d.%d.%d.%d, filesystem has %d.%d.%d.%d\n",
+                        state,
+                        FW_HDR_FW_VER_MAJOR_G(d), FW_HDR_FW_VER_MINOR_G(d),
+                        FW_HDR_FW_VER_MICRO_G(d), FW_HDR_FW_VER_BUILD_G(d),
+                        FW_HDR_FW_VER_MAJOR_G(c), FW_HDR_FW_VER_MINOR_G(c),
+                        FW_HDR_FW_VER_MICRO_G(c), FW_HDR_FW_VER_BUILD_G(c),
+                        FW_HDR_FW_VER_MAJOR_G(k), FW_HDR_FW_VER_MINOR_G(k),
+                        FW_HDR_FW_VER_MICRO_G(k), FW_HDR_FW_VER_BUILD_G(k));
+                ret = EINVAL;
+                goto bye;
+        }
+
+        /* We're using whatever's on the card and it's known to be good. */
+        hw->fwrev = be32_to_cpu(card_fw->fw_ver);
+        hw->tp_vers = be32_to_cpu(card_fw->tp_microcode_ver);
+
+bye:
+        return ret;
 }
 
 /*
@@ -1977,48 +1989,52 @@ out:
  * latest firmware ECANCELED is returned
  */
 static int
-csio_hw_flash_fw(struct csio_hw *hw)
+csio_hw_flash_fw(struct csio_hw *hw, int *reset)
 {
         int ret = -ECANCELED;
         const struct firmware *fw;
-        const struct fw_hdr *hdr;
-        u32 fw_ver;
+        struct fw_info *fw_info;
+        struct fw_hdr *card_fw;
         struct pci_dev *pci_dev = hw->pdev;
         struct device *dev = &pci_dev->dev ;
+        const u8 *fw_data = NULL;
+        unsigned int fw_size = 0;
 
-        if (request_firmware(&fw, CSIO_FW_FNAME(hw), dev) < 0) {
-                csio_err(hw, "could not find firmware image %s, err: %d\n",
-                         CSIO_FW_FNAME(hw), ret);
+        /* This is the firmware whose headers the driver was compiled
+         * against
+         */
+        fw_info = find_fw_info(CHELSIO_CHIP_VERSION(hw->chip_id));
+        if (fw_info == NULL) {
+                csio_err(hw,
+                        "unable to get firmware info for chip %d.\n",
+                        CHELSIO_CHIP_VERSION(hw->chip_id));
                 return -EINVAL;
         }
 
-        hdr = (const struct fw_hdr *)fw->data;
-        fw_ver = ntohl(hdr->fw_ver);
-        if (FW_HDR_FW_VER_MAJOR_G(fw_ver) != FW_VERSION_MAJOR(hw))
-                return -EINVAL;      /* wrong major version, won't do */
+        if (request_firmware(&fw, FW_FNAME_T5, dev) < 0) {
+                csio_err(hw, "could not find firmware image %s, err: %d\n",
+                         FW_FNAME_T5, ret);
+        } else {
+                fw_data = fw->data;
+                fw_size = fw->size;
+        }
 
-        /*
-         * If the flash FW is unusable or we found something newer, load it.
+        /* allocate memory to read the header of the firmware on the
+         * card
          */
-        if (FW_HDR_FW_VER_MAJOR_G(hw->fwrev) != FW_VERSION_MAJOR(hw) ||
-            fw_ver > hw->fwrev) {
-                ret = csio_hw_fw_upgrade(hw, hw->pfn, fw->data, fw->size,
-                                    /*force=*/false);
-                if (!ret)
-                        csio_info(hw,
-                                  "firmware upgraded to version %pI4 from %s\n",
-                                  &hdr->fw_ver, CSIO_FW_FNAME(hw));
-                else
-                        csio_err(hw, "firmware upgrade failed! err=%d\n", ret);
-        } else
-                ret = -EINVAL;
+        card_fw = kmalloc(sizeof(*card_fw), GFP_KERNEL);
 
-        release_firmware(fw);
+        /* upgrade FW logic */
+        ret = csio_hw_prep_fw(hw, fw_info, fw_data, fw_size, card_fw,
+                         hw->fw_state, reset);
 
+        /* Cleaning up */
+        if (fw != NULL)
+                release_firmware(fw);
+        kfree(card_fw);
         return ret;
 }
 
-
 /*
  * csio_hw_configure - Configure HW
  * @hw - HW module
@@ -2039,7 +2055,7 @@ csio_hw_configure(struct csio_hw *hw)
         }
 
         /* HW version */
-        hw->chip_ver = (char)csio_rd_reg32(hw, PL_REV);
+        hw->chip_ver = (char)csio_rd_reg32(hw, PL_REV_A);
 
         /* Needed for FW download */
         rv = csio_hw_get_flash_params(hw);
@@ -2074,50 +2090,43 @@ csio_hw_configure(struct csio_hw *hw)
         if (rv != 0)
                 goto out;
 
+        csio_hw_get_fw_version(hw, &hw->fwrev);
+        csio_hw_get_tp_version(hw, &hw->tp_vers);
         if (csio_is_hw_master(hw) && hw->fw_state != CSIO_DEV_STATE_INIT) {
-                rv = csio_hw_check_fw_version(hw);
-                if (rv == -EINVAL) {
 
                         /* Do firmware update */
-                        spin_unlock_irq(&hw->lock);
-                        rv = csio_hw_flash_fw(hw);
-                        spin_lock_irq(&hw->lock);
+                spin_unlock_irq(&hw->lock);
+                rv = csio_hw_flash_fw(hw, &reset);
+                spin_lock_irq(&hw->lock);
 
-                        if (rv == 0) {
-                                reset = 0;
-                                /*
-                                 * Note that the chip was reset as part of the
-                                 * firmware upgrade so we don't reset it again
-                                 * below and grab the new firmware version.
-                                 */
-                                rv = csio_hw_check_fw_version(hw);
-                        }
-                }
-                /*
-                 * If the firmware doesn't support Configuration
-                 * Files, use the old Driver-based, hard-wired
-                 * initialization.  Otherwise, try using the
-                 * Configuration File support and fall back to the
-                 * Driver-based initialization if there's no
-                 * Configuration File found.
+                if (rv != 0)
+                        goto out;
+
+                /* If the firmware doesn't support Configuration Files,
+                 * return an error.
                  */
-                if (csio_hw_check_fwconfig(hw, param) == 0) {
-                        rv = csio_hw_use_fwconfig(hw, reset, param);
-                        if (rv == -ENOENT)
-                                goto out;
-                        if (rv != 0) {
-                                csio_info(hw,
-                                    "No Configuration File present "
-                                    "on adapter.  Using hard-wired "
-                                    "configuration parameters.\n");
-                                rv = csio_hw_no_fwconfig(hw, reset);
-                        }
-                } else {
-                        rv = csio_hw_no_fwconfig(hw, reset);
+                rv = csio_hw_check_fwconfig(hw, param);
+                if (rv != 0) {
+                        csio_info(hw, "Firmware doesn't support "
+                                  "Firmware Configuration files\n");
+                        goto out;
                 }
 
-                if (rv != 0)
+                /* The firmware provides us with a memory buffer where we can
+                 * load a Configuration File from the host if we want to
+                 * override the Configuration File in flash.
+                 */
+                rv = csio_hw_use_fwconfig(hw, reset, param);
+                if (rv == -ENOENT) {
+                        csio_info(hw, "Could not initialize "
+                                  "adapter, error%d\n", rv);
+                        goto out;
+                }
+                if (rv != 0) {
+                        csio_info(hw, "Could not initialize "
+                                  "adapter, error%d\n", rv);
                         goto out;
+                }
 
         } else {
                 if (hw->fw_state == CSIO_DEV_STATE_INIT) {
@@ -2217,7 +2226,7 @@ out:
         return;
 }
 
-#define PF_INTR_MASK (PFSW | PFCIM)
+#define PF_INTR_MASK (PFSW_F | PFCIM_F)
 
 /*
  * csio_hw_intr_enable - Enable HW interrupts
@@ -2229,21 +2238,21 @@ static void
 csio_hw_intr_enable(struct csio_hw *hw)
 {
         uint16_t vec = (uint16_t)csio_get_mb_intr_idx(csio_hw_to_mbm(hw));
-        uint32_t pf = SOURCEPF_GET(csio_rd_reg32(hw, PL_WHOAMI));
-        uint32_t pl = csio_rd_reg32(hw, PL_INT_ENABLE);
+        uint32_t pf = SOURCEPF_G(csio_rd_reg32(hw, PL_WHOAMI_A));
+        uint32_t pl = csio_rd_reg32(hw, PL_INT_ENABLE_A);
 
         /*
          * Set aivec for MSI/MSIX. PCIE_PF_CFG.INTXType is set up
          * by FW, so do nothing for INTX.
          */
         if (hw->intr_mode == CSIO_IM_MSIX)
-                csio_set_reg_field(hw, MYPF_REG(PCIE_PF_CFG),
-                                   AIVEC(AIVEC_MASK), vec);
+                csio_set_reg_field(hw, MYPF_REG(PCIE_PF_CFG_A),
+                                   AIVEC_V(AIVEC_M), vec);
         else if (hw->intr_mode == CSIO_IM_MSI)
-                csio_set_reg_field(hw, MYPF_REG(PCIE_PF_CFG),
-                                   AIVEC(AIVEC_MASK), 0);
+                csio_set_reg_field(hw, MYPF_REG(PCIE_PF_CFG_A),
+                                   AIVEC_V(AIVEC_M), 0);
 
-        csio_wr_reg32(hw, PF_INTR_MASK, MYPF_REG(PL_PF_INT_ENABLE));
+        csio_wr_reg32(hw, PF_INTR_MASK, MYPF_REG(PL_PF_INT_ENABLE_A));
 
         /* Turn on MB interrupts - this will internally flush PIO as well */
         csio_mb_intr_enable(hw);
@@ -2253,19 +2262,19 @@ csio_hw_intr_enable(struct csio_hw *hw)
                 /*
                  * Disable the Serial FLASH interrupt, if enabled!
                  */
-                pl &= (~SF);
-                csio_wr_reg32(hw, pl, PL_INT_ENABLE);
+                pl &= (~SF_F);
+                csio_wr_reg32(hw, pl, PL_INT_ENABLE_A);
 
-                csio_wr_reg32(hw, ERR_CPL_EXCEED_IQE_SIZE |
-                              EGRESS_SIZE_ERR | ERR_INVALID_CIDX_INC |
-                              ERR_CPL_OPCODE_0 | ERR_DROPPED_DB |
-                              ERR_DATA_CPL_ON_HIGH_QID1 |
-                              ERR_DATA_CPL_ON_HIGH_QID0 | ERR_BAD_DB_PIDX3 |
-                              ERR_BAD_DB_PIDX2 | ERR_BAD_DB_PIDX1 |
-                              ERR_BAD_DB_PIDX0 | ERR_ING_CTXT_PRIO |
-                              ERR_EGR_CTXT_PRIO | INGRESS_SIZE_ERR,
-                              SGE_INT_ENABLE3);
-                csio_set_reg_field(hw, PL_INT_MAP0, 0, 1 << pf);
+                csio_wr_reg32(hw, ERR_CPL_EXCEED_IQE_SIZE_F |
+                              EGRESS_SIZE_ERR_F | ERR_INVALID_CIDX_INC_F |
+                              ERR_CPL_OPCODE_0_F | ERR_DROPPED_DB_F |
+                              ERR_DATA_CPL_ON_HIGH_QID1_F |
+                              ERR_DATA_CPL_ON_HIGH_QID0_F | ERR_BAD_DB_PIDX3_F |
+                              ERR_BAD_DB_PIDX2_F | ERR_BAD_DB_PIDX1_F |
+                              ERR_BAD_DB_PIDX0_F | ERR_ING_CTXT_PRIO_F |
+                              ERR_EGR_CTXT_PRIO_F | INGRESS_SIZE_ERR_F,
+                              SGE_INT_ENABLE3_A);
+                csio_set_reg_field(hw, PL_INT_MAP0_A, 0, 1 << pf);
         }
 
         hw->flags |= CSIO_HWF_HW_INTR_ENABLED;
@@ -2281,16 +2290,16 @@ csio_hw_intr_enable(struct csio_hw *hw)
 void
 csio_hw_intr_disable(struct csio_hw *hw)
 {
-        uint32_t pf = SOURCEPF_GET(csio_rd_reg32(hw, PL_WHOAMI));
+        uint32_t pf = SOURCEPF_G(csio_rd_reg32(hw, PL_WHOAMI_A));
 
         if (!(hw->flags & CSIO_HWF_HW_INTR_ENABLED))
                 return;
 
         hw->flags &= ~CSIO_HWF_HW_INTR_ENABLED;
 
-        csio_wr_reg32(hw, 0, MYPF_REG(PL_PF_INT_ENABLE));
+        csio_wr_reg32(hw, 0, MYPF_REG(PL_PF_INT_ENABLE_A));
         if (csio_is_hw_master(hw))
-                csio_set_reg_field(hw, PL_INT_MAP0, 1 << pf, 0);
+                csio_set_reg_field(hw, PL_INT_MAP0_A, 1 << pf, 0);
 
         /* Turn off MB interrupts */
         csio_mb_intr_disable(hw);
@@ -2300,7 +2309,7 @@ csio_hw_intr_disable(struct csio_hw *hw)
 void
 csio_hw_fatal_err(struct csio_hw *hw)
 {
-        csio_set_reg_field(hw, SGE_CONTROL, GLOBALENABLE, 0);
+        csio_set_reg_field(hw, SGE_CONTROL_A, GLOBALENABLE_F, 0);
         csio_hw_intr_disable(hw);
 
         /* Do not reset HW, we may need FW state for debugging */
@@ -2594,7 +2603,7 @@ csio_hws_removing(struct csio_hw *hw, enum csio_hw_ev evt)
                  * register directly.
                  */
                 csio_err(hw, "Resetting HW and waiting 2 seconds...\n");
-                csio_wr_reg32(hw, PIORSTMODE | PIORST, PL_RST);
+                csio_wr_reg32(hw, PIORSTMODE_F | PIORST_F, PL_RST_A);
                 mdelay(2000);
                 break;
 
@@ -2682,11 +2691,11 @@ static void csio_tp_intr_handler(struct csio_hw *hw)
 {
         static struct intr_info tp_intr_info[] = {
                 { 0x3fffffff, "TP parity error", -1, 1 },
-                { FLMTXFLSTEMPTY, "TP out of Tx pages", -1, 1 },
+                { FLMTXFLSTEMPTY_F, "TP out of Tx pages", -1, 1 },
                 { 0, NULL, 0, 0 }
         };
 
-        if (csio_handle_intr_status(hw, TP_INT_CAUSE, tp_intr_info))
+        if (csio_handle_intr_status(hw, TP_INT_CAUSE_A, tp_intr_info))
                 csio_hw_fatal_err(hw);
 }
 
@@ -2698,52 +2707,52 @@ static void csio_sge_intr_handler(struct csio_hw *hw)
         uint64_t v;
 
         static struct intr_info sge_intr_info[] = {
-                { ERR_CPL_EXCEED_IQE_SIZE,
+                { ERR_CPL_EXCEED_IQE_SIZE_F,
                   "SGE received CPL exceeding IQE size", -1, 1 },
-                { ERR_INVALID_CIDX_INC,
+                { ERR_INVALID_CIDX_INC_F,
                   "SGE GTS CIDX increment too large", -1, 0 },
-                { ERR_CPL_OPCODE_0, "SGE received 0-length CPL", -1, 0 },
-                { ERR_DROPPED_DB, "SGE doorbell dropped", -1, 0 },
-                { ERR_DATA_CPL_ON_HIGH_QID1 | ERR_DATA_CPL_ON_HIGH_QID0,
+                { ERR_CPL_OPCODE_0_F, "SGE received 0-length CPL", -1, 0 },
+                { ERR_DROPPED_DB_F, "SGE doorbell dropped", -1, 0 },
+                { ERR_DATA_CPL_ON_HIGH_QID1_F | ERR_DATA_CPL_ON_HIGH_QID0_F,
                   "SGE IQID > 1023 received CPL for FL", -1, 0 },
-                { ERR_BAD_DB_PIDX3, "SGE DBP 3 pidx increment too large", -1,
+                { ERR_BAD_DB_PIDX3_F, "SGE DBP 3 pidx increment too large", -1,
                   0 },
-                { ERR_BAD_DB_PIDX2, "SGE DBP 2 pidx increment too large", -1,
+                { ERR_BAD_DB_PIDX2_F, "SGE DBP 2 pidx increment too large", -1,
                   0 },
-                { ERR_BAD_DB_PIDX1, "SGE DBP 1 pidx increment too large", -1,
+                { ERR_BAD_DB_PIDX1_F, "SGE DBP 1 pidx increment too large", -1,
                   0 },
-                { ERR_BAD_DB_PIDX0, "SGE DBP 0 pidx increment too large", -1,
+                { ERR_BAD_DB_PIDX0_F, "SGE DBP 0 pidx increment too large", -1,
                   0 },
-                { ERR_ING_CTXT_PRIO,
+                { ERR_ING_CTXT_PRIO_F,
                   "SGE too many priority ingress contexts", -1, 0 },
-                { ERR_EGR_CTXT_PRIO,
+                { ERR_EGR_CTXT_PRIO_F,
                   "SGE too many priority egress contexts", -1, 0 },
-                { INGRESS_SIZE_ERR, "SGE illegal ingress QID", -1, 0 },
-                { EGRESS_SIZE_ERR, "SGE illegal egress QID", -1, 0 },
+                { INGRESS_SIZE_ERR_F, "SGE illegal ingress QID", -1, 0 },
+                { EGRESS_SIZE_ERR_F, "SGE illegal egress QID", -1, 0 },
                 { 0, NULL, 0, 0 }
         };
 
-        v = (uint64_t)csio_rd_reg32(hw, SGE_INT_CAUSE1) |
-            ((uint64_t)csio_rd_reg32(hw, SGE_INT_CAUSE2) << 32);
+        v = (uint64_t)csio_rd_reg32(hw, SGE_INT_CAUSE1_A) |
+            ((uint64_t)csio_rd_reg32(hw, SGE_INT_CAUSE2_A) << 32);
         if (v) {
                 csio_fatal(hw, "SGE parity error (%#llx)\n",
                             (unsigned long long)v);
                 csio_wr_reg32(hw, (uint32_t)(v & 0xFFFFFFFF),
-                                                SGE_INT_CAUSE1);
-                csio_wr_reg32(hw, (uint32_t)(v >> 32), SGE_INT_CAUSE2);
+                                                SGE_INT_CAUSE1_A);
+                csio_wr_reg32(hw, (uint32_t)(v >> 32), SGE_INT_CAUSE2_A);
         }
 
-        v |= csio_handle_intr_status(hw, SGE_INT_CAUSE3, sge_intr_info);
+        v |= csio_handle_intr_status(hw, SGE_INT_CAUSE3_A, sge_intr_info);
 
-        if (csio_handle_intr_status(hw, SGE_INT_CAUSE3, sge_intr_info) ||
+        if (csio_handle_intr_status(hw, SGE_INT_CAUSE3_A, sge_intr_info) ||
             v != 0)
                 csio_hw_fatal_err(hw);
 }
 
-#define CIM_OBQ_INTR (OBQULP0PARERR | OBQULP1PARERR | OBQULP2PARERR |\
-                      OBQULP3PARERR | OBQSGEPARERR | OBQNCSIPARERR)
-#define CIM_IBQ_INTR (IBQTP0PARERR | IBQTP1PARERR | IBQULPPARERR |\
-                      IBQSGEHIPARERR | IBQSGELOPARERR | IBQNCSIPARERR)
+#define CIM_OBQ_INTR (OBQULP0PARERR_F | OBQULP1PARERR_F | OBQULP2PARERR_F |\
+                      OBQULP3PARERR_F | OBQSGEPARERR_F | OBQNCSIPARERR_F)
+#define CIM_IBQ_INTR (IBQTP0PARERR_F | IBQTP1PARERR_F | IBQULPPARERR_F |\
+                      IBQSGEHIPARERR_F | IBQSGELOPARERR_F | IBQNCSIPARERR_F)
 
 /*
  * CIM interrupt handler.
@@ -2751,53 +2760,53 @@ static void csio_sge_intr_handler(struct csio_hw *hw)
 static void csio_cim_intr_handler(struct csio_hw *hw)
 {
         static struct intr_info cim_intr_info[] = {
-                { PREFDROPINT, "CIM control register prefetch drop", -1, 1 },
+                { PREFDROPINT_F, "CIM control register prefetch drop", -1, 1 },
                 { CIM_OBQ_INTR, "CIM OBQ parity error", -1, 1 },
                 { CIM_IBQ_INTR, "CIM IBQ parity error", -1, 1 },
-                { MBUPPARERR, "CIM mailbox uP parity error", -1, 1 },
-                { MBHOSTPARERR, "CIM mailbox host parity error", -1, 1 },
-                { TIEQINPARERRINT, "CIM TIEQ outgoing parity error", -1, 1 },
-                { TIEQOUTPARERRINT, "CIM TIEQ incoming parity error", -1, 1 },
+                { MBUPPARERR_F, "CIM mailbox uP parity error", -1, 1 },
+                { MBHOSTPARERR_F, "CIM mailbox host parity error", -1, 1 },
+                { TIEQINPARERRINT_F, "CIM TIEQ outgoing parity error", -1, 1 },
+                { TIEQOUTPARERRINT_F, "CIM TIEQ incoming parity error", -1, 1 },
                 { 0, NULL, 0, 0 }
         };
         static struct intr_info cim_upintr_info[] = {
-                { RSVDSPACEINT, "CIM reserved space access", -1, 1 },
-                { ILLTRANSINT, "CIM illegal transaction", -1, 1 },
-                { ILLWRINT, "CIM illegal write", -1, 1 },
-                { ILLRDINT, "CIM illegal read", -1, 1 },
-                { ILLRDBEINT, "CIM illegal read BE", -1, 1 },
-                { ILLWRBEINT, "CIM illegal write BE", -1, 1 },
-                { SGLRDBOOTINT, "CIM single read from boot space", -1, 1 },
-                { SGLWRBOOTINT, "CIM single write to boot space", -1, 1 },
-                { BLKWRBOOTINT, "CIM block write to boot space", -1, 1 },
-                { SGLRDFLASHINT, "CIM single read from flash space", -1, 1 },
-                { SGLWRFLASHINT, "CIM single write to flash space", -1, 1 },
-                { BLKWRFLASHINT, "CIM block write to flash space", -1, 1 },
-                { SGLRDEEPROMINT, "CIM single EEPROM read", -1, 1 },
-                { SGLWREEPROMINT, "CIM single EEPROM write", -1, 1 },
-                { BLKRDEEPROMINT, "CIM block EEPROM read", -1, 1 },
-                { BLKWREEPROMINT, "CIM block EEPROM write", -1, 1 },
-                { SGLRDCTLINT , "CIM single read from CTL space", -1, 1 },
-                { SGLWRCTLINT , "CIM single write to CTL space", -1, 1 },
-                { BLKRDCTLINT , "CIM block read from CTL space", -1, 1 },
-                { BLKWRCTLINT , "CIM block write to CTL space", -1, 1 },
-                { SGLRDPLINT , "CIM single read from PL space", -1, 1 },
-                { SGLWRPLINT , "CIM single write to PL space", -1, 1 },
-                { BLKRDPLINT , "CIM block read from PL space", -1, 1 },
-                { BLKWRPLINT , "CIM block write to PL space", -1, 1 },
-                { REQOVRLOOKUPINT , "CIM request FIFO overwrite", -1, 1 },
-                { RSPOVRLOOKUPINT , "CIM response FIFO overwrite", -1, 1 },
-                { TIMEOUTINT , "CIM PIF timeout", -1, 1 },
-                { TIMEOUTMAINT , "CIM PIF MA timeout", -1, 1 },
+                { RSVDSPACEINT_F, "CIM reserved space access", -1, 1 },
+                { ILLTRANSINT_F, "CIM illegal transaction", -1, 1 },
+                { ILLWRINT_F, "CIM illegal write", -1, 1 },
+                { ILLRDINT_F, "CIM illegal read", -1, 1 },
+                { ILLRDBEINT_F, "CIM illegal read BE", -1, 1 },
+                { ILLWRBEINT_F, "CIM illegal write BE", -1, 1 },
+                { SGLRDBOOTINT_F, "CIM single read from boot space", -1, 1 },
+                { SGLWRBOOTINT_F, "CIM single write to boot space", -1, 1 },
+                { BLKWRBOOTINT_F, "CIM block write to boot space", -1, 1 },
+                { SGLRDFLASHINT_F, "CIM single read from flash space", -1, 1 },
+                { SGLWRFLASHINT_F, "CIM single write to flash space", -1, 1 },
+                { BLKWRFLASHINT_F, "CIM block write to flash space", -1, 1 },
+                { SGLRDEEPROMINT_F, "CIM single EEPROM read", -1, 1 },
+                { SGLWREEPROMINT_F, "CIM single EEPROM write", -1, 1 },
+                { BLKRDEEPROMINT_F, "CIM block EEPROM read", -1, 1 },
+                { BLKWREEPROMINT_F, "CIM block EEPROM write", -1, 1 },
+                { SGLRDCTLINT_F, "CIM single read from CTL space", -1, 1 },
+                { SGLWRCTLINT_F, "CIM single write to CTL space", -1, 1 },
+                { BLKRDCTLINT_F, "CIM block read from CTL space", -1, 1 },
+                { BLKWRCTLINT_F, "CIM block write to CTL space", -1, 1 },
+                { SGLRDPLINT_F, "CIM single read from PL space", -1, 1 },
+                { SGLWRPLINT_F, "CIM single write to PL space", -1, 1 },
+                { BLKRDPLINT_F, "CIM block read from PL space", -1, 1 },
+                { BLKWRPLINT_F, "CIM block write to PL space", -1, 1 },
+                { REQOVRLOOKUPINT_F, "CIM request FIFO overwrite", -1, 1 },
+                { RSPOVRLOOKUPINT_F, "CIM response FIFO overwrite", -1, 1 },
+                { TIMEOUTINT_F, "CIM PIF timeout", -1, 1 },
+                { TIMEOUTMAINT_F, "CIM PIF MA timeout", -1, 1 },
                 { 0, NULL, 0, 0 }
         };
 
         int fat;
 
-        fat = csio_handle_intr_status(hw, CIM_HOST_INT_CAUSE,
-                                    cim_intr_info) +
-              csio_handle_intr_status(hw, CIM_HOST_UPACC_INT_CAUSE,
-                                    cim_upintr_info);
+        fat = csio_handle_intr_status(hw, CIM_HOST_INT_CAUSE_A,
+                                      cim_intr_info) +
+              csio_handle_intr_status(hw, CIM_HOST_UPACC_INT_CAUSE_A,
+                                      cim_upintr_info);
         if (fat)
                 csio_hw_fatal_err(hw);
 }
@@ -2813,7 +2822,7 @@ static void csio_ulprx_intr_handler(struct csio_hw *hw)
                 { 0, NULL, 0, 0 }
         };
 
-        if (csio_handle_intr_status(hw, ULP_RX_INT_CAUSE, ulprx_intr_info))
+        if (csio_handle_intr_status(hw, ULP_RX_INT_CAUSE_A, ulprx_intr_info))
                 csio_hw_fatal_err(hw);
 }
 
@@ -2823,19 +2832,19 @@ static void csio_ulprx_intr_handler(struct csio_hw *hw)
 static void csio_ulptx_intr_handler(struct csio_hw *hw)
 {
         static struct intr_info ulptx_intr_info[] = {
-                { PBL_BOUND_ERR_CH3, "ULPTX channel 3 PBL out of bounds", -1,
+                { PBL_BOUND_ERR_CH3_F, "ULPTX channel 3 PBL out of bounds", -1,
                   0 },
-                { PBL_BOUND_ERR_CH2, "ULPTX channel 2 PBL out of bounds", -1,
+                { PBL_BOUND_ERR_CH2_F, "ULPTX channel 2 PBL out of bounds", -1,
                   0 },
-                { PBL_BOUND_ERR_CH1, "ULPTX channel 1 PBL out of bounds", -1,
+                { PBL_BOUND_ERR_CH1_F, "ULPTX channel 1 PBL out of bounds", -1,
                   0 },
-                { PBL_BOUND_ERR_CH0, "ULPTX channel 0 PBL out of bounds", -1,
+                { PBL_BOUND_ERR_CH0_F, "ULPTX channel 0 PBL out of bounds", -1,
                   0 },
                 { 0xfffffff, "ULPTX parity error", -1, 1 },
                 { 0, NULL, 0, 0 }
         };
 
-        if (csio_handle_intr_status(hw, ULP_TX_INT_CAUSE, ulptx_intr_info))
+        if (csio_handle_intr_status(hw, ULP_TX_INT_CAUSE_A, ulptx_intr_info))
                 csio_hw_fatal_err(hw);
 }
 
@@ -2845,20 +2854,20 @@ static void csio_ulptx_intr_handler(struct csio_hw *hw)
 static void csio_pmtx_intr_handler(struct csio_hw *hw)
 {
         static struct intr_info pmtx_intr_info[] = {
-                { PCMD_LEN_OVFL0, "PMTX channel 0 pcmd too large", -1, 1 },
-                { PCMD_LEN_OVFL1, "PMTX channel 1 pcmd too large", -1, 1 },
-                { PCMD_LEN_OVFL2, "PMTX channel 2 pcmd too large", -1, 1 },
-                { ZERO_C_CMD_ERROR, "PMTX 0-length pcmd", -1, 1 },
+                { PCMD_LEN_OVFL0_F, "PMTX channel 0 pcmd too large", -1, 1 },
+                { PCMD_LEN_OVFL1_F, "PMTX channel 1 pcmd too large", -1, 1 },
+                { PCMD_LEN_OVFL2_F, "PMTX channel 2 pcmd too large", -1, 1 },
+                { ZERO_C_CMD_ERROR_F, "PMTX 0-length pcmd", -1, 1 },
                 { 0xffffff0, "PMTX framing error", -1, 1 },
-                { OESPI_PAR_ERROR, "PMTX oespi parity error", -1, 1 },
-                { DB_OPTIONS_PAR_ERROR, "PMTX db_options parity error", -1,
+                { OESPI_PAR_ERROR_F, "PMTX oespi parity error", -1, 1 },
+                { DB_OPTIONS_PAR_ERROR_F, "PMTX db_options parity error", -1,
                   1 },
-                { ICSPI_PAR_ERROR, "PMTX icspi parity error", -1, 1 },
-                { C_PCMD_PAR_ERROR, "PMTX c_pcmd parity error", -1, 1},
+                { ICSPI_PAR_ERROR_F, "PMTX icspi parity error", -1, 1 },
+                { PMTX_C_PCMD_PAR_ERROR_F, "PMTX c_pcmd parity error", -1, 1},
                 { 0, NULL, 0, 0 }
         };
 
-        if (csio_handle_intr_status(hw, PM_TX_INT_CAUSE, pmtx_intr_info))
+        if (csio_handle_intr_status(hw, PM_TX_INT_CAUSE_A, pmtx_intr_info))
                 csio_hw_fatal_err(hw);
 }
 
@@ -2868,17 +2877,17 @@ static void csio_pmtx_intr_handler(struct csio_hw *hw)
 static void csio_pmrx_intr_handler(struct csio_hw *hw)
 {
         static struct intr_info pmrx_intr_info[] = {
-                { ZERO_E_CMD_ERROR, "PMRX 0-length pcmd", -1, 1 },
+                { ZERO_E_CMD_ERROR_F, "PMRX 0-length pcmd", -1, 1 },
                 { 0x3ffff0, "PMRX framing error", -1, 1 },
-                { OCSPI_PAR_ERROR, "PMRX ocspi parity error", -1, 1 },
-                { DB_OPTIONS_PAR_ERROR, "PMRX db_options parity error", -1,
+                { OCSPI_PAR_ERROR_F, "PMRX ocspi parity error", -1, 1 },
+                { DB_OPTIONS_PAR_ERROR_F, "PMRX db_options parity error", -1,
                   1 },
-                { IESPI_PAR_ERROR, "PMRX iespi parity error", -1, 1 },
-                { E_PCMD_PAR_ERROR, "PMRX e_pcmd parity error", -1, 1},
+                { IESPI_PAR_ERROR_F, "PMRX iespi parity error", -1, 1 },
+                { PMRX_E_PCMD_PAR_ERROR_F, "PMRX e_pcmd parity error", -1, 1},
                 { 0, NULL, 0, 0 }
         };
 
-        if (csio_handle_intr_status(hw, PM_RX_INT_CAUSE, pmrx_intr_info))
+        if (csio_handle_intr_status(hw, PM_RX_INT_CAUSE_A, pmrx_intr_info))
                 csio_hw_fatal_err(hw);
 }
 
@@ -2888,16 +2897,16 @@ static void csio_pmrx_intr_handler(struct csio_hw *hw)
 static void csio_cplsw_intr_handler(struct csio_hw *hw)
 {
         static struct intr_info cplsw_intr_info[] = {
-                { CIM_OP_MAP_PERR, "CPLSW CIM op_map parity error", -1, 1 },
-                { CIM_OVFL_ERROR, "CPLSW CIM overflow", -1, 1 },
-                { TP_FRAMING_ERROR, "CPLSW TP framing error", -1, 1 },
-                { SGE_FRAMING_ERROR, "CPLSW SGE framing error", -1, 1 },
-                { CIM_FRAMING_ERROR, "CPLSW CIM framing error", -1, 1 },
-                { ZERO_SWITCH_ERROR, "CPLSW no-switch error", -1, 1 },
+                { CIM_OP_MAP_PERR_F, "CPLSW CIM op_map parity error", -1, 1 },
+                { CIM_OVFL_ERROR_F, "CPLSW CIM overflow", -1, 1 },
+                { TP_FRAMING_ERROR_F, "CPLSW TP framing error", -1, 1 },
+                { SGE_FRAMING_ERROR_F, "CPLSW SGE framing error", -1, 1 },
+                { CIM_FRAMING_ERROR_F, "CPLSW CIM framing error", -1, 1 },
+                { ZERO_SWITCH_ERROR_F, "CPLSW no-switch error", -1, 1 },
                 { 0, NULL, 0, 0 }
         };
 
-        if (csio_handle_intr_status(hw, CPL_INTR_CAUSE, cplsw_intr_info))
+        if (csio_handle_intr_status(hw, CPL_INTR_CAUSE_A, cplsw_intr_info))
                 csio_hw_fatal_err(hw);
 }
 
@@ -2907,15 +2916,15 @@ static void csio_cplsw_intr_handler(struct csio_hw *hw)
 static void csio_le_intr_handler(struct csio_hw *hw)
 {
         static struct intr_info le_intr_info[] = {
-                { LIPMISS, "LE LIP miss", -1, 0 },
-                { LIP0, "LE 0 LIP error", -1, 0 },
-                { PARITYERR, "LE parity error", -1, 1 },
-                { UNKNOWNCMD, "LE unknown command", -1, 1 },
-                { REQQPARERR, "LE request queue parity error", -1, 1 },
+                { LIPMISS_F, "LE LIP miss", -1, 0 },
+                { LIP0_F, "LE 0 LIP error", -1, 0 },
+                { PARITYERR_F, "LE parity error", -1, 1 },
+                { UNKNOWNCMD_F, "LE unknown command", -1, 1 },
+                { REQQPARERR_F, "LE request queue parity error", -1, 1 },
                 { 0, NULL, 0, 0 }
         };
 
-        if (csio_handle_intr_status(hw, LE_DB_INT_CAUSE, le_intr_info))
+        if (csio_handle_intr_status(hw, LE_DB_INT_CAUSE_A, le_intr_info))
                 csio_hw_fatal_err(hw);
 }
 
@@ -2929,19 +2938,22 @@ static void csio_mps_intr_handler(struct csio_hw *hw)
                 { 0, NULL, 0, 0 }
         };
         static struct intr_info mps_tx_intr_info[] = {
-                { TPFIFO, "MPS Tx TP FIFO parity error", -1, 1 },
-                { NCSIFIFO, "MPS Tx NC-SI FIFO parity error", -1, 1 },
-                { TXDATAFIFO, "MPS Tx data FIFO parity error", -1, 1 },
-                { TXDESCFIFO, "MPS Tx desc FIFO parity error", -1, 1 },
-                { BUBBLE, "MPS Tx underflow", -1, 1 },
-                { SECNTERR, "MPS Tx SOP/EOP error", -1, 1 },
-                { FRMERR, "MPS Tx framing error", -1, 1 },
+                { TPFIFO_V(TPFIFO_M), "MPS Tx TP FIFO parity error", -1, 1 },
+                { NCSIFIFO_F, "MPS Tx NC-SI FIFO parity error", -1, 1 },
+                { TXDATAFIFO_V(TXDATAFIFO_M), "MPS Tx data FIFO parity error",
+                  -1, 1 },
+                { TXDESCFIFO_V(TXDESCFIFO_M), "MPS Tx desc FIFO parity error",
+                  -1, 1 },
+                { BUBBLE_F, "MPS Tx underflow", -1, 1 },
+                { SECNTERR_F, "MPS Tx SOP/EOP error", -1, 1 },
+                { FRMERR_F, "MPS Tx framing error", -1, 1 },
                 { 0, NULL, 0, 0 }
         };
         static struct intr_info mps_trc_intr_info[] = {
-                { FILTMEM, "MPS TRC filter parity error", -1, 1 },
-                { PKTFIFO, "MPS TRC packet FIFO parity error", -1, 1 },
-                { MISCPERR, "MPS TRC misc parity error", -1, 1 },
+                { FILTMEM_V(FILTMEM_M), "MPS TRC filter parity error", -1, 1 },
+                { PKTFIFO_V(PKTFIFO_M), "MPS TRC packet FIFO parity error",
+                  -1, 1 },
+                { MISCPERR_F, "MPS TRC misc parity error", -1, 1 },
                 { 0, NULL, 0, 0 }
         };
         static struct intr_info mps_stat_sram_intr_info[] = {
@@ -2957,36 +2969,37 @@ static void csio_mps_intr_handler(struct csio_hw *hw)
                 { 0, NULL, 0, 0 }
         };
         static struct intr_info mps_cls_intr_info[] = {
-                { MATCHSRAM, "MPS match SRAM parity error", -1, 1 },
-                { MATCHTCAM, "MPS match TCAM parity error", -1, 1 },
-                { HASHSRAM, "MPS hash SRAM parity error", -1, 1 },
+                { MATCHSRAM_F, "MPS match SRAM parity error", -1, 1 },
+                { MATCHTCAM_F, "MPS match TCAM parity error", -1, 1 },
+                { HASHSRAM_F, "MPS hash SRAM parity error", -1, 1 },
                 { 0, NULL, 0, 0 }
         };
 
         int fat;
 
-        fat = csio_handle_intr_status(hw, MPS_RX_PERR_INT_CAUSE,
-                                    mps_rx_intr_info) +
-              csio_handle_intr_status(hw, MPS_TX_INT_CAUSE,
-                                    mps_tx_intr_info) +
-              csio_handle_intr_status(hw, MPS_TRC_INT_CAUSE,
-                                    mps_trc_intr_info) +
-              csio_handle_intr_status(hw, MPS_STAT_PERR_INT_CAUSE_SRAM,
-                                    mps_stat_sram_intr_info) +
-              csio_handle_intr_status(hw, MPS_STAT_PERR_INT_CAUSE_TX_FIFO,
-                                    mps_stat_tx_intr_info) +
-              csio_handle_intr_status(hw, MPS_STAT_PERR_INT_CAUSE_RX_FIFO,
-                                    mps_stat_rx_intr_info) +
-              csio_handle_intr_status(hw, MPS_CLS_INT_CAUSE,
-                                    mps_cls_intr_info);
-
-        csio_wr_reg32(hw, 0, MPS_INT_CAUSE);
-        csio_rd_reg32(hw, MPS_INT_CAUSE);                    /* flush */
+        fat = csio_handle_intr_status(hw, MPS_RX_PERR_INT_CAUSE_A,
+                                      mps_rx_intr_info) +
+              csio_handle_intr_status(hw, MPS_TX_INT_CAUSE_A,
+                                      mps_tx_intr_info) +
+              csio_handle_intr_status(hw, MPS_TRC_INT_CAUSE_A,
+                                      mps_trc_intr_info) +
+              csio_handle_intr_status(hw, MPS_STAT_PERR_INT_CAUSE_SRAM_A,
+                                      mps_stat_sram_intr_info) +
+              csio_handle_intr_status(hw, MPS_STAT_PERR_INT_CAUSE_TX_FIFO_A,
+                                      mps_stat_tx_intr_info) +
+              csio_handle_intr_status(hw, MPS_STAT_PERR_INT_CAUSE_RX_FIFO_A,
+                                      mps_stat_rx_intr_info) +
+              csio_handle_intr_status(hw, MPS_CLS_INT_CAUSE_A,
+                                      mps_cls_intr_info);
+
+        csio_wr_reg32(hw, 0, MPS_INT_CAUSE_A);
+        csio_rd_reg32(hw, MPS_INT_CAUSE_A);                    /* flush */
         if (fat)
                 csio_hw_fatal_err(hw);
 }
 
-#define MEM_INT_MASK (PERR_INT_CAUSE | ECC_CE_INT_CAUSE | ECC_UE_INT_CAUSE)
+#define MEM_INT_MASK (PERR_INT_CAUSE_F | ECC_CE_INT_CAUSE_F | \
+                      ECC_UE_INT_CAUSE_F)
 
 /*
  * EDC/MC interrupt handler.
@@ -2998,28 +3011,28 @@ static void csio_mem_intr_handler(struct csio_hw *hw, int idx)
         unsigned int addr, cnt_addr, v;
 
         if (idx <= MEM_EDC1) {
-                addr = EDC_REG(EDC_INT_CAUSE, idx);
-                cnt_addr = EDC_REG(EDC_ECC_STATUS, idx);
+                addr = EDC_REG(EDC_INT_CAUSE_A, idx);
+                cnt_addr = EDC_REG(EDC_ECC_STATUS_A, idx);
         } else {
-                addr = MC_INT_CAUSE;
-                cnt_addr = MC_ECC_STATUS;
+                addr = MC_INT_CAUSE_A;
+                cnt_addr = MC_ECC_STATUS_A;
         }
 
         v = csio_rd_reg32(hw, addr) & MEM_INT_MASK;
-        if (v & PERR_INT_CAUSE)
+        if (v & PERR_INT_CAUSE_F)
                 csio_fatal(hw, "%s FIFO parity error\n", name[idx]);
-        if (v & ECC_CE_INT_CAUSE) {
-                uint32_t cnt = ECC_CECNT_GET(csio_rd_reg32(hw, cnt_addr));
+        if (v & ECC_CE_INT_CAUSE_F) {
+                uint32_t cnt = ECC_CECNT_G(csio_rd_reg32(hw, cnt_addr));
 
-                csio_wr_reg32(hw, ECC_CECNT_MASK, cnt_addr);
+                csio_wr_reg32(hw, ECC_CECNT_V(ECC_CECNT_M), cnt_addr);
                 csio_warn(hw, "%u %s correctable ECC data error%s\n",
                             cnt, name[idx], cnt > 1 ? "s" : "");
         }
-        if (v & ECC_UE_INT_CAUSE)
+        if (v & ECC_UE_INT_CAUSE_F)
                 csio_fatal(hw, "%s uncorrectable ECC data error\n", name[idx]);
 
         csio_wr_reg32(hw, v, addr);
-        if (v & (PERR_INT_CAUSE | ECC_UE_INT_CAUSE))
+        if (v & (PERR_INT_CAUSE_F | ECC_UE_INT_CAUSE_F))
                 csio_hw_fatal_err(hw);
 }
 
@@ -3028,18 +3041,18 @@ static void csio_mem_intr_handler(struct csio_hw *hw, int idx)
  */
 static void csio_ma_intr_handler(struct csio_hw *hw)
 {
-        uint32_t v, status = csio_rd_reg32(hw, MA_INT_CAUSE);
+        uint32_t v, status = csio_rd_reg32(hw, MA_INT_CAUSE_A);
 
-        if (status & MEM_PERR_INT_CAUSE)
+        if (status & MEM_PERR_INT_CAUSE_F)
                 csio_fatal(hw, "MA parity error, parity status %#x\n",
-                            csio_rd_reg32(hw, MA_PARITY_ERROR_STATUS));
-        if (status & MEM_WRAP_INT_CAUSE) {
-                v = csio_rd_reg32(hw, MA_INT_WRAP_STATUS);
+                            csio_rd_reg32(hw, MA_PARITY_ERROR_STATUS_A));
+        if (status & MEM_WRAP_INT_CAUSE_F) {
+                v = csio_rd_reg32(hw, MA_INT_WRAP_STATUS_A);
                 csio_fatal(hw,
                    "MA address wrap-around error by client %u to address %#x\n",
-                   MEM_WRAP_CLIENT_NUM_GET(v), MEM_WRAP_ADDRESS_GET(v) << 4);
+                   MEM_WRAP_CLIENT_NUM_G(v), MEM_WRAP_ADDRESS_G(v) << 4);
         }
-        csio_wr_reg32(hw, status, MA_INT_CAUSE);
+        csio_wr_reg32(hw, status, MA_INT_CAUSE_A);
         csio_hw_fatal_err(hw);
 }
 
@@ -3049,13 +3062,13 @@ static void csio_ma_intr_handler(struct csio_hw *hw)
 static void csio_smb_intr_handler(struct csio_hw *hw)
 {
         static struct intr_info smb_intr_info[] = {
-                { MSTTXFIFOPARINT, "SMB master Tx FIFO parity error", -1, 1 },
-                { MSTRXFIFOPARINT, "SMB master Rx FIFO parity error", -1, 1 },
-                { SLVFIFOPARINT, "SMB slave FIFO parity error", -1, 1 },
+                { MSTTXFIFOPARINT_F, "SMB master Tx FIFO parity error", -1, 1 },
+                { MSTRXFIFOPARINT_F, "SMB master Rx FIFO parity error", -1, 1 },
+                { SLVFIFOPARINT_F, "SMB slave FIFO parity error", -1, 1 },
                 { 0, NULL, 0, 0 }
         };
 
-        if (csio_handle_intr_status(hw, SMB_INT_CAUSE, smb_intr_info))
+        if (csio_handle_intr_status(hw, SMB_INT_CAUSE_A, smb_intr_info))
                 csio_hw_fatal_err(hw);
 }
 
@@ -3065,14 +3078,14 @@ static void csio_smb_intr_handler(struct csio_hw *hw)
 static void csio_ncsi_intr_handler(struct csio_hw *hw)
 {
         static struct intr_info ncsi_intr_info[] = {
-                { CIM_DM_PRTY_ERR, "NC-SI CIM parity error", -1, 1 },
-                { MPS_DM_PRTY_ERR, "NC-SI MPS parity error", -1, 1 },
-                { TXFIFO_PRTY_ERR, "NC-SI Tx FIFO parity error", -1, 1 },
-                { RXFIFO_PRTY_ERR, "NC-SI Rx FIFO parity error", -1, 1 },
+                { CIM_DM_PRTY_ERR_F, "NC-SI CIM parity error", -1, 1 },
+                { MPS_DM_PRTY_ERR_F, "NC-SI MPS parity error", -1, 1 },
+                { TXFIFO_PRTY_ERR_F, "NC-SI Tx FIFO parity error", -1, 1 },
+                { RXFIFO_PRTY_ERR_F, "NC-SI Rx FIFO parity error", -1, 1 },
                 { 0, NULL, 0, 0 }
         };
 
-        if (csio_handle_intr_status(hw, NCSI_INT_CAUSE, ncsi_intr_info))
+        if (csio_handle_intr_status(hw, NCSI_INT_CAUSE_A, ncsi_intr_info))
                 csio_hw_fatal_err(hw);
 }
 
@@ -3081,17 +3094,17 @@ static void csio_ncsi_intr_handler(struct csio_hw *hw)
  */
 static void csio_xgmac_intr_handler(struct csio_hw *hw, int port)
 {
-        uint32_t v = csio_rd_reg32(hw, CSIO_MAC_INT_CAUSE_REG(hw, port));
+        uint32_t v = csio_rd_reg32(hw, T5_PORT_REG(port, MAC_PORT_INT_CAUSE_A));
 
-        v &= TXFIFO_PRTY_ERR | RXFIFO_PRTY_ERR;
+        v &= TXFIFO_PRTY_ERR_F | RXFIFO_PRTY_ERR_F;
         if (!v)
                 return;
 
-        if (v & TXFIFO_PRTY_ERR)
+        if (v & TXFIFO_PRTY_ERR_F)
                 csio_fatal(hw, "XGMAC %d Tx FIFO parity error\n", port);
-        if (v & RXFIFO_PRTY_ERR)
+        if (v & RXFIFO_PRTY_ERR_F)
                 csio_fatal(hw, "XGMAC %d Rx FIFO parity error\n", port);
-        csio_wr_reg32(hw, v, CSIO_MAC_INT_CAUSE_REG(hw, port));
+        csio_wr_reg32(hw, v, T5_PORT_REG(port, MAC_PORT_INT_CAUSE_A));
         csio_hw_fatal_err(hw);
 }
 
@@ -3101,12 +3114,12 @@ static void csio_xgmac_intr_handler(struct csio_hw *hw, int port)
 static void csio_pl_intr_handler(struct csio_hw *hw)
 {
         static struct intr_info pl_intr_info[] = {
-                { FATALPERR, "T4 fatal parity error", -1, 1 },
-                { PERRVFID, "PL VFID_MAP parity error", -1, 1 },
+                { FATALPERR_F, "T4 fatal parity error", -1, 1 },
+                { PERRVFID_F, "PL VFID_MAP parity error", -1, 1 },
                 { 0, NULL, 0, 0 }
         };
 
-        if (csio_handle_intr_status(hw, PL_PL_INT_CAUSE, pl_intr_info))
+        if (csio_handle_intr_status(hw, PL_PL_INT_CAUSE_A, pl_intr_info))
                 csio_hw_fatal_err(hw);
 }
 
@@ -3121,7 +3134,7 @@ static void csio_pl_intr_handler(struct csio_hw *hw)
 int
 csio_hw_slow_intr_handler(struct csio_hw *hw)
 {
-        uint32_t cause = csio_rd_reg32(hw, PL_INT_CAUSE);
+        uint32_t cause = csio_rd_reg32(hw, PL_INT_CAUSE_A);
 
         if (!(cause & CSIO_GLBL_INTR_MASK)) {
                 CSIO_INC_STATS(hw, n_plint_unexp);
@@ -3132,75 +3145,75 @@ csio_hw_slow_intr_handler(struct csio_hw *hw)
 
         CSIO_INC_STATS(hw, n_plint_cnt);
 
-        if (cause & CIM)
+        if (cause & CIM_F)
                 csio_cim_intr_handler(hw);
 
-        if (cause & MPS)
+        if (cause & MPS_F)
                 csio_mps_intr_handler(hw);
 
-        if (cause & NCSI)
+        if (cause & NCSI_F)
                 csio_ncsi_intr_handler(hw);
 
-        if (cause & PL)
+        if (cause & PL_F)
                 csio_pl_intr_handler(hw);
 
-        if (cause & SMB)
+        if (cause & SMB_F)
                 csio_smb_intr_handler(hw);
 
-        if (cause & XGMAC0)
+        if (cause & XGMAC0_F)
                 csio_xgmac_intr_handler(hw, 0);
 
-        if (cause & XGMAC1)
+        if (cause & XGMAC1_F)
                 csio_xgmac_intr_handler(hw, 1);
 
-        if (cause & XGMAC_KR0)
+        if (cause & XGMAC_KR0_F)
                 csio_xgmac_intr_handler(hw, 2);
 
-        if (cause & XGMAC_KR1)
+        if (cause & XGMAC_KR1_F)
                 csio_xgmac_intr_handler(hw, 3);
 
-        if (cause & PCIE)
+        if (cause & PCIE_F)
                 hw->chip_ops->chip_pcie_intr_handler(hw);
 
-        if (cause & MC)
+        if (cause & MC_F)
                 csio_mem_intr_handler(hw, MEM_MC);
 
-        if (cause & EDC0)
+        if (cause & EDC0_F)
                 csio_mem_intr_handler(hw, MEM_EDC0);
 
-        if (cause & EDC1)
+        if (cause & EDC1_F)
                 csio_mem_intr_handler(hw, MEM_EDC1);
 
-        if (cause & LE)
+        if (cause & LE_F)
                 csio_le_intr_handler(hw);
 
-        if (cause & TP)
+        if (cause & TP_F)
                 csio_tp_intr_handler(hw);
 
-        if (cause & MA)
+        if (cause & MA_F)
                 csio_ma_intr_handler(hw);
 
-        if (cause & PM_TX)
+        if (cause & PM_TX_F)
                 csio_pmtx_intr_handler(hw);
 
-        if (cause & PM_RX)
+        if (cause & PM_RX_F)
                 csio_pmrx_intr_handler(hw);
 
-        if (cause & ULP_RX)
+        if (cause & ULP_RX_F)
                 csio_ulprx_intr_handler(hw);
 
-        if (cause & CPL_SWITCH)
+        if (cause & CPL_SWITCH_F)
                 csio_cplsw_intr_handler(hw);
 
-        if (cause & SGE)
+        if (cause & SGE_F)
                 csio_sge_intr_handler(hw);
 
-        if (cause & ULP_TX)
+        if (cause & ULP_TX_F)
                 csio_ulptx_intr_handler(hw);
 
         /* Clear the interrupts just processed for which we are the master. */
-        csio_wr_reg32(hw, cause & CSIO_GLBL_INTR_MASK, PL_INT_CAUSE);
-        csio_rd_reg32(hw, PL_INT_CAUSE); /* flush */
+        csio_wr_reg32(hw, cause & CSIO_GLBL_INTR_MASK, PL_INT_CAUSE_A);
+        csio_rd_reg32(hw, PL_INT_CAUSE_A); /* flush */
 
         return 1;
 }
@@ -3840,13 +3853,7 @@ csio_hw_set_description(struct csio_hw *hw, uint16_t ven_id, uint16_t dev_id)
                 prot_type = (dev_id & CSIO_ASIC_DEVID_PROTO_MASK);
                 adap_type = (dev_id & CSIO_ASIC_DEVID_TYPE_MASK);
 
-                if (prot_type == CSIO_T4_FCOE_ASIC) {
-                        memcpy(hw->hw_ver,
-                               csio_t4_fcoe_adapters[adap_type].model_no, 16);
-                        memcpy(hw->model_desc,
-                               csio_t4_fcoe_adapters[adap_type].description,
-                               32);
-                } else if (prot_type == CSIO_T5_FCOE_ASIC) {
+                if (prot_type == CSIO_T5_FCOE_ASIC) {
                         memcpy(hw->hw_ver,
                                csio_t5_fcoe_adapters[adap_type].model_no, 16);
                         memcpy(hw->model_desc,
@@ -3883,8 +3890,8 @@ csio_hw_init(struct csio_hw *hw)
 
         strcpy(hw->name, CSIO_HW_NAME);
 
-        /* Initialize the HW chip ops with T4/T5 specific ops */
-        hw->chip_ops = csio_is_t4(hw->chip_id) ? &t4_ops : &t5_ops;
+        /* Initialize the HW chip ops T5 specific ops */
+        hw->chip_ops = &t5_ops;
 
         /* Set the model & its description */
 
diff --git a/drivers/scsi/csiostor/csio_hw.h b/drivers/scsi/csiostor/csio_hw.h
index 68248da1b9af..029bef82c057 100644
--- a/drivers/scsi/csiostor/csio_hw.h
+++ b/drivers/scsi/csiostor/csio_hw.h
@@ -48,6 +48,7 @@
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_transport_fc.h>
 
+#include "t4_hw.h"
 #include "csio_hw_chip.h"
 #include "csio_wr.h"
 #include "csio_mb.h"
@@ -117,10 +118,10 @@ extern int csio_msi;
 #define CSIO_ASIC_DEVID_PROTO_MASK              0xFF00
 #define CSIO_ASIC_DEVID_TYPE_MASK               0x00FF
 
-#define CSIO_GLBL_INTR_MASK             (CIM | MPS | PL | PCIE | MC | EDC0 | \
-                                         EDC1 | LE | TP | MA | PM_TX | PM_RX | \
-                                         ULP_RX | CPL_SWITCH | SGE | \
-                                         ULP_TX | SF)
+#define CSIO_GLBL_INTR_MASK     (CIM_F | MPS_F | PL_F | PCIE_F | MC_F | \
+                                 EDC0_F | EDC1_F | LE_F | TP_F | MA_F | \
+                                 PM_TX_F | PM_RX_F | ULP_RX_F | \
+                                 CPL_SWITCH_F | SGE_F | ULP_TX_F | SF_F)
 
 /*
  * Hard parameters used to initialize the card in the absence of a
@@ -174,16 +175,12 @@ struct csio_evt_msg {
 };
 
 enum {
-        EEPROMVSIZE    = 32768, /* Serial EEPROM virtual address space size */
         SERNUM_LEN     = 16,    /* Serial # length */
         EC_LEN         = 16,    /* E/C length */
         ID_LEN         = 16,    /* ID length */
-        TRACE_LEN      = 112,   /* length of trace data and mask */
 };
 
 enum {
-        SF_PAGE_SIZE = 256,           /* serial flash page size */
-        SF_SEC_SIZE = 64 * 1024,      /* serial flash sector size */
         SF_SIZE = SF_SEC_SIZE * 16,   /* serial flash size */
 };
 
@@ -199,39 +196,8 @@ enum {
         SF_RD_DATA_FAST = 0xb,        /* read flash */
         SF_RD_ID        = 0x9f,       /* read ID */
         SF_ERASE_SECTOR = 0xd8,       /* erase sector */
-
-        FW_START_SEC = 8,             /* first flash sector for FW */
-        FW_END_SEC = 15,              /* last flash sector for FW */
-        FW_IMG_START = FW_START_SEC * SF_SEC_SIZE,
-        FW_MAX_SIZE = (FW_END_SEC - FW_START_SEC + 1) * SF_SEC_SIZE,
-
-        FLASH_CFG_MAX_SIZE    = 0x10000 , /* max size of the flash config file*/
-        FLASH_CFG_OFFSET      = 0x1f0000,
-        FLASH_CFG_START_SEC   = FLASH_CFG_OFFSET / SF_SEC_SIZE,
 };
 
-/*
- * Flash layout.
- */
-#define FLASH_START(start)      ((start) * SF_SEC_SIZE)
-#define FLASH_MAX_SIZE(nsecs)   ((nsecs) * SF_SEC_SIZE)
-
-enum {
-        /*
-         * Location of firmware image in FLASH.
-         */
-        FLASH_FW_START_SEC = 8,
-        FLASH_FW_NSECS = 8,
-        FLASH_FW_START = FLASH_START(FLASH_FW_START_SEC),
-        FLASH_FW_MAX_SIZE = FLASH_MAX_SIZE(FLASH_FW_NSECS),
-
-        /* Location of Firmware Configuration File in FLASH. */
-        FLASH_CFG_START = FLASH_START(FLASH_CFG_START_SEC),
-};
-
-#undef FLASH_START
-#undef FLASH_MAX_SIZE
-
 /* Management module */
 enum {
         CSIO_MGMT_EQ_WRSIZE = 512,
@@ -482,11 +448,6 @@ struct csio_hw {
         uint32_t                tp_vers;
         char                    chip_ver;
         uint16_t                chip_id;                /* Tells T4/T5 chip */
-        uint32_t                cfg_finiver;
-        uint32_t                cfg_finicsum;
-        uint32_t                cfg_cfcsum;
-        uint8_t                 cfg_csum_status;
-        uint8_t                 cfg_store;
         enum csio_dev_state     fw_state;
         struct csio_vpd         vpd;
 
diff --git a/drivers/scsi/csiostor/csio_hw_chip.h b/drivers/scsi/csiostor/csio_hw_chip.h
index 4752fed476df..b56a11d817be 100644
--- a/drivers/scsi/csiostor/csio_hw_chip.h
+++ b/drivers/scsi/csiostor/csio_hw_chip.h
@@ -37,24 +37,27 @@
 #include "csio_defs.h"
 
 /* Define MACRO values */
-#define CSIO_HW_T4                              0x4000
-#define CSIO_T4_FCOE_ASIC                       0x4600
 #define CSIO_HW_T5                              0x5000
 #define CSIO_T5_FCOE_ASIC                       0x5600
 #define CSIO_HW_CHIP_MASK                       0xF000
 
-#define T4_REGMAP_SIZE                          (160 * 1024)
 #define T5_REGMAP_SIZE                          (332 * 1024)
-#define FW_FNAME_T4                             "cxgb4/t4fw.bin"
 #define FW_FNAME_T5                             "cxgb4/t5fw.bin"
-#define FW_CFG_NAME_T4                          "cxgb4/t4-config.txt"
 #define FW_CFG_NAME_T5                          "cxgb4/t5-config.txt"
 
-/* Define static functions */
-static inline int csio_is_t4(uint16_t chip)
-{
-        return (chip == CSIO_HW_T4);
-}
+#define CHELSIO_CHIP_CODE(version, revision) (((version) << 4) | (revision))
+#define CHELSIO_CHIP_FPGA          0x100
+#define CHELSIO_CHIP_VERSION(code) (((code) >> 12) & 0xf)
+#define CHELSIO_CHIP_RELEASE(code) ((code) & 0xf)
+
+#define CHELSIO_T5              0x5
+
+enum chip_type {
+        T5_A0 = CHELSIO_CHIP_CODE(CHELSIO_T5, 0),
+        T5_A1 = CHELSIO_CHIP_CODE(CHELSIO_T5, 1),
+        T5_FIRST_REV    = T5_A0,
+        T5_LAST_REV     = T5_A1,
+};
 
 static inline int csio_is_t5(uint16_t chip)
 {
@@ -65,30 +68,22 @@ static inline int csio_is_t5(uint16_t chip)
 #define CSIO_DEVICE(devid, idx)                                         \
         { PCI_VENDOR_ID_CHELSIO, (devid), PCI_ANY_ID, PCI_ANY_ID, 0, 0, (idx) }
 
-#define CSIO_HW_PIDX(hw, index)                                         \
-        (csio_is_t4(hw->chip_id) ? (PIDX(index)) :                      \
-                                        (PIDX_T5(index) | DBTYPE(1U)))
-
-#define CSIO_HW_LP_INT_THRESH(hw, val)                                  \
-        (csio_is_t4(hw->chip_id) ? (LP_INT_THRESH(val)) :               \
-                                        (V_LP_INT_THRESH_T5(val)))
-
-#define CSIO_HW_M_LP_INT_THRESH(hw)                                     \
-        (csio_is_t4(hw->chip_id) ? (LP_INT_THRESH_MASK) : (M_LP_INT_THRESH_T5))
-
-#define CSIO_MAC_INT_CAUSE_REG(hw, port)                                \
-        (csio_is_t4(hw->chip_id) ? (PORT_REG(port, XGMAC_PORT_INT_CAUSE)) : \
-                                (T5_PORT_REG(port, MAC_PORT_INT_CAUSE)))
-
-#define FW_VERSION_MAJOR(hw) (csio_is_t4(hw->chip_id) ? 1 : 0)
-#define FW_VERSION_MINOR(hw) (csio_is_t4(hw->chip_id) ? 2 : 0)
-#define FW_VERSION_MICRO(hw) (csio_is_t4(hw->chip_id) ? 8 : 0)
-
-#define CSIO_FW_FNAME(hw)                                               \
-        (csio_is_t4(hw->chip_id) ? FW_FNAME_T4 : FW_FNAME_T5)
-
-#define CSIO_CF_FNAME(hw)                                               \
-        (csio_is_t4(hw->chip_id) ? FW_CFG_NAME_T4 : FW_CFG_NAME_T5)
+#include "t4fw_api.h"
+#include "t4fw_version.h"
+
+#define FW_VERSION(chip) ( \
+                FW_HDR_FW_VER_MAJOR_G(chip##FW_VERSION_MAJOR) | \
+                FW_HDR_FW_VER_MINOR_G(chip##FW_VERSION_MINOR) | \
+                FW_HDR_FW_VER_MICRO_G(chip##FW_VERSION_MICRO) | \
+                FW_HDR_FW_VER_BUILD_G(chip##FW_VERSION_BUILD))
+#define FW_INTFVER(chip, intf) (FW_HDR_INTFVER_##intf)
+
+struct fw_info {
+        u8 chip;
+        char *fs_name;
+        char *fw_mod_name;
+        struct fw_hdr fw_hdr;
+};
 
 /* Declare ENUMS */
 enum { MEM_EDC0, MEM_EDC1, MEM_MC, MEM_MC0 = MEM_MC, MEM_MC1 };
@@ -96,7 +91,6 @@ enum { MEM_EDC0, MEM_EDC1, MEM_MC, MEM_MC0 = MEM_MC, MEM_MC1 };
 enum {
         MEMWIN_APERTURE = 2048,
         MEMWIN_BASE     = 0x1b800,
-        MEMWIN_CSIOSTOR = 6,            /* PCI-e Memory Window access */
 };
 
 /* Slow path handlers */
@@ -122,7 +116,6 @@ struct csio_hw_chip_ops {
         void (*chip_dfs_create_ext_mem)(struct csio_hw *);
 };
 
-extern struct csio_hw_chip_ops t4_ops;
 extern struct csio_hw_chip_ops t5_ops;
 
 #endif /* #ifndef __CSIO_HW_CHIP_H__ */
diff --git a/drivers/scsi/csiostor/csio_hw_t4.c b/drivers/scsi/csiostor/csio_hw_t4.c
deleted file mode 100644
index 95d831857640..000000000000
--- a/drivers/scsi/csiostor/csio_hw_t4.c
+++ /dev/null
@@ -1,404 +0,0 @@
-/*
- * This file is part of the Chelsio FCoE driver for Linux.
- *
- * Copyright (c) 2008-2013 Chelsio Communications, Inc. All rights reserved.
- *
- * This software is available to you under a choice of one of two
- * licenses.  You may choose to be licensed under the terms of the GNU
- * General Public License (GPL) Version 2, available from the file
- * OpenIB.org BSD license below:
- *
- *     Redistribution and use in source and binary forms, with or
- *     without modification, are permitted provided that the following
- *     conditions are met:
- *
- *      - Redistributions of source code must retain the above
- *        copyright notice, this list of conditions and the following
- *      - Redistributions in binary form must reproduce the above
- *        copyright notice, this list of conditions and the following
- *        disclaimer in the documentation and/or other materials
- *        provided with the distribution.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "csio_hw.h"
-#include "csio_init.h"
-
-/*
- * Return the specified PCI-E Configuration Space register from our Physical
- * Function.  We try first via a Firmware LDST Command since we prefer to let
- * the firmware own all of these registers, but if that fails we go for it
- * directly ourselves.
- */
-static uint32_t
-csio_t4_read_pcie_cfg4(struct csio_hw *hw, int reg)
-{
-        u32 val = 0;
-        struct csio_mb *mbp;
-        int rv;
-        struct fw_ldst_cmd *ldst_cmd;
-
-        mbp = mempool_alloc(hw->mb_mempool, GFP_ATOMIC);
-        if (!mbp) {
-                CSIO_INC_STATS(hw, n_err_nomem);
-                pci_read_config_dword(hw->pdev, reg, &val);
-                return val;
-        }
-
-        csio_mb_ldst(hw, mbp, CSIO_MB_DEFAULT_TMO, reg);
-        rv = csio_mb_issue(hw, mbp);
-
-        /*
-         * If the LDST Command suucceeded, exctract the returned register
-         * value.  Otherwise read it directly ourself.
-         */
-        if (rv == 0) {
-                ldst_cmd = (struct fw_ldst_cmd *)(mbp->mb);
-                val = ntohl(ldst_cmd->u.pcie.data[0]);
-        } else
-                pci_read_config_dword(hw->pdev, reg, &val);
-
-        mempool_free(mbp, hw->mb_mempool);
-
-        return val;
-}
-
-static int
-csio_t4_set_mem_win(struct csio_hw *hw, uint32_t win)
-{
-        u32 bar0;
-        u32 mem_win_base;
-
-        /*
-         * Truncation intentional: we only read the bottom 32-bits of the
-         * 64-bit BAR0/BAR1 ...  We use the hardware backdoor mechanism to
-         * read BAR0 instead of using pci_resource_start() because we could be
-         * operating from within a Virtual Machine which is trapping our
-         * accesses to our Configuration Space and we need to set up the PCI-E
-         * Memory Window decoders with the actual addresses which will be
-         * coming across the PCI-E link.
-         */
-        bar0 = csio_t4_read_pcie_cfg4(hw, PCI_BASE_ADDRESS_0);
-        bar0 &= PCI_BASE_ADDRESS_MEM_MASK;
-
-        mem_win_base = bar0 + MEMWIN_BASE;
-
-        /*
-         * Set up memory window for accessing adapter memory ranges.  (Read
-         * back MA register to ensure that changes propagate before we attempt
-         * to use the new values.)
-         */
-        csio_wr_reg32(hw, mem_win_base | BIR(0) |
-                          WINDOW(ilog2(MEMWIN_APERTURE) - 10),
-                          PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN, win));
-        csio_rd_reg32(hw,
-                      PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN, win));
-        return 0;
-}
-
-/*
- * Interrupt handler for the PCIE module.
- */
-static void
-csio_t4_pcie_intr_handler(struct csio_hw *hw)
-{
-        static struct intr_info sysbus_intr_info[] = {
-                { RNPP, "RXNP array parity error", -1, 1 },
-                { RPCP, "RXPC array parity error", -1, 1 },
-                { RCIP, "RXCIF array parity error", -1, 1 },
-                { RCCP, "Rx completions control array parity error", -1, 1 },
-                { RFTP, "RXFT array parity error", -1, 1 },
-                { 0, NULL, 0, 0 }
-        };
-        static struct intr_info pcie_port_intr_info[] = {
-                { TPCP, "TXPC array parity error", -1, 1 },
-                { TNPP, "TXNP array parity error", -1, 1 },
-                { TFTP, "TXFT array parity error", -1, 1 },
-                { TCAP, "TXCA array parity error", -1, 1 },
-                { TCIP, "TXCIF array parity error", -1, 1 },
-                { RCAP, "RXCA array parity error", -1, 1 },
-                { OTDD, "outbound request TLP discarded", -1, 1 },
-                { RDPE, "Rx data parity error", -1, 1 },
-                { TDUE, "Tx uncorrectable data error", -1, 1 },
-                { 0, NULL, 0, 0 }
-        };
-
-        static struct intr_info pcie_intr_info[] = {
-                { MSIADDRLPERR, "MSI AddrL parity error", -1, 1 },
-                { MSIADDRHPERR, "MSI AddrH parity error", -1, 1 },
-                { MSIDATAPERR, "MSI data parity error", -1, 1 },
-                { MSIXADDRLPERR, "MSI-X AddrL parity error", -1, 1 },
-                { MSIXADDRHPERR, "MSI-X AddrH parity error", -1, 1 },
-                { MSIXDATAPERR, "MSI-X data parity error", -1, 1 },
-                { MSIXDIPERR, "MSI-X DI parity error", -1, 1 },
-                { PIOCPLPERR, "PCI PIO completion FIFO parity error", -1, 1 },
-                { PIOREQPERR, "PCI PIO request FIFO parity error", -1, 1 },
-                { TARTAGPERR, "PCI PCI target tag FIFO parity error", -1, 1 },
-                { CCNTPERR, "PCI CMD channel count parity error", -1, 1 },
-                { CREQPERR, "PCI CMD channel request parity error", -1, 1 },
-                { CRSPPERR, "PCI CMD channel response parity error", -1, 1 },
-                { DCNTPERR, "PCI DMA channel count parity error", -1, 1 },
-                { DREQPERR, "PCI DMA channel request parity error", -1, 1 },
-                { DRSPPERR, "PCI DMA channel response parity error", -1, 1 },
-                { HCNTPERR, "PCI HMA channel count parity error", -1, 1 },
-                { HREQPERR, "PCI HMA channel request parity error", -1, 1 },
-                { HRSPPERR, "PCI HMA channel response parity error", -1, 1 },
-                { CFGSNPPERR, "PCI config snoop FIFO parity error", -1, 1 },
-                { FIDPERR, "PCI FID parity error", -1, 1 },
-                { INTXCLRPERR, "PCI INTx clear parity error", -1, 1 },
-                { MATAGPERR, "PCI MA tag parity error", -1, 1 },
-                { PIOTAGPERR, "PCI PIO tag parity error", -1, 1 },
-                { RXCPLPERR, "PCI Rx completion parity error", -1, 1 },
-                { RXWRPERR, "PCI Rx write parity error", -1, 1 },
-                { RPLPERR, "PCI replay buffer parity error", -1, 1 },
-                { PCIESINT, "PCI core secondary fault", -1, 1 },
-                { PCIEPINT, "PCI core primary fault", -1, 1 },
-                { UNXSPLCPLERR, "PCI unexpected split completion error", -1,
-                  0 },
-                { 0, NULL, 0, 0 }
-        };
-
-        int fat;
-        fat = csio_handle_intr_status(hw,
-                                      PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS,
-                                      sysbus_intr_info) +
-              csio_handle_intr_status(hw,
-                                      PCIE_CORE_UTL_PCI_EXPRESS_PORT_STATUS,
-                                      pcie_port_intr_info) +
-              csio_handle_intr_status(hw, PCIE_INT_CAUSE, pcie_intr_info);
-        if (fat)
-                csio_hw_fatal_err(hw);
-}
-
-/*
- * csio_t4_flash_cfg_addr - return the address of the flash configuration file
- * @hw: the HW module
- *
- * Return the address within the flash where the Firmware Configuration
- * File is stored.
- */
-static unsigned int
-csio_t4_flash_cfg_addr(struct csio_hw *hw)
-{
-        return FLASH_CFG_OFFSET;
-}
-
-/*
- *      csio_t4_mc_read - read from MC through backdoor accesses
- *      @hw: the hw module
- *      @idx: not used for T4 adapter
- *      @addr: address of first byte requested
- *      @data: 64 bytes of data containing the requested address
- *      @ecc: where to store the corresponding 64-bit ECC word
- *
- *      Read 64 bytes of data from MC starting at a 64-byte-aligned address
- *      that covers the requested address @addr.  If @parity is not %NULL it
- *      is assigned the 64-bit ECC word for the read data.
- */
-static int
-csio_t4_mc_read(struct csio_hw *hw, int idx, uint32_t addr, __be32 *data,
-                uint64_t *ecc)
-{
-        int i;
-
-        if (csio_rd_reg32(hw, MC_BIST_CMD) & START_BIST)
-                return -EBUSY;
-        csio_wr_reg32(hw, addr & ~0x3fU, MC_BIST_CMD_ADDR);
-        csio_wr_reg32(hw, 64, MC_BIST_CMD_LEN);
-        csio_wr_reg32(hw, 0xc, MC_BIST_DATA_PATTERN);
-        csio_wr_reg32(hw, BIST_OPCODE(1) | START_BIST | BIST_CMD_GAP(1),
-                      MC_BIST_CMD);
-        i = csio_hw_wait_op_done_val(hw, MC_BIST_CMD, START_BIST,
-                                     0, 10, 1, NULL);
-        if (i)
-                return i;
-
-#define MC_DATA(i) MC_BIST_STATUS_REG(MC_BIST_STATUS_RDATA, i)
-
-        for (i = 15; i >= 0; i--)
-                *data++ = htonl(csio_rd_reg32(hw, MC_DATA(i)));
-        if (ecc)
-                *ecc = csio_rd_reg64(hw, MC_DATA(16));
-#undef MC_DATA
-        return 0;
-}
-
-/*
- *      csio_t4_edc_read - read from EDC through backdoor accesses
- *      @hw: the hw module
- *      @idx: which EDC to access
- *      @addr: address of first byte requested
- *      @data: 64 bytes of data containing the requested address
- *      @ecc: where to store the corresponding 64-bit ECC word
- *
- *      Read 64 bytes of data from EDC starting at a 64-byte-aligned address
- *      that covers the requested address @addr.  If @parity is not %NULL it
- *      is assigned the 64-bit ECC word for the read data.
- */
-static int
-csio_t4_edc_read(struct csio_hw *hw, int idx, uint32_t addr, __be32 *data,
-                uint64_t *ecc)
-{
-        int i;
-
-        idx *= EDC_STRIDE;
-        if (csio_rd_reg32(hw, EDC_BIST_CMD + idx) & START_BIST)
-                return -EBUSY;
-        csio_wr_reg32(hw, addr & ~0x3fU, EDC_BIST_CMD_ADDR + idx);
-        csio_wr_reg32(hw, 64, EDC_BIST_CMD_LEN + idx);
-        csio_wr_reg32(hw, 0xc, EDC_BIST_DATA_PATTERN + idx);
-        csio_wr_reg32(hw, BIST_OPCODE(1) | BIST_CMD_GAP(1) | START_BIST,
-                      EDC_BIST_CMD + idx);
-        i = csio_hw_wait_op_done_val(hw, EDC_BIST_CMD + idx, START_BIST,
-                                     0, 10, 1, NULL);
-        if (i)
-                return i;
-
-#define EDC_DATA(i) (EDC_BIST_STATUS_REG(EDC_BIST_STATUS_RDATA, i) + idx)
-
-        for (i = 15; i >= 0; i--)
-                *data++ = htonl(csio_rd_reg32(hw, EDC_DATA(i)));
-        if (ecc)
-                *ecc = csio_rd_reg64(hw, EDC_DATA(16));
-#undef EDC_DATA
-        return 0;
-}
-
-/*
- * csio_t4_memory_rw - read/write EDC 0, EDC 1 or MC via PCIE memory window
- * @hw: the csio_hw
- * @win: PCI-E memory Window to use
- * @mtype: memory type: MEM_EDC0, MEM_EDC1, MEM_MC0 (or MEM_MC) or MEM_MC1
- * @addr: address within indicated memory type
- * @len: amount of memory to transfer
- * @buf: host memory buffer
- * @dir: direction of transfer 1 => read, 0 => write
- *
- * Reads/writes an [almost] arbitrary memory region in the firmware: the
- * firmware memory address, length and host buffer must be aligned on
- * 32-bit boudaries.  The memory is transferred as a raw byte sequence
- * from/to the firmware's memory.  If this memory contains data
- * structures which contain multi-byte integers, it's the callers
- * responsibility to perform appropriate byte order conversions.
- */
-static int
-csio_t4_memory_rw(struct csio_hw *hw, u32 win, int mtype, u32 addr,
-                u32 len, uint32_t *buf, int dir)
-{
-        u32 pos, start, offset, memoffset, bar0;
-        u32 edc_size, mc_size, mem_reg, mem_aperture, mem_base;
-
-        /*
-         * Argument sanity checks ...
-         */
-        if ((addr & 0x3) || (len & 0x3))
-                return -EINVAL;
-
-        /* Offset into the region of memory which is being accessed
-         * MEM_EDC0 = 0
-         * MEM_EDC1 = 1
-         * MEM_MC   = 2 -- T4
-         */
-        edc_size  = EDRAM0_SIZE_G(csio_rd_reg32(hw, MA_EDRAM0_BAR_A));
-        if (mtype != MEM_MC1)
-                memoffset = (mtype * (edc_size * 1024 * 1024));
-        else {
-                mc_size = EXT_MEM_SIZE_G(csio_rd_reg32(hw,
-                                                       MA_EXT_MEMORY_BAR_A));
-                memoffset = (MEM_MC0 * edc_size + mc_size) * 1024 * 1024;
-        }
-
-        /* Determine the PCIE_MEM_ACCESS_OFFSET */
-        addr = addr + memoffset;
-
-        /*
-         * Each PCI-E Memory Window is programmed with a window size -- or
-         * "aperture" -- which controls the granularity of its mapping onto
-         * adapter memory.  We need to grab that aperture in order to know
-         * how to use the specified window.  The window is also programmed
-         * with the base address of the Memory Window in BAR0's address
-         * space.  For T4 this is an absolute PCI-E Bus Address.  For T5
-         * the address is relative to BAR0.
-         */
-        mem_reg = csio_rd_reg32(hw,
-                        PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN, win));
-        mem_aperture = 1 << (WINDOW(mem_reg) + 10);
-        mem_base = GET_PCIEOFST(mem_reg) << 10;
-
-        bar0 = csio_t4_read_pcie_cfg4(hw, PCI_BASE_ADDRESS_0);
-        bar0 &= PCI_BASE_ADDRESS_MEM_MASK;
-        mem_base -= bar0;
-
-        start = addr & ~(mem_aperture-1);
-        offset = addr - start;
-
-        csio_dbg(hw, "csio_t4_memory_rw: mem_reg: 0x%x, mem_aperture: 0x%x\n",
-                 mem_reg, mem_aperture);
-        csio_dbg(hw, "csio_t4_memory_rw: mem_base: 0x%x, mem_offset: 0x%x\n",
-                 mem_base, memoffset);
-        csio_dbg(hw, "csio_t4_memory_rw: bar0: 0x%x, start:0x%x, offset:0x%x\n",
-                 bar0, start, offset);
-        csio_dbg(hw, "csio_t4_memory_rw: mtype: %d, addr: 0x%x, len: %d\n",
-                 mtype, addr, len);
-
-        for (pos = start; len > 0; pos += mem_aperture, offset = 0) {
-                /*
-                 * Move PCI-E Memory Window to our current transfer
-                 * position.  Read it back to ensure that changes propagate
-                 * before we attempt to use the new value.
-                 */
-                csio_wr_reg32(hw, pos,
-                        PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET, win));
-                csio_rd_reg32(hw,
-                        PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET, win));
-
-                while (offset < mem_aperture && len > 0) {
-                        if (dir)
-                                *buf++ = csio_rd_reg32(hw, mem_base + offset);
-                        else
-                                csio_wr_reg32(hw, *buf++, mem_base + offset);
-
-                        offset += sizeof(__be32);
-                        len -= sizeof(__be32);
-                }
-        }
-        return 0;
-}
-
-/*
- * csio_t4_dfs_create_ext_mem - setup debugfs for MC to read the values
- * @hw: the csio_hw
- *
- * This function creates files in the debugfs with external memory region MC.
- */
-static void
-csio_t4_dfs_create_ext_mem(struct csio_hw *hw)
-{
-        u32 size;
-        int i = csio_rd_reg32(hw, MA_TARGET_MEM_ENABLE_A);
-
-        if (i & EXT_MEM_ENABLE_F) {
-                size = csio_rd_reg32(hw, MA_EXT_MEMORY_BAR_A);
-                csio_add_debugfs_mem(hw, "mc", MEM_MC,
-                                     EXT_MEM_SIZE_G(size));
-        }
-}
-
-/* T4 adapter specific function */
-struct csio_hw_chip_ops t4_ops = {
-        .chip_set_mem_win               = csio_t4_set_mem_win,
-        .chip_pcie_intr_handler         = csio_t4_pcie_intr_handler,
-        .chip_flash_cfg_addr            = csio_t4_flash_cfg_addr,
-        .chip_mc_read                   = csio_t4_mc_read,
-        .chip_edc_read                  = csio_t4_edc_read,
-        .chip_memory_rw                 = csio_t4_memory_rw,
-        .chip_dfs_create_ext_mem        = csio_t4_dfs_create_ext_mem,
-};
diff --git a/drivers/scsi/csiostor/csio_hw_t5.c b/drivers/scsi/csiostor/csio_hw_t5.c
index 66e180a58718..3267f4f627c9 100644
--- a/drivers/scsi/csiostor/csio_hw_t5.c
+++ b/drivers/scsi/csiostor/csio_hw_t5.c
@@ -56,11 +56,11 @@ csio_t5_set_mem_win(struct csio_hw *hw, uint32_t win)
          * back MA register to ensure that changes propagate before we attempt
          * to use the new values.)
          */
-        csio_wr_reg32(hw, mem_win_base | BIR(0) |
-                          WINDOW(ilog2(MEMWIN_APERTURE) - 10),
-                          PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN, win));
+        csio_wr_reg32(hw, mem_win_base | BIR_V(0) |
+                          WINDOW_V(ilog2(MEMWIN_APERTURE) - 10),
+                          PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN_A, win));
         csio_rd_reg32(hw,
-                      PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN, win));
+                      PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN_A, win));
 
         return 0;
 }
@@ -72,74 +72,74 @@ static void
 csio_t5_pcie_intr_handler(struct csio_hw *hw)
 {
         static struct intr_info sysbus_intr_info[] = {
-                { RNPP, "RXNP array parity error", -1, 1 },
-                { RPCP, "RXPC array parity error", -1, 1 },
-                { RCIP, "RXCIF array parity error", -1, 1 },
-                { RCCP, "Rx completions control array parity error", -1, 1 },
-                { RFTP, "RXFT array parity error", -1, 1 },
+                { RNPP_F, "RXNP array parity error", -1, 1 },
+                { RPCP_F, "RXPC array parity error", -1, 1 },
+                { RCIP_F, "RXCIF array parity error", -1, 1 },
+                { RCCP_F, "Rx completions control array parity error", -1, 1 },
+                { RFTP_F, "RXFT array parity error", -1, 1 },
                 { 0, NULL, 0, 0 }
         };
         static struct intr_info pcie_port_intr_info[] = {
-                { TPCP, "TXPC array parity error", -1, 1 },
-                { TNPP, "TXNP array parity error", -1, 1 },
-                { TFTP, "TXFT array parity error", -1, 1 },
-                { TCAP, "TXCA array parity error", -1, 1 },
-                { TCIP, "TXCIF array parity error", -1, 1 },
-                { RCAP, "RXCA array parity error", -1, 1 },
-                { OTDD, "outbound request TLP discarded", -1, 1 },
-                { RDPE, "Rx data parity error", -1, 1 },
-                { TDUE, "Tx uncorrectable data error", -1, 1 },
+                { TPCP_F, "TXPC array parity error", -1, 1 },
+                { TNPP_F, "TXNP array parity error", -1, 1 },
+                { TFTP_F, "TXFT array parity error", -1, 1 },
+                { TCAP_F, "TXCA array parity error", -1, 1 },
+                { TCIP_F, "TXCIF array parity error", -1, 1 },
+                { RCAP_F, "RXCA array parity error", -1, 1 },
+                { OTDD_F, "outbound request TLP discarded", -1, 1 },
+                { RDPE_F, "Rx data parity error", -1, 1 },
+                { TDUE_F, "Tx uncorrectable data error", -1, 1 },
                 { 0, NULL, 0, 0 }
         };
 
         static struct intr_info pcie_intr_info[] = {
-                { MSTGRPPERR, "Master Response Read Queue parity error",
+                { MSTGRPPERR_F, "Master Response Read Queue parity error",
                 -1, 1 },
-                { MSTTIMEOUTPERR, "Master Timeout FIFO parity error", -1, 1 },
-                { MSIXSTIPERR, "MSI-X STI SRAM parity error", -1, 1 },
-                { MSIXADDRLPERR, "MSI-X AddrL parity error", -1, 1 },
-                { MSIXADDRHPERR, "MSI-X AddrH parity error", -1, 1 },
-                { MSIXDATAPERR, "MSI-X data parity error", -1, 1 },
-                { MSIXDIPERR, "MSI-X DI parity error", -1, 1 },
-                { PIOCPLGRPPERR, "PCI PIO completion Group FIFO parity error",
+                { MSTTIMEOUTPERR_F, "Master Timeout FIFO parity error", -1, 1 },
+                { MSIXSTIPERR_F, "MSI-X STI SRAM parity error", -1, 1 },
+                { MSIXADDRLPERR_F, "MSI-X AddrL parity error", -1, 1 },
+                { MSIXADDRHPERR_F, "MSI-X AddrH parity error", -1, 1 },
+                { MSIXDATAPERR_F, "MSI-X data parity error", -1, 1 },
+                { MSIXDIPERR_F, "MSI-X DI parity error", -1, 1 },
+                { PIOCPLGRPPERR_F, "PCI PIO completion Group FIFO parity error",
                 -1, 1 },
-                { PIOREQGRPPERR, "PCI PIO request Group FIFO parity error",
+                { PIOREQGRPPERR_F, "PCI PIO request Group FIFO parity error",
                 -1, 1 },
-                { TARTAGPERR, "PCI PCI target tag FIFO parity error", -1, 1 },
-                { MSTTAGQPERR, "PCI master tag queue parity error", -1, 1 },
-                { CREQPERR, "PCI CMD channel request parity error", -1, 1 },
-                { CRSPPERR, "PCI CMD channel response parity error", -1, 1 },
-                { DREQWRPERR, "PCI DMA channel write request parity error",
+                { TARTAGPERR_F, "PCI PCI target tag FIFO parity error", -1, 1 },
+                { MSTTAGQPERR_F, "PCI master tag queue parity error", -1, 1 },
+                { CREQPERR_F, "PCI CMD channel request parity error", -1, 1 },
+                { CRSPPERR_F, "PCI CMD channel response parity error", -1, 1 },
+                { DREQWRPERR_F, "PCI DMA channel write request parity error",
                 -1, 1 },
-                { DREQPERR, "PCI DMA channel request parity error", -1, 1 },
-                { DRSPPERR, "PCI DMA channel response parity error", -1, 1 },
-                { HREQWRPERR, "PCI HMA channel count parity error", -1, 1 },
-                { HREQPERR, "PCI HMA channel request parity error", -1, 1 },
-                { HRSPPERR, "PCI HMA channel response parity error", -1, 1 },
-                { CFGSNPPERR, "PCI config snoop FIFO parity error", -1, 1 },
-                { FIDPERR, "PCI FID parity error", -1, 1 },
-                { VFIDPERR, "PCI INTx clear parity error", -1, 1 },
-                { MAGRPPERR, "PCI MA group FIFO parity error", -1, 1 },
-                { PIOTAGPERR, "PCI PIO tag parity error", -1, 1 },
-                { IPRXHDRGRPPERR, "PCI IP Rx header group parity error",
+                { DREQPERR_F, "PCI DMA channel request parity error", -1, 1 },
+                { DRSPPERR_F, "PCI DMA channel response parity error", -1, 1 },
+                { HREQWRPERR_F, "PCI HMA channel count parity error", -1, 1 },
+                { HREQPERR_F, "PCI HMA channel request parity error", -1, 1 },
+                { HRSPPERR_F, "PCI HMA channel response parity error", -1, 1 },
+                { CFGSNPPERR_F, "PCI config snoop FIFO parity error", -1, 1 },
+                { FIDPERR_F, "PCI FID parity error", -1, 1 },
+                { VFIDPERR_F, "PCI INTx clear parity error", -1, 1 },
+                { MAGRPPERR_F, "PCI MA group FIFO parity error", -1, 1 },
+                { PIOTAGPERR_F, "PCI PIO tag parity error", -1, 1 },
+                { IPRXHDRGRPPERR_F, "PCI IP Rx header group parity error",
                 -1, 1 },
-                { IPRXDATAGRPPERR, "PCI IP Rx data group parity error",
+                { IPRXDATAGRPPERR_F, "PCI IP Rx data group parity error",
                 -1, 1 },
-                { RPLPERR, "PCI IP replay buffer parity error", -1, 1 },
-                { IPSOTPERR, "PCI IP SOT buffer parity error", -1, 1 },
-                { TRGT1GRPPERR, "PCI TRGT1 group FIFOs parity error", -1, 1 },
-                { READRSPERR, "Outbound read error", -1, 0 },
+                { RPLPERR_F, "PCI IP replay buffer parity error", -1, 1 },
+                { IPSOTPERR_F, "PCI IP SOT buffer parity error", -1, 1 },
+                { TRGT1GRPPERR_F, "PCI TRGT1 group FIFOs parity error", -1, 1 },
+                { READRSPERR_F, "Outbound read error", -1, 0 },
                 { 0, NULL, 0, 0 }
         };
 
         int fat;
         fat = csio_handle_intr_status(hw,
-                                      PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS,
+                                      PCIE_CORE_UTL_SYSTEM_BUS_AGENT_STATUS_A,
                                       sysbus_intr_info) +
               csio_handle_intr_status(hw,
-                                      PCIE_CORE_UTL_PCI_EXPRESS_PORT_STATUS,
+                                      PCIE_CORE_UTL_PCI_EXPRESS_PORT_STATUS_A,
                                       pcie_port_intr_info) +
-              csio_handle_intr_status(hw, PCIE_INT_CAUSE, pcie_intr_info);
+              csio_handle_intr_status(hw, PCIE_INT_CAUSE_A, pcie_intr_info);
         if (fat)
                 csio_hw_fatal_err(hw);
 }
@@ -177,25 +177,25 @@ csio_t5_mc_read(struct csio_hw *hw, int idx, uint32_t addr, __be32 *data,
         uint32_t mc_bist_cmd_reg, mc_bist_cmd_addr_reg, mc_bist_cmd_len_reg;
         uint32_t mc_bist_status_rdata_reg, mc_bist_data_pattern_reg;
 
-        mc_bist_cmd_reg = MC_REG(MC_P_BIST_CMD, idx);
-        mc_bist_cmd_addr_reg = MC_REG(MC_P_BIST_CMD_ADDR, idx);
-        mc_bist_cmd_len_reg = MC_REG(MC_P_BIST_CMD_LEN, idx);
-        mc_bist_status_rdata_reg = MC_REG(MC_P_BIST_STATUS_RDATA, idx);
-        mc_bist_data_pattern_reg = MC_REG(MC_P_BIST_DATA_PATTERN, idx);
+        mc_bist_cmd_reg = MC_REG(MC_P_BIST_CMD_A, idx);
+        mc_bist_cmd_addr_reg = MC_REG(MC_P_BIST_CMD_ADDR_A, idx);
+        mc_bist_cmd_len_reg = MC_REG(MC_P_BIST_CMD_LEN_A, idx);
+        mc_bist_status_rdata_reg = MC_REG(MC_P_BIST_STATUS_RDATA_A, idx);
+        mc_bist_data_pattern_reg = MC_REG(MC_P_BIST_DATA_PATTERN_A, idx);
 
-        if (csio_rd_reg32(hw, mc_bist_cmd_reg) & START_BIST)
+        if (csio_rd_reg32(hw, mc_bist_cmd_reg) & START_BIST_F)
                 return -EBUSY;
         csio_wr_reg32(hw, addr & ~0x3fU, mc_bist_cmd_addr_reg);
         csio_wr_reg32(hw, 64, mc_bist_cmd_len_reg);
         csio_wr_reg32(hw, 0xc, mc_bist_data_pattern_reg);
-        csio_wr_reg32(hw, BIST_OPCODE(1) | START_BIST |  BIST_CMD_GAP(1),
+        csio_wr_reg32(hw, BIST_OPCODE_V(1) | START_BIST_F |  BIST_CMD_GAP_V(1),
                       mc_bist_cmd_reg);
-        i = csio_hw_wait_op_done_val(hw, mc_bist_cmd_reg, START_BIST,
+        i = csio_hw_wait_op_done_val(hw, mc_bist_cmd_reg, START_BIST_F,
                                      0, 10, 1, NULL);
         if (i)
                 return i;
 
-#define MC_DATA(i) MC_BIST_STATUS_REG(MC_BIST_STATUS_RDATA, i)
+#define MC_DATA(i) MC_BIST_STATUS_REG(MC_BIST_STATUS_RDATA_A, i)
 
         for (i = 15; i >= 0; i--)
                 *data++ = htonl(csio_rd_reg32(hw, MC_DATA(i)));
@@ -231,27 +231,27 @@ csio_t5_edc_read(struct csio_hw *hw, int idx, uint32_t addr, __be32 *data,
 #define EDC_STRIDE_T5 (EDC_T51_BASE_ADDR - EDC_T50_BASE_ADDR)
 #define EDC_REG_T5(reg, idx) (reg + EDC_STRIDE_T5 * idx)
 
-        edc_bist_cmd_reg = EDC_REG_T5(EDC_H_BIST_CMD, idx);
-        edc_bist_cmd_addr_reg = EDC_REG_T5(EDC_H_BIST_CMD_ADDR, idx);
-        edc_bist_cmd_len_reg = EDC_REG_T5(EDC_H_BIST_CMD_LEN, idx);
-        edc_bist_cmd_data_pattern = EDC_REG_T5(EDC_H_BIST_DATA_PATTERN, idx);
-        edc_bist_status_rdata_reg = EDC_REG_T5(EDC_H_BIST_STATUS_RDATA, idx);
+        edc_bist_cmd_reg = EDC_REG_T5(EDC_H_BIST_CMD_A, idx);
+        edc_bist_cmd_addr_reg = EDC_REG_T5(EDC_H_BIST_CMD_ADDR_A, idx);
+        edc_bist_cmd_len_reg = EDC_REG_T5(EDC_H_BIST_CMD_LEN_A, idx);
+        edc_bist_cmd_data_pattern = EDC_REG_T5(EDC_H_BIST_DATA_PATTERN_A, idx);
+        edc_bist_status_rdata_reg = EDC_REG_T5(EDC_H_BIST_STATUS_RDATA_A, idx);
 #undef EDC_REG_T5
 #undef EDC_STRIDE_T5
 
-        if (csio_rd_reg32(hw, edc_bist_cmd_reg) & START_BIST)
+        if (csio_rd_reg32(hw, edc_bist_cmd_reg) & START_BIST_F)
                 return -EBUSY;
         csio_wr_reg32(hw, addr & ~0x3fU, edc_bist_cmd_addr_reg);
         csio_wr_reg32(hw, 64, edc_bist_cmd_len_reg);
         csio_wr_reg32(hw, 0xc, edc_bist_cmd_data_pattern);
-        csio_wr_reg32(hw, BIST_OPCODE(1) | START_BIST |  BIST_CMD_GAP(1),
+        csio_wr_reg32(hw, BIST_OPCODE_V(1) | START_BIST_F |  BIST_CMD_GAP_V(1),
                       edc_bist_cmd_reg);
-        i = csio_hw_wait_op_done_val(hw, edc_bist_cmd_reg, START_BIST,
+        i = csio_hw_wait_op_done_val(hw, edc_bist_cmd_reg, START_BIST_F,
                                      0, 10, 1, NULL);
         if (i)
                 return i;
 
-#define EDC_DATA(i) (EDC_BIST_STATUS_REG(EDC_BIST_STATUS_RDATA, i) + idx)
+#define EDC_DATA(i) (EDC_BIST_STATUS_REG(EDC_BIST_STATUS_RDATA_A, i) + idx)
 
         for (i = 15; i >= 0; i--)
                 *data++ = htonl(csio_rd_reg32(hw, EDC_DATA(i)));
@@ -320,13 +320,13 @@ csio_t5_memory_rw(struct csio_hw *hw, u32 win, int mtype, u32 addr,
          * the address is relative to BAR0.
          */
         mem_reg = csio_rd_reg32(hw,
-                        PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN, win));
-        mem_aperture = 1 << (WINDOW(mem_reg) + 10);
-        mem_base = GET_PCIEOFST(mem_reg) << 10;
+                        PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_BASE_WIN_A, win));
+        mem_aperture = 1 << (WINDOW_V(mem_reg) + 10);
+        mem_base = PCIEOFST_G(mem_reg) << 10;
 
         start = addr & ~(mem_aperture-1);
         offset = addr - start;
-        win_pf = V_PFNUM(hw->pfn);
+        win_pf = PFNUM_V(hw->pfn);
 
         csio_dbg(hw, "csio_t5_memory_rw: mem_reg: 0x%x, mem_aperture: 0x%x\n",
                  mem_reg, mem_aperture);
@@ -344,9 +344,9 @@ csio_t5_memory_rw(struct csio_hw *hw, u32 win, int mtype, u32 addr,
                  * before we attempt to use the new value.
                  */
                 csio_wr_reg32(hw, pos | win_pf,
-                        PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET, win));
+                        PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET_A, win));
                 csio_rd_reg32(hw,
-                        PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET, win));
+                        PCIE_MEM_ACCESS_REG(PCIE_MEM_ACCESS_OFFSET_A, win));
 
                 while (offset < mem_aperture && len > 0) {
                         if (dir)
diff --git a/drivers/scsi/csiostor/csio_init.c b/drivers/scsi/csiostor/csio_init.c
index 34d20cc3e110..d9631e15f7b5 100644
--- a/drivers/scsi/csiostor/csio_init.c
+++ b/drivers/scsi/csiostor/csio_init.c
@@ -113,12 +113,9 @@ static const struct file_operations csio_mem_debugfs_fops = {
 void csio_add_debugfs_mem(struct csio_hw *hw, const char *name,
                                  unsigned int idx, unsigned int size_mb)
 {
-        struct dentry *de;
-
-        de = debugfs_create_file(name, S_IRUSR, hw->debugfs_root,
-                                 (void *)hw + idx, &csio_mem_debugfs_fops);
-        if (de && de->d_inode)
-                de->d_inode->i_size = size_mb << 20;
+        debugfs_create_file_size(name, S_IRUSR, hw->debugfs_root,
+                                 (void *)hw + idx, &csio_mem_debugfs_fops,
+                                 size_mb << 20);
 }
 
 static int csio_setup_debugfs(struct csio_hw *hw)
@@ -1176,9 +1173,8 @@ static struct pci_error_handlers csio_err_handler = {
  */
 #define CH_PCI_DEVICE_ID_TABLE_DEFINE_BEGIN \
         static struct pci_device_id csio_pci_tbl[] = {
-/* Define for iSCSI uses PF5, FCoE uses PF6 */
-#define CH_PCI_DEVICE_ID_FUNCTION       0x5
-#define CH_PCI_DEVICE_ID_FUNCTION2      0x6
+/* Define for FCoE uses PF6 */
+#define CH_PCI_DEVICE_ID_FUNCTION       0x6
 
 #define CH_PCI_ID_TABLE_ENTRY(devid) \
                 { PCI_VDEVICE(CHELSIO, (devid)), 0 }
@@ -1256,5 +1252,4 @@ MODULE_DESCRIPTION(CSIO_DRV_DESC);
 MODULE_LICENSE(CSIO_DRV_LICENSE);
 MODULE_DEVICE_TABLE(pci, csio_pci_tbl);
 MODULE_VERSION(CSIO_DRV_VERSION);
-MODULE_FIRMWARE(FW_FNAME_T4);
 MODULE_FIRMWARE(FW_FNAME_T5);
diff --git a/drivers/scsi/csiostor/csio_isr.c b/drivers/scsi/csiostor/csio_isr.c
index a8c748a35f9c..2fb71c6c3b37 100644
--- a/drivers/scsi/csiostor/csio_isr.c
+++ b/drivers/scsi/csiostor/csio_isr.c
@@ -317,7 +317,7 @@ csio_fcoe_isr(int irq, void *dev_id)
 
         /* Disable the interrupt for this PCI function. */
         if (hw->intr_mode == CSIO_IM_INTX)
-                csio_wr_reg32(hw, 0, MYPF_REG(PCIE_PF_CLI));
+                csio_wr_reg32(hw, 0, MYPF_REG(PCIE_PF_CLI_A));
 
         /*
          * The read in the following function will flush the
diff --git a/drivers/scsi/csiostor/csio_lnode.c b/drivers/scsi/csiostor/csio_lnode.c
index 87f9280d9b43..c00b2ff72b55 100644
--- a/drivers/scsi/csiostor/csio_lnode.c
+++ b/drivers/scsi/csiostor/csio_lnode.c
@@ -1758,7 +1758,7 @@ csio_ln_mgmt_submit_wr(struct csio_mgmtm *mgmtm, struct csio_ioreq *io_req,
         else {
                 /* Program DSGL to dma payload */
                 dsgl.cmd_nsge = htonl(ULPTX_CMD_V(ULP_TX_SC_DSGL) |
-                                        ULPTX_MORE | ULPTX_NSGE(1));
+                                        ULPTX_MORE_F | ULPTX_NSGE_V(1));
                 dsgl.len0 = cpu_to_be32(pld_len);
                 dsgl.addr0 = cpu_to_be64(pld->paddr);
                 csio_wr_copy_to_wrp(&dsgl, &wrp, ALIGN(wr_off, 8),
diff --git a/drivers/scsi/csiostor/csio_mb.c b/drivers/scsi/csiostor/csio_mb.c
index 08c265c0f353..9451787ca7f2 100644
--- a/drivers/scsi/csiostor/csio_mb.c
+++ b/drivers/scsi/csiostor/csio_mb.c
@@ -327,7 +327,8 @@ csio_mb_caps_config(struct csio_hw *hw, struct csio_mb *mbp, uint32_t tmo,
 }
 
 #define CSIO_ADVERT_MASK     (FW_PORT_CAP_SPEED_100M | FW_PORT_CAP_SPEED_1G |\
-                              FW_PORT_CAP_SPEED_10G | FW_PORT_CAP_ANEG)
+                              FW_PORT_CAP_SPEED_10G | FW_PORT_CAP_SPEED_40G |\
+                              FW_PORT_CAP_ANEG)
 
 /*
  * csio_mb_port- FW PORT command helper
@@ -1104,8 +1105,8 @@ csio_mb_process_portparams_rsp(struct csio_hw *hw,
 void
 csio_mb_intr_enable(struct csio_hw *hw)
 {
-        csio_wr_reg32(hw, MBMSGRDYINTEN(1), MYPF_REG(CIM_PF_HOST_INT_ENABLE));
-        csio_rd_reg32(hw, MYPF_REG(CIM_PF_HOST_INT_ENABLE));
+        csio_wr_reg32(hw, MBMSGRDYINTEN_F, MYPF_REG(CIM_PF_HOST_INT_ENABLE_A));
+        csio_rd_reg32(hw, MYPF_REG(CIM_PF_HOST_INT_ENABLE_A));
 }
 
 /*
@@ -1117,8 +1118,9 @@ csio_mb_intr_enable(struct csio_hw *hw)
 void
 csio_mb_intr_disable(struct csio_hw *hw)
 {
-        csio_wr_reg32(hw, MBMSGRDYINTEN(0), MYPF_REG(CIM_PF_HOST_INT_ENABLE));
-        csio_rd_reg32(hw, MYPF_REG(CIM_PF_HOST_INT_ENABLE));
+        csio_wr_reg32(hw, MBMSGRDYINTEN_V(0),
+                      MYPF_REG(CIM_PF_HOST_INT_ENABLE_A));
+        csio_rd_reg32(hw, MYPF_REG(CIM_PF_HOST_INT_ENABLE_A));
 }
 
 static void
@@ -1153,8 +1155,8 @@ csio_mb_debug_cmd_handler(struct csio_hw *hw)
 {
         int i;
         __be64 cmd[CSIO_MB_MAX_REGS];
-        uint32_t ctl_reg = PF_REG(hw->pfn, CIM_PF_MAILBOX_CTRL);
-        uint32_t data_reg = PF_REG(hw->pfn, CIM_PF_MAILBOX_DATA);
+        uint32_t ctl_reg = PF_REG(hw->pfn, CIM_PF_MAILBOX_CTRL_A);
+        uint32_t data_reg = PF_REG(hw->pfn, CIM_PF_MAILBOX_DATA_A);
         int size = sizeof(struct fw_debug_cmd);
 
         /* Copy mailbox data */
@@ -1164,8 +1166,8 @@ csio_mb_debug_cmd_handler(struct csio_hw *hw)
         csio_mb_dump_fw_dbg(hw, cmd);
 
         /* Notify FW of mailbox by setting owner as UP */
-        csio_wr_reg32(hw, MBMSGVALID | MBINTREQ | MBOWNER(CSIO_MBOWNER_FW),
-                      ctl_reg);
+        csio_wr_reg32(hw, MBMSGVALID_F | MBINTREQ_F |
+                      MBOWNER_V(CSIO_MBOWNER_FW), ctl_reg);
 
         csio_rd_reg32(hw, ctl_reg);
         wmb();
@@ -1187,8 +1189,8 @@ csio_mb_issue(struct csio_hw *hw, struct csio_mb *mbp)
         __be64 *cmd = mbp->mb;
         __be64 hdr;
         struct csio_mbm *mbm = &hw->mbm;
-        uint32_t ctl_reg = PF_REG(hw->pfn, CIM_PF_MAILBOX_CTRL);
-        uint32_t data_reg = PF_REG(hw->pfn, CIM_PF_MAILBOX_DATA);
+        uint32_t ctl_reg = PF_REG(hw->pfn, CIM_PF_MAILBOX_CTRL_A);
+        uint32_t data_reg = PF_REG(hw->pfn, CIM_PF_MAILBOX_DATA_A);
         int size = mbp->mb_size;
         int rv = -EINVAL;
         struct fw_cmd_hdr *fw_hdr;
@@ -1224,12 +1226,12 @@ csio_mb_issue(struct csio_hw *hw, struct csio_mb *mbp)
         }
 
         /* Now get ownership of mailbox */
-        owner = MBOWNER_GET(csio_rd_reg32(hw, ctl_reg));
+        owner = MBOWNER_G(csio_rd_reg32(hw, ctl_reg));
 
         if (!csio_mb_is_host_owner(owner)) {
 
                 for (i = 0; (owner == CSIO_MBOWNER_NONE) && (i < 3); i++)
-                        owner = MBOWNER_GET(csio_rd_reg32(hw, ctl_reg));
+                        owner = MBOWNER_G(csio_rd_reg32(hw, ctl_reg));
                 /*
                  * Mailbox unavailable. In immediate mode, fail the command.
                  * In other modes, enqueue the request.
@@ -1271,10 +1273,10 @@ csio_mb_issue(struct csio_hw *hw, struct csio_mb *mbp)
         if (mbp->mb_cbfn != NULL) {
                 mbm->mcurrent = mbp;
                 mod_timer(&mbm->timer, jiffies + msecs_to_jiffies(mbp->tmo));
-                csio_wr_reg32(hw, MBMSGVALID | MBINTREQ |
-                              MBOWNER(CSIO_MBOWNER_FW), ctl_reg);
+                csio_wr_reg32(hw, MBMSGVALID_F | MBINTREQ_F |
+                              MBOWNER_V(CSIO_MBOWNER_FW), ctl_reg);
         } else
-                csio_wr_reg32(hw, MBMSGVALID | MBOWNER(CSIO_MBOWNER_FW),
+                csio_wr_reg32(hw, MBMSGVALID_F | MBOWNER_V(CSIO_MBOWNER_FW),
                               ctl_reg);
 
         /* Flush posted writes */
@@ -1294,9 +1296,9 @@ csio_mb_issue(struct csio_hw *hw, struct csio_mb *mbp)
 
                 /* Check for response */
                 ctl = csio_rd_reg32(hw, ctl_reg);
-                if (csio_mb_is_host_owner(MBOWNER_GET(ctl))) {
+                if (csio_mb_is_host_owner(MBOWNER_G(ctl))) {
 
-                        if (!(ctl & MBMSGVALID)) {
+                        if (!(ctl & MBMSGVALID_F)) {
                                 csio_wr_reg32(hw, 0, ctl_reg);
                                 continue;
                         }
@@ -1457,16 +1459,16 @@ csio_mb_isr_handler(struct csio_hw *hw)
         __be64                  *cmd;
         uint32_t                ctl, cim_cause, pl_cause;
         int                     i;
-        uint32_t                ctl_reg = PF_REG(hw->pfn, CIM_PF_MAILBOX_CTRL);
-        uint32_t                data_reg = PF_REG(hw->pfn, CIM_PF_MAILBOX_DATA);
+        uint32_t        ctl_reg = PF_REG(hw->pfn, CIM_PF_MAILBOX_CTRL_A);
+        uint32_t        data_reg = PF_REG(hw->pfn, CIM_PF_MAILBOX_DATA_A);
         int                     size;
         __be64                  hdr;
         struct fw_cmd_hdr       *fw_hdr;
 
-        pl_cause = csio_rd_reg32(hw, MYPF_REG(PL_PF_INT_CAUSE));
-        cim_cause = csio_rd_reg32(hw, MYPF_REG(CIM_PF_HOST_INT_CAUSE));
+        pl_cause = csio_rd_reg32(hw, MYPF_REG(PL_PF_INT_CAUSE_A));
+        cim_cause = csio_rd_reg32(hw, MYPF_REG(CIM_PF_HOST_INT_CAUSE_A));
 
-        if (!(pl_cause & PFCIM) || !(cim_cause & MBMSGRDYINT)) {
+        if (!(pl_cause & PFCIM_F) || !(cim_cause & MBMSGRDYINT_F)) {
                 CSIO_INC_STATS(hw, n_mbint_unexp);
                 return -EINVAL;
         }
@@ -1477,16 +1479,16 @@ csio_mb_isr_handler(struct csio_hw *hw)
          * the upper level cause register. In other words, CIM-cause
          * first followed by PL-Cause next.
          */
-        csio_wr_reg32(hw, MBMSGRDYINT, MYPF_REG(CIM_PF_HOST_INT_CAUSE));
-        csio_wr_reg32(hw, PFCIM, MYPF_REG(PL_PF_INT_CAUSE));
+        csio_wr_reg32(hw, MBMSGRDYINT_F, MYPF_REG(CIM_PF_HOST_INT_CAUSE_A));
+        csio_wr_reg32(hw, PFCIM_F, MYPF_REG(PL_PF_INT_CAUSE_A));
 
         ctl = csio_rd_reg32(hw, ctl_reg);
 
-        if (csio_mb_is_host_owner(MBOWNER_GET(ctl))) {
+        if (csio_mb_is_host_owner(MBOWNER_G(ctl))) {
 
                 CSIO_DUMP_MB(hw, hw->pfn, data_reg);
 
-                if (!(ctl & MBMSGVALID)) {
+                if (!(ctl & MBMSGVALID_F)) {
                         csio_warn(hw,
                                   "Stray mailbox interrupt recvd,"
                                   " mailbox data not valid\n");
diff --git a/drivers/scsi/csiostor/csio_scsi.c b/drivers/scsi/csiostor/csio_scsi.c
index 3987284e0d2a..2c4562d82dc0 100644
--- a/drivers/scsi/csiostor/csio_scsi.c
+++ b/drivers/scsi/csiostor/csio_scsi.c
@@ -298,8 +298,8 @@ csio_scsi_init_ultptx_dsgl(struct csio_hw *hw, struct csio_ioreq *req,
         struct csio_dma_buf *dma_buf;
         struct scsi_cmnd *scmnd = csio_scsi_cmnd(req);
 
-        sgl->cmd_nsge = htonl(ULPTX_CMD_V(ULP_TX_SC_DSGL) | ULPTX_MORE |
-                                     ULPTX_NSGE(req->nsge));
+        sgl->cmd_nsge = htonl(ULPTX_CMD_V(ULP_TX_SC_DSGL) | ULPTX_MORE_F |
+                                     ULPTX_NSGE_V(req->nsge));
         /* Now add the data SGLs */
         if (likely(!req->dcopy)) {
                 scsi_for_each_sg(scmnd, sgel, req->nsge, i) {
diff --git a/drivers/scsi/csiostor/csio_wr.c b/drivers/scsi/csiostor/csio_wr.c
index 773da14cfa14..e8f18174f2e9 100644
--- a/drivers/scsi/csiostor/csio_wr.c
+++ b/drivers/scsi/csiostor/csio_wr.c
@@ -51,12 +51,12 @@ int csio_intr_coalesce_time = 10;	/* value:SGE_TIMER_VALUE_1 */
 static int csio_sge_timer_reg = 1;
 
 #define CSIO_SET_FLBUF_SIZE(_hw, _reg, _val)                            \
-        csio_wr_reg32((_hw), (_val), SGE_FL_BUFFER_SIZE##_reg)
+        csio_wr_reg32((_hw), (_val), SGE_FL_BUFFER_SIZE##_reg##_A)
 
 static void
 csio_get_flbuf_size(struct csio_hw *hw, struct csio_sge *sge, uint32_t reg)
 {
-        sge->sge_fl_buf_size[reg] = csio_rd_reg32(hw, SGE_FL_BUFFER_SIZE0 +
+        sge->sge_fl_buf_size[reg] = csio_rd_reg32(hw, SGE_FL_BUFFER_SIZE0_A +
                                                         reg * sizeof(uint32_t));
 }
 
@@ -71,7 +71,7 @@ csio_wr_fl_bufsz(struct csio_sge *sge, struct csio_dma_buf *buf)
 static inline uint32_t
 csio_wr_qstat_pgsz(struct csio_hw *hw)
 {
-        return (hw->wrm.sge.sge_control & EGRSTATUSPAGESIZE(1)) ?  128 : 64;
+        return (hw->wrm.sge.sge_control & EGRSTATUSPAGESIZE_F) ?  128 : 64;
 }
 
 /* Ring freelist doorbell */
@@ -84,9 +84,9 @@ csio_wr_ring_fldb(struct csio_hw *hw, struct csio_q *flq)
          * 8 freelist buffer pointers (since each pointer is 8 bytes).
          */
         if (flq->inc_idx >= 8) {
-                csio_wr_reg32(hw, DBPRIO(1) | QID(flq->un.fl.flid) |
-                                  CSIO_HW_PIDX(hw, flq->inc_idx / 8),
-                                  MYPF_REG(SGE_PF_KDOORBELL));
+                csio_wr_reg32(hw, DBPRIO_F | QID_V(flq->un.fl.flid) |
+                                  PIDX_T5_V(flq->inc_idx / 8) | DBTYPE_F,
+                                  MYPF_REG(SGE_PF_KDOORBELL_A));
                 flq->inc_idx &= 7;
         }
 }
@@ -95,10 +95,10 @@ csio_wr_ring_fldb(struct csio_hw *hw, struct csio_q *flq)
 static void
 csio_wr_sge_intr_enable(struct csio_hw *hw, uint16_t iqid)
 {
-        csio_wr_reg32(hw, CIDXINC(0)            |
-                          INGRESSQID(iqid)      |
-                          TIMERREG(X_TIMERREG_RESTART_COUNTER),
-                          MYPF_REG(SGE_PF_GTS));
+        csio_wr_reg32(hw, CIDXINC_V(0)          |
+                          INGRESSQID_V(iqid)    |
+                          TIMERREG_V(X_TIMERREG_RESTART_COUNTER),
+                          MYPF_REG(SGE_PF_GTS_A));
 }
 
 /*
@@ -982,9 +982,9 @@ csio_wr_issue(struct csio_hw *hw, int qidx, bool prio)
 
         wmb();
         /* Ring SGE Doorbell writing q->pidx into it */
-        csio_wr_reg32(hw, DBPRIO(prio) | QID(q->un.eq.physeqid) |
-                          CSIO_HW_PIDX(hw, q->inc_idx),
-                          MYPF_REG(SGE_PF_KDOORBELL));
+        csio_wr_reg32(hw, DBPRIO_V(prio) | QID_V(q->un.eq.physeqid) |
+                          PIDX_T5_V(q->inc_idx) | DBTYPE_F,
+                          MYPF_REG(SGE_PF_KDOORBELL_A));
         q->inc_idx = 0;
 
         return 0;
@@ -1242,10 +1242,10 @@ csio_wr_process_iq(struct csio_hw *hw, struct csio_q *q,
 
 restart:
         /* Now inform SGE about our incremental index value */
-        csio_wr_reg32(hw, CIDXINC(q->inc_idx)           |
-                          INGRESSQID(q->un.iq.physiqid) |
-                          TIMERREG(csio_sge_timer_reg),
-                          MYPF_REG(SGE_PF_GTS));
+        csio_wr_reg32(hw, CIDXINC_V(q->inc_idx)         |
+                          INGRESSQID_V(q->un.iq.physiqid)       |
+                          TIMERREG_V(csio_sge_timer_reg),
+                          MYPF_REG(SGE_PF_GTS_A));
         q->stats.n_tot_rsps += q->inc_idx;
 
         q->inc_idx = 0;
@@ -1310,22 +1310,23 @@ csio_wr_fixup_host_params(struct csio_hw *hw)
         uint32_t ingpad = 0;
         uint32_t stat_len = clsz > 64 ? 128 : 64;
 
-        csio_wr_reg32(hw, HOSTPAGESIZEPF0(s_hps) | HOSTPAGESIZEPF1(s_hps) |
-                      HOSTPAGESIZEPF2(s_hps) | HOSTPAGESIZEPF3(s_hps) |
-                      HOSTPAGESIZEPF4(s_hps) | HOSTPAGESIZEPF5(s_hps) |
-                      HOSTPAGESIZEPF6(s_hps) | HOSTPAGESIZEPF7(s_hps),
-                      SGE_HOST_PAGE_SIZE);
+        csio_wr_reg32(hw, HOSTPAGESIZEPF0_V(s_hps) | HOSTPAGESIZEPF1_V(s_hps) |
+                      HOSTPAGESIZEPF2_V(s_hps) | HOSTPAGESIZEPF3_V(s_hps) |
+                      HOSTPAGESIZEPF4_V(s_hps) | HOSTPAGESIZEPF5_V(s_hps) |
+                      HOSTPAGESIZEPF6_V(s_hps) | HOSTPAGESIZEPF7_V(s_hps),
+                      SGE_HOST_PAGE_SIZE_A);
 
         sge->csio_fl_align = clsz < 32 ? 32 : clsz;
         ingpad = ilog2(sge->csio_fl_align) - 5;
 
-        csio_set_reg_field(hw, SGE_CONTROL, INGPADBOUNDARY_MASK |
-                                            EGRSTATUSPAGESIZE(1),
-                           INGPADBOUNDARY(ingpad) |
-                           EGRSTATUSPAGESIZE(stat_len != 64));
+        csio_set_reg_field(hw, SGE_CONTROL_A,
+                           INGPADBOUNDARY_V(INGPADBOUNDARY_M) |
+                           EGRSTATUSPAGESIZE_F,
+                           INGPADBOUNDARY_V(ingpad) |
+                           EGRSTATUSPAGESIZE_V(stat_len != 64));
 
         /* FL BUFFER SIZE#0 is Page size i,e already aligned to cache line */
-        csio_wr_reg32(hw, PAGE_SIZE, SGE_FL_BUFFER_SIZE0);
+        csio_wr_reg32(hw, PAGE_SIZE, SGE_FL_BUFFER_SIZE0_A);
 
         /*
          * If using hard params, the following will get set correctly
@@ -1333,23 +1334,24 @@ csio_wr_fixup_host_params(struct csio_hw *hw)
          */
         if (hw->flags & CSIO_HWF_USING_SOFT_PARAMS) {
                 csio_wr_reg32(hw,
-                        (csio_rd_reg32(hw, SGE_FL_BUFFER_SIZE2) +
+                        (csio_rd_reg32(hw, SGE_FL_BUFFER_SIZE2_A) +
                         sge->csio_fl_align - 1) & ~(sge->csio_fl_align - 1),
-                        SGE_FL_BUFFER_SIZE2);
+                        SGE_FL_BUFFER_SIZE2_A);
                 csio_wr_reg32(hw,
-                        (csio_rd_reg32(hw, SGE_FL_BUFFER_SIZE3) +
+                        (csio_rd_reg32(hw, SGE_FL_BUFFER_SIZE3_A) +
                         sge->csio_fl_align - 1) & ~(sge->csio_fl_align - 1),
-                        SGE_FL_BUFFER_SIZE3);
+                        SGE_FL_BUFFER_SIZE3_A);
         }
 
-        csio_wr_reg32(hw, HPZ0(PAGE_SHIFT - 12), ULP_RX_TDDP_PSZ);
+        csio_wr_reg32(hw, HPZ0_V(PAGE_SHIFT - 12), ULP_RX_TDDP_PSZ_A);
 
         /* default value of rx_dma_offset of the NIC driver */
-        csio_set_reg_field(hw, SGE_CONTROL, PKTSHIFT_MASK,
-                           PKTSHIFT(CSIO_SGE_RX_DMA_OFFSET));
+        csio_set_reg_field(hw, SGE_CONTROL_A,
+                           PKTSHIFT_V(PKTSHIFT_M),
+                           PKTSHIFT_V(CSIO_SGE_RX_DMA_OFFSET));
 
-        csio_hw_tp_wr_bits_indirect(hw, TP_INGRESS_CONFIG,
-                                    CSUM_HAS_PSEUDO_HDR, 0);
+        csio_hw_tp_wr_bits_indirect(hw, TP_INGRESS_CONFIG_A,
+                                    CSUM_HAS_PSEUDO_HDR_F, 0);
 }
 
 static void
@@ -1384,9 +1386,9 @@ csio_wr_get_sge(struct csio_hw *hw)
         u32 timer_value_0_and_1, timer_value_2_and_3, timer_value_4_and_5;
         u32 ingress_rx_threshold;
 
-        sge->sge_control = csio_rd_reg32(hw, SGE_CONTROL);
+        sge->sge_control = csio_rd_reg32(hw, SGE_CONTROL_A);
 
-        ingpad = INGPADBOUNDARY_GET(sge->sge_control);
+        ingpad = INGPADBOUNDARY_G(sge->sge_control);
 
         switch (ingpad) {
         case X_INGPCIEBOUNDARY_32B:
@@ -1410,28 +1412,28 @@ csio_wr_get_sge(struct csio_hw *hw)
         for (i = 0; i < CSIO_SGE_FL_SIZE_REGS; i++)
                 csio_get_flbuf_size(hw, sge, i);
 
-        timer_value_0_and_1 = csio_rd_reg32(hw, SGE_TIMER_VALUE_0_AND_1);
-        timer_value_2_and_3 = csio_rd_reg32(hw, SGE_TIMER_VALUE_2_AND_3);
-        timer_value_4_and_5 = csio_rd_reg32(hw, SGE_TIMER_VALUE_4_AND_5);
+        timer_value_0_and_1 = csio_rd_reg32(hw, SGE_TIMER_VALUE_0_AND_1_A);
+        timer_value_2_and_3 = csio_rd_reg32(hw, SGE_TIMER_VALUE_2_AND_3_A);
+        timer_value_4_and_5 = csio_rd_reg32(hw, SGE_TIMER_VALUE_4_AND_5_A);
 
         sge->timer_val[0] = (uint16_t)csio_core_ticks_to_us(hw,
-                                        TIMERVALUE0_GET(timer_value_0_and_1));
+                                        TIMERVALUE0_G(timer_value_0_and_1));
         sge->timer_val[1] = (uint16_t)csio_core_ticks_to_us(hw,
-                                        TIMERVALUE1_GET(timer_value_0_and_1));
+                                        TIMERVALUE1_G(timer_value_0_and_1));
         sge->timer_val[2] = (uint16_t)csio_core_ticks_to_us(hw,
-                                        TIMERVALUE2_GET(timer_value_2_and_3));
+                                        TIMERVALUE2_G(timer_value_2_and_3));
         sge->timer_val[3] = (uint16_t)csio_core_ticks_to_us(hw,
-                                        TIMERVALUE3_GET(timer_value_2_and_3));
+                                        TIMERVALUE3_G(timer_value_2_and_3));
         sge->timer_val[4] = (uint16_t)csio_core_ticks_to_us(hw,
-                                        TIMERVALUE4_GET(timer_value_4_and_5));
+                                        TIMERVALUE4_G(timer_value_4_and_5));
         sge->timer_val[5] = (uint16_t)csio_core_ticks_to_us(hw,
-                                        TIMERVALUE5_GET(timer_value_4_and_5));
+                                        TIMERVALUE5_G(timer_value_4_and_5));
 
-        ingress_rx_threshold = csio_rd_reg32(hw, SGE_INGRESS_RX_THRESHOLD);
-        sge->counter_val[0] = THRESHOLD_0_GET(ingress_rx_threshold);
-        sge->counter_val[1] = THRESHOLD_1_GET(ingress_rx_threshold);
-        sge->counter_val[2] = THRESHOLD_2_GET(ingress_rx_threshold);
-        sge->counter_val[3] = THRESHOLD_3_GET(ingress_rx_threshold);
+        ingress_rx_threshold = csio_rd_reg32(hw, SGE_INGRESS_RX_THRESHOLD_A);
+        sge->counter_val[0] = THRESHOLD_0_G(ingress_rx_threshold);
+        sge->counter_val[1] = THRESHOLD_1_G(ingress_rx_threshold);
+        sge->counter_val[2] = THRESHOLD_2_G(ingress_rx_threshold);
+        sge->counter_val[3] = THRESHOLD_3_G(ingress_rx_threshold);
 
         csio_init_intr_coalesce_parms(hw);
 }
@@ -1454,9 +1456,9 @@ csio_wr_set_sge(struct csio_hw *hw)
          * Set up our basic SGE mode to deliver CPL messages to our Ingress
          * Queue and Packet Date to the Free List.
          */
-        csio_set_reg_field(hw, SGE_CONTROL, RXPKTCPLMODE(1), RXPKTCPLMODE(1));
+        csio_set_reg_field(hw, SGE_CONTROL_A, RXPKTCPLMODE_F, RXPKTCPLMODE_F);
 
-        sge->sge_control = csio_rd_reg32(hw, SGE_CONTROL);
+        sge->sge_control = csio_rd_reg32(hw, SGE_CONTROL_A);
 
         /* sge->csio_fl_align is set up by csio_wr_fixup_host_params(). */
 
@@ -1464,22 +1466,23 @@ csio_wr_set_sge(struct csio_hw *hw)
          * Set up to drop DOORBELL writes when the DOORBELL FIFO overflows
          * and generate an interrupt when this occurs so we can recover.
          */
-        csio_set_reg_field(hw, SGE_DBFIFO_STATUS,
-                   HP_INT_THRESH(HP_INT_THRESH_MASK) |
-                   CSIO_HW_LP_INT_THRESH(hw, CSIO_HW_M_LP_INT_THRESH(hw)),
-                   HP_INT_THRESH(CSIO_SGE_DBFIFO_INT_THRESH) |
-                   CSIO_HW_LP_INT_THRESH(hw, CSIO_SGE_DBFIFO_INT_THRESH));
+        csio_set_reg_field(hw, SGE_DBFIFO_STATUS_A,
+                           LP_INT_THRESH_T5_V(LP_INT_THRESH_T5_M),
+                           LP_INT_THRESH_T5_V(CSIO_SGE_DBFIFO_INT_THRESH));
+        csio_set_reg_field(hw, SGE_DBFIFO_STATUS2_A,
+                           HP_INT_THRESH_T5_V(LP_INT_THRESH_T5_M),
+                           HP_INT_THRESH_T5_V(CSIO_SGE_DBFIFO_INT_THRESH));
 
-        csio_set_reg_field(hw, SGE_DOORBELL_CONTROL, ENABLE_DROP,
-                           ENABLE_DROP);
+        csio_set_reg_field(hw, SGE_DOORBELL_CONTROL_A, ENABLE_DROP_F,
+                           ENABLE_DROP_F);
 
         /* SGE_FL_BUFFER_SIZE0 is set up by csio_wr_fixup_host_params(). */
 
         CSIO_SET_FLBUF_SIZE(hw, 1, CSIO_SGE_FLBUF_SIZE1);
         csio_wr_reg32(hw, (CSIO_SGE_FLBUF_SIZE2 + sge->csio_fl_align - 1)
-                      & ~(sge->csio_fl_align - 1), SGE_FL_BUFFER_SIZE2);
+                      & ~(sge->csio_fl_align - 1), SGE_FL_BUFFER_SIZE2_A);
         csio_wr_reg32(hw, (CSIO_SGE_FLBUF_SIZE3 + sge->csio_fl_align - 1)
-                      & ~(sge->csio_fl_align - 1), SGE_FL_BUFFER_SIZE3);
+                      & ~(sge->csio_fl_align - 1), SGE_FL_BUFFER_SIZE3_A);
         CSIO_SET_FLBUF_SIZE(hw, 4, CSIO_SGE_FLBUF_SIZE4);
         CSIO_SET_FLBUF_SIZE(hw, 5, CSIO_SGE_FLBUF_SIZE5);
         CSIO_SET_FLBUF_SIZE(hw, 6, CSIO_SGE_FLBUF_SIZE6);
@@ -1502,26 +1505,26 @@ csio_wr_set_sge(struct csio_hw *hw)
         sge->counter_val[2] = CSIO_SGE_INT_CNT_VAL_2;
         sge->counter_val[3] = CSIO_SGE_INT_CNT_VAL_3;
 
-        csio_wr_reg32(hw, THRESHOLD_0(sge->counter_val[0]) |
-                      THRESHOLD_1(sge->counter_val[1]) |
-                      THRESHOLD_2(sge->counter_val[2]) |
-                      THRESHOLD_3(sge->counter_val[3]),
-                      SGE_INGRESS_RX_THRESHOLD);
+        csio_wr_reg32(hw, THRESHOLD_0_V(sge->counter_val[0]) |
+                      THRESHOLD_1_V(sge->counter_val[1]) |
+                      THRESHOLD_2_V(sge->counter_val[2]) |
+                      THRESHOLD_3_V(sge->counter_val[3]),
+                      SGE_INGRESS_RX_THRESHOLD_A);
 
         csio_wr_reg32(hw,
-                   TIMERVALUE0(csio_us_to_core_ticks(hw, sge->timer_val[0])) |
-                   TIMERVALUE1(csio_us_to_core_ticks(hw, sge->timer_val[1])),
-                   SGE_TIMER_VALUE_0_AND_1);
+                   TIMERVALUE0_V(csio_us_to_core_ticks(hw, sge->timer_val[0])) |
+                   TIMERVALUE1_V(csio_us_to_core_ticks(hw, sge->timer_val[1])),
+                   SGE_TIMER_VALUE_0_AND_1_A);
 
         csio_wr_reg32(hw,
-                   TIMERVALUE2(csio_us_to_core_ticks(hw, sge->timer_val[2])) |
-                   TIMERVALUE3(csio_us_to_core_ticks(hw, sge->timer_val[3])),
-                   SGE_TIMER_VALUE_2_AND_3);
+                   TIMERVALUE2_V(csio_us_to_core_ticks(hw, sge->timer_val[2])) |
+                   TIMERVALUE3_V(csio_us_to_core_ticks(hw, sge->timer_val[3])),
+                   SGE_TIMER_VALUE_2_AND_3_A);
 
         csio_wr_reg32(hw,
-                   TIMERVALUE4(csio_us_to_core_ticks(hw, sge->timer_val[4])) |
-                   TIMERVALUE5(csio_us_to_core_ticks(hw, sge->timer_val[5])),
-                   SGE_TIMER_VALUE_4_AND_5);
+                   TIMERVALUE4_V(csio_us_to_core_ticks(hw, sge->timer_val[4])) |
+                   TIMERVALUE5_V(csio_us_to_core_ticks(hw, sge->timer_val[5])),
+                   SGE_TIMER_VALUE_4_AND_5_A);
 
         csio_init_intr_coalesce_parms(hw);
 }
diff --git a/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c b/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c
index a83d2ceded83..dd00e5fe4a5e 100644
--- a/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c
+++ b/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c
@@ -28,6 +28,7 @@
 #include "t4fw_api.h"
 #include "l2t.h"
 #include "cxgb4i.h"
+#include "clip_tbl.h"
 
 static unsigned int dbg_level;
 
@@ -704,7 +705,7 @@ static void do_act_establish(struct cxgbi_device *cdev, struct sk_buff *skb)
         struct cpl_act_establish *req = (struct cpl_act_establish *)skb->data;
         unsigned short tcp_opt = ntohs(req->tcp_opt);
         unsigned int tid = GET_TID(req);
-        unsigned int atid = GET_TID_TID(ntohl(req->tos_atid));
+        unsigned int atid = TID_TID_G(ntohl(req->tos_atid));
         struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
         struct tid_info *t = lldi->tids;
         u32 rcv_isn = be32_to_cpu(req->rcv_isn);
@@ -752,15 +753,15 @@ static void do_act_establish(struct cxgbi_device *cdev, struct sk_buff *skb)
         if (cxgb4i_rcv_win > (RCV_BUFSIZ_MASK << 10))
                 csk->rcv_wup -= cxgb4i_rcv_win - (RCV_BUFSIZ_MASK << 10);
 
-        csk->advmss = lldi->mtus[GET_TCPOPT_MSS(tcp_opt)] - 40;
-        if (GET_TCPOPT_TSTAMP(tcp_opt))
+        csk->advmss = lldi->mtus[TCPOPT_MSS_G(tcp_opt)] - 40;
+        if (TCPOPT_TSTAMP_G(tcp_opt))
                 csk->advmss -= 12;
         if (csk->advmss < 128)
                 csk->advmss = 128;
 
         log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
                 "csk 0x%p, mss_idx %u, advmss %u.\n",
-                        csk, GET_TCPOPT_MSS(tcp_opt), csk->advmss);
+                        csk, TCPOPT_MSS_G(tcp_opt), csk->advmss);
 
         cxgbi_sock_established(csk, ntohl(req->snd_isn), ntohs(req->tcp_opt));
 
@@ -856,8 +857,8 @@ static void do_act_open_rpl(struct cxgbi_device *cdev, struct sk_buff *skb)
         struct cpl_act_open_rpl *rpl = (struct cpl_act_open_rpl *)skb->data;
         unsigned int tid = GET_TID(rpl);
         unsigned int atid =
-                GET_TID_TID(GET_AOPEN_ATID(be32_to_cpu(rpl->atid_status)));
-        unsigned int status = GET_AOPEN_STATUS(be32_to_cpu(rpl->atid_status));
+                TID_TID_G(AOPEN_ATID_G(be32_to_cpu(rpl->atid_status)));
+        unsigned int status = AOPEN_STATUS_G(be32_to_cpu(rpl->atid_status));
         struct cxgb4_lld_info *lldi = cxgbi_cdev_priv(cdev);
         struct tid_info *t = lldi->tids;
 
@@ -1112,7 +1113,7 @@ static void do_rx_iscsi_hdr(struct cxgbi_device *cdev, struct sk_buff *skb)
                 hlen = ntohs(cpl->len);
                 dlen = ntohl(*(unsigned int *)(bhs + 4)) & 0xFFFFFF;
 
-                plen = ISCSI_PDU_LEN(pdu_len_ddp);
+                plen = ISCSI_PDU_LEN_G(pdu_len_ddp);
                 if (is_t4(lldi->adapter_type))
                         plen -= 40;
 
@@ -1322,6 +1323,9 @@ static inline void l2t_put(struct cxgbi_sock *csk)
 static void release_offload_resources(struct cxgbi_sock *csk)
 {
         struct cxgb4_lld_info *lldi;
+#if IS_ENABLED(CONFIG_IPV6)
+        struct net_device *ndev = csk->cdev->ports[csk->port_id];
+#endif
 
         log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
                 "csk 0x%p,%u,0x%lx,%u.\n",
@@ -1334,6 +1338,12 @@ static void release_offload_resources(struct cxgbi_sock *csk)
         }
 
         l2t_put(csk);
+#if IS_ENABLED(CONFIG_IPV6)
+        if (csk->csk_family == AF_INET6)
+                cxgb4_clip_release(ndev,
+                                   (const u32 *)&csk->saddr6.sin6_addr, 1);
+#endif
+
         if (cxgbi_sock_flag(csk, CTPF_HAS_ATID))
                 free_atid(csk);
         else if (cxgbi_sock_flag(csk, CTPF_HAS_TID)) {
@@ -1391,10 +1401,15 @@ static int init_act_open(struct cxgbi_sock *csk)
         csk->l2t = cxgb4_l2t_get(lldi->l2t, n, ndev, 0);
         if (!csk->l2t) {
                 pr_err("%s, cannot alloc l2t.\n", ndev->name);
-                goto rel_resource;
+                goto rel_resource_without_clip;
         }
         cxgbi_sock_get(csk);
 
+#if IS_ENABLED(CONFIG_IPV6)
+        if (csk->csk_family == AF_INET6)
+                cxgb4_clip_get(ndev, (const u32 *)&csk->saddr6.sin6_addr, 1);
+#endif
+
         if (t4) {
                 size = sizeof(struct cpl_act_open_req);
                 size6 = sizeof(struct cpl_act_open_req6);
@@ -1451,6 +1466,12 @@ static int init_act_open(struct cxgbi_sock *csk)
         return 0;
 
 rel_resource:
+#if IS_ENABLED(CONFIG_IPV6)
+        if (csk->csk_family == AF_INET6)
+                cxgb4_clip_release(ndev,
+                                   (const u32 *)&csk->saddr6.sin6_addr, 1);
+#endif
+rel_resource_without_clip:
         if (n)
                 neigh_release(n);
         if (skb)
@@ -1619,7 +1640,7 @@ static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk, unsigned int tid,
         req = (struct cpl_set_tcb_field *)skb->head;
         INIT_TP_WR(req, csk->tid);
         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, csk->tid));
-        req->reply_ctrl = htons(NO_REPLY(reply) | QUEUENO(csk->rss_qid));
+        req->reply_ctrl = htons(NO_REPLY_V(reply) | QUEUENO_V(csk->rss_qid));
         req->word_cookie = htons(0);
         req->mask = cpu_to_be64(0x3 << 8);
         req->val = cpu_to_be64(pg_idx << 8);
@@ -1651,7 +1672,7 @@ static int ddp_setup_conn_digest(struct cxgbi_sock *csk, unsigned int tid,
         req = (struct cpl_set_tcb_field *)skb->head;
         INIT_TP_WR(req, tid);
         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, tid));
-        req->reply_ctrl = htons(NO_REPLY(reply) | QUEUENO(csk->rss_qid));
+        req->reply_ctrl = htons(NO_REPLY_V(reply) | QUEUENO_V(csk->rss_qid));
         req->word_cookie = htons(0);
         req->mask = cpu_to_be64(0x3 << 4);
         req->val = cpu_to_be64(((hcrc ? ULP_CRC_HEADER : 0) |
diff --git a/drivers/scsi/dc395x.c b/drivers/scsi/dc395x.c
index 0c6be0a17f53..5ee7f44cf869 100644
--- a/drivers/scsi/dc395x.c
+++ b/drivers/scsi/dc395x.c
@@ -4610,13 +4610,10 @@ static void adapter_uninit(struct AdapterCtlBlk *acb)
 }
 
 
-#undef SPRINTF
-#define SPRINTF(args...) seq_printf(m,##args)
-
 #undef YESNO
 #define YESNO(YN) \
- if (YN) SPRINTF(" Yes ");\
- else SPRINTF(" No  ")
+ if (YN) seq_printf(m, " Yes ");\
+ else seq_printf(m, " No  ")
 
 static int dc395x_show_info(struct seq_file *m, struct Scsi_Host *host)
 {
@@ -4626,47 +4623,45 @@ static int dc395x_show_info(struct seq_file *m, struct Scsi_Host *host)
         unsigned long flags;
         int dev;
 
-        SPRINTF(DC395X_BANNER " PCI SCSI Host Adapter\n");
-        SPRINTF(" Driver Version " DC395X_VERSION "\n");
+        seq_puts(m, DC395X_BANNER " PCI SCSI Host Adapter\n"
+                " Driver Version " DC395X_VERSION "\n");
 
         DC395x_LOCK_IO(acb->scsi_host, flags);
 
-        SPRINTF("SCSI Host Nr %i, ", host->host_no);
-        SPRINTF("DC395U/UW/F DC315/U %s\n",
+        seq_printf(m, "SCSI Host Nr %i, ", host->host_no);
+        seq_printf(m, "DC395U/UW/F DC315/U %s\n",
                 (acb->config & HCC_WIDE_CARD) ? "Wide" : "");
-        SPRINTF("io_port_base 0x%04lx, ", acb->io_port_base);
-        SPRINTF("irq_level 0x%04x, ", acb->irq_level);
-        SPRINTF(" SelTimeout %ims\n", (1638 * acb->sel_timeout) / 1000);
+        seq_printf(m, "io_port_base 0x%04lx, ", acb->io_port_base);
+        seq_printf(m, "irq_level 0x%04x, ", acb->irq_level);
+        seq_printf(m, " SelTimeout %ims\n", (1638 * acb->sel_timeout) / 1000);
 
-        SPRINTF("MaxID %i, MaxLUN %llu, ", host->max_id, host->max_lun);
-        SPRINTF("AdapterID %i\n", host->this_id);
+        seq_printf(m, "MaxID %i, MaxLUN %llu, ", host->max_id, host->max_lun);
+        seq_printf(m, "AdapterID %i\n", host->this_id);
 
-        SPRINTF("tag_max_num %i", acb->tag_max_num);
-        /*SPRINTF(", DMA_Status %i\n", DC395x_read8(acb, TRM_S1040_DMA_STATUS)); */
-        SPRINTF(", FilterCfg 0x%02x",
+        seq_printf(m, "tag_max_num %i", acb->tag_max_num);
+        /*seq_printf(m, ", DMA_Status %i\n", DC395x_read8(acb, TRM_S1040_DMA_STATUS)); */
+        seq_printf(m, ", FilterCfg 0x%02x",
                 DC395x_read8(acb, TRM_S1040_SCSI_CONFIG1));
-        SPRINTF(", DelayReset %is\n", acb->eeprom.delay_time);
-        /*SPRINTF("\n"); */
+        seq_printf(m, ", DelayReset %is\n", acb->eeprom.delay_time);
+        /*seq_printf(m, "\n"); */
 
-        SPRINTF("Nr of DCBs: %i\n", list_size(&acb->dcb_list));
-        SPRINTF
-            ("Map of attached LUNs: %02x %02x %02x %02x %02x %02x %02x %02x\n",
+        seq_printf(m, "Nr of DCBs: %i\n", list_size(&acb->dcb_list));
+        seq_printf(m, "Map of attached LUNs: %02x %02x %02x %02x %02x %02x %02x %02x\n",
              acb->dcb_map[0], acb->dcb_map[1], acb->dcb_map[2],
              acb->dcb_map[3], acb->dcb_map[4], acb->dcb_map[5],
              acb->dcb_map[6], acb->dcb_map[7]);
-        SPRINTF
-            ("                      %02x %02x %02x %02x %02x %02x %02x %02x\n",
+        seq_printf(m, "                      %02x %02x %02x %02x %02x %02x %02x %02x\n",
              acb->dcb_map[8], acb->dcb_map[9], acb->dcb_map[10],
              acb->dcb_map[11], acb->dcb_map[12], acb->dcb_map[13],
              acb->dcb_map[14], acb->dcb_map[15]);
 
-        SPRINTF
-            ("Un ID LUN Prty Sync Wide DsCn SndS TagQ nego_period SyncFreq SyncOffs MaxCmd\n");
+        seq_puts(m,
+                 "Un ID LUN Prty Sync Wide DsCn SndS TagQ nego_period SyncFreq SyncOffs MaxCmd\n");
 
         dev = 0;
         list_for_each_entry(dcb, &acb->dcb_list, list) {
                 int nego_period;
-                SPRINTF("%02i %02i  %02i ", dev, dcb->target_id,
+                seq_printf(m, "%02i %02i  %02i ", dev, dcb->target_id,
                         dcb->target_lun);
                 YESNO(dcb->dev_mode & NTC_DO_PARITY_CHK);
                 YESNO(dcb->sync_offset);
@@ -4676,53 +4671,53 @@ static int dc395x_show_info(struct seq_file *m, struct Scsi_Host *host)
                 YESNO(dcb->sync_mode & EN_TAG_QUEUEING);
                 nego_period = clock_period[dcb->sync_period & 0x07] << 2;
                 if (dcb->sync_offset)
-                        SPRINTF("  %03i ns ", nego_period);
+                        seq_printf(m, "  %03i ns ", nego_period);
                 else
-                        SPRINTF(" (%03i ns)", (dcb->min_nego_period << 2));
+                        seq_printf(m, " (%03i ns)", (dcb->min_nego_period << 2));
 
                 if (dcb->sync_offset & 0x0f) {
                         spd = 1000 / (nego_period);
                         spd1 = 1000 % (nego_period);
                         spd1 = (spd1 * 10 + nego_period / 2) / (nego_period);
-                        SPRINTF("   %2i.%1i M     %02i ", spd, spd1,
+                        seq_printf(m, "   %2i.%1i M     %02i ", spd, spd1,
                                 (dcb->sync_offset & 0x0f));
                 } else
-                        SPRINTF("                 ");
+                        seq_puts(m, "                 ");
 
                 /* Add more info ... */
-                SPRINTF("     %02i\n", dcb->max_command);
+                seq_printf(m, "     %02i\n", dcb->max_command);
                 dev++;
         }
 
         if (timer_pending(&acb->waiting_timer))
-                SPRINTF("Waiting queue timer running\n");
+                seq_puts(m, "Waiting queue timer running\n");
         else
-                SPRINTF("\n");
+                seq_putc(m, '\n');
 
         list_for_each_entry(dcb, &acb->dcb_list, list) {
                 struct ScsiReqBlk *srb;
                 if (!list_empty(&dcb->srb_waiting_list))
-                        SPRINTF("DCB (%02i-%i): Waiting: %i:",
+                        seq_printf(m, "DCB (%02i-%i): Waiting: %i:",
                                 dcb->target_id, dcb->target_lun,
                                 list_size(&dcb->srb_waiting_list));
                 list_for_each_entry(srb, &dcb->srb_waiting_list, list)
-                        SPRINTF(" %p", srb->cmd);
+                        seq_printf(m, " %p", srb->cmd);
                 if (!list_empty(&dcb->srb_going_list))
-                        SPRINTF("\nDCB (%02i-%i): Going  : %i:",
+                        seq_printf(m, "\nDCB (%02i-%i): Going  : %i:",
                                 dcb->target_id, dcb->target_lun,
                                 list_size(&dcb->srb_going_list));
                 list_for_each_entry(srb, &dcb->srb_going_list, list)
-                        SPRINTF(" %p", srb->cmd);
+                        seq_printf(m, " %p", srb->cmd);
                 if (!list_empty(&dcb->srb_waiting_list) || !list_empty(&dcb->srb_going_list))
-                        SPRINTF("\n");
+                        seq_putc(m, '\n');
         }
 
         if (debug_enabled(DBG_1)) {
-                SPRINTF("DCB list for ACB %p:\n", acb);
+                seq_printf(m, "DCB list for ACB %p:\n", acb);
                 list_for_each_entry(dcb, &acb->dcb_list, list) {
-                        SPRINTF("%p -> ", dcb);
+                        seq_printf(m, "%p -> ", dcb);
                 }
-                SPRINTF("END\n");
+                seq_puts(m, "END\n");
         }
 
         DC395x_UNLOCK_IO(acb->scsi_host, flags);
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index 0bf976936a10..2806cfbec2b9 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -568,7 +568,7 @@ static int adpt_show_info(struct seq_file *m, struct Scsi_Host *host)
         seq_printf(m, "\tpost fifo size  = %d\n\treply fifo size = %d\n\tsg table size   = %d\n\n",
                         host->can_queue, (int) pHba->reply_fifo_size , host->sg_tablesize);
 
-        seq_printf(m, "Devices:\n");
+        seq_puts(m, "Devices:\n");
         for(chan = 0; chan < MAX_CHANNEL; chan++) {
                 for(id = 0; id < MAX_ID; id++) {
                         d = pHba->channel[chan].device[id];
diff --git a/drivers/scsi/eata_pio.c b/drivers/scsi/eata_pio.c
index 8319d2b417b8..ca8003f0d8a3 100644
--- a/drivers/scsi/eata_pio.c
+++ b/drivers/scsi/eata_pio.c
@@ -102,7 +102,7 @@ static int eata_pio_show_info(struct seq_file *m, struct Scsi_Host *shost)
                    shost->host_no, SD(shost)->name);
         seq_printf(m, "Firmware revision: v%s\n",
                    SD(shost)->revision);
-        seq_printf(m, "IO: PIO\n");
+        seq_puts(m, "IO: PIO\n");
         seq_printf(m, "Base IO : %#.4x\n", (u32) shost->base);
         seq_printf(m, "Host Bus: %s\n",
                    (SD(shost)->bustype == 'P')?"PCI ":
diff --git a/drivers/scsi/esas2r/esas2r_init.c b/drivers/scsi/esas2r/esas2r_init.c
index 6776931e25d4..78ce4d61a69b 100644
--- a/drivers/scsi/esas2r/esas2r_init.c
+++ b/drivers/scsi/esas2r/esas2r_init.c
@@ -813,12 +813,13 @@ static void esas2r_init_pci_cfg_space(struct esas2r_adapter *a)
                 pci_read_config_word(a->pcid, pcie_cap_reg + PCI_EXP_DEVCTL,
                                      &devcontrol);
 
-                if ((devcontrol & PCI_EXP_DEVCTL_READRQ) > 0x2000) {
+                if ((devcontrol & PCI_EXP_DEVCTL_READRQ) >
+                     PCI_EXP_DEVCTL_READRQ_512B) {
                         esas2r_log(ESAS2R_LOG_INFO,
                                    "max read request size > 512B");
 
                         devcontrol &= ~PCI_EXP_DEVCTL_READRQ;
-                        devcontrol |= 0x2000;
+                        devcontrol |= PCI_EXP_DEVCTL_READRQ_512B;
                         pci_write_config_word(a->pcid,
                                               pcie_cap_reg + PCI_EXP_DEVCTL,
                                               devcontrol);
diff --git a/drivers/scsi/esas2r/esas2r_main.c b/drivers/scsi/esas2r/esas2r_main.c
index 7e1c21e6736b..31f8966b2e03 100644
--- a/drivers/scsi/esas2r/esas2r_main.c
+++ b/drivers/scsi/esas2r/esas2r_main.c
@@ -749,7 +749,7 @@ int esas2r_show_info(struct seq_file *m, struct Scsi_Host *sh)
         if (dev_count == 0)
                 seq_puts(m, "none\n");
 
-        seq_puts(m, "\n");
+        seq_putc(m, '\n');
         return 0;
 
 }
diff --git a/drivers/scsi/esp_scsi.c b/drivers/scsi/esp_scsi.c
index ce5bd52fe692..065b25df741b 100644
--- a/drivers/scsi/esp_scsi.c
+++ b/drivers/scsi/esp_scsi.c
@@ -2396,8 +2396,6 @@ int scsi_esp_register(struct esp *esp, struct device *dev)
 
         if (!esp->num_tags)
                 esp->num_tags = ESP_DEFAULT_TAGS;
-        else if (esp->num_tags >= ESP_MAX_TAG)
-                esp->num_tags = ESP_MAX_TAG - 1;
         esp->host->transportt = esp_transport_template;
         esp->host->max_lun = ESP_MAX_LUN;
         esp->host->cmd_per_lun = 2;
diff --git a/drivers/scsi/gdth_proc.c b/drivers/scsi/gdth_proc.c
index 9fb632684863..e66e997992e3 100644
--- a/drivers/scsi/gdth_proc.c
+++ b/drivers/scsi/gdth_proc.c
@@ -173,7 +173,7 @@ int gdth_show_info(struct seq_file *m, struct Scsi_Host *host)
     /* request is i.e. "cat /proc/scsi/gdth/0" */ 
     /* format: %-15s\t%-10s\t%-15s\t%s */
     /* driver parameters */
-    seq_printf(m, "Driver Parameters:\n");
+    seq_puts(m, "Driver Parameters:\n");
     if (reserve_list[0] == 0xff)
         strcpy(hrec, "--");
     else {
@@ -192,7 +192,7 @@ int gdth_show_info(struct seq_file *m, struct Scsi_Host *host)
                    max_ids, hdr_channel);
 
     /* controller information */
-    seq_printf(m,"\nDisk Array Controller Information:\n");
+    seq_puts(m, "\nDisk Array Controller Information:\n");
     seq_printf(m,
                    " Number:       \t%d         \tName:          \t%s\n",
                    ha->hanum, ha->binfo.type_string);
@@ -219,7 +219,7 @@ int gdth_show_info(struct seq_file *m, struct Scsi_Host *host)
 
 #ifdef GDTH_DMA_STATISTICS
     /* controller statistics */
-    seq_printf(m,"\nController Statistics:\n");
+    seq_puts(m, "\nController Statistics:\n");
     seq_printf(m,
                    " 32-bit DMA buffer:\t%lu\t64-bit DMA buffer:\t%lu\n",
                    ha->dma32_cnt, ha->dma64_cnt);
@@ -227,7 +227,7 @@ int gdth_show_info(struct seq_file *m, struct Scsi_Host *host)
 
     if (ha->more_proc) {
         /* more information: 2. about physical devices */
-        seq_printf(m, "\nPhysical Devices:");
+        seq_puts(m, "\nPhysical Devices:");
         flag = FALSE;
             
         buf = gdth_ioctl_alloc(ha, GDTH_SCRATCH, FALSE, &paddr);
@@ -326,10 +326,10 @@ int gdth_show_info(struct seq_file *m, struct Scsi_Host *host)
         gdth_ioctl_free(ha, GDTH_SCRATCH, buf, paddr);
 
         if (!flag)
-            seq_printf(m, "\n --\n");
+            seq_puts(m, "\n --\n");
 
         /* 3. about logical drives */
-        seq_printf(m,"\nLogical Drives:");
+        seq_puts(m, "\nLogical Drives:");
         flag = FALSE;
 
         buf = gdth_ioctl_alloc(ha, GDTH_SCRATCH, FALSE, &paddr);
@@ -411,10 +411,10 @@ int gdth_show_info(struct seq_file *m, struct Scsi_Host *host)
         gdth_ioctl_free(ha, GDTH_SCRATCH, buf, paddr);
         
         if (!flag)
-            seq_printf(m, "\n --\n");
+            seq_puts(m, "\n --\n");
 
         /* 4. about array drives */
-        seq_printf(m,"\nArray Drives:");
+        seq_puts(m, "\nArray Drives:");
         flag = FALSE;
 
         buf = gdth_ioctl_alloc(ha, GDTH_SCRATCH, FALSE, &paddr);
@@ -471,10 +471,10 @@ int gdth_show_info(struct seq_file *m, struct Scsi_Host *host)
         gdth_ioctl_free(ha, GDTH_SCRATCH, buf, paddr);
         
         if (!flag)
-            seq_printf(m, "\n --\n");
+            seq_puts(m, "\n --\n");
 
         /* 5. about host drives */
-        seq_printf(m,"\nHost Drives:");
+        seq_puts(m, "\nHost Drives:");
         flag = FALSE;
 
         buf = gdth_ioctl_alloc(ha, sizeof(gdth_hget_str), FALSE, &paddr);
@@ -527,11 +527,11 @@ int gdth_show_info(struct seq_file *m, struct Scsi_Host *host)
         }
         
         if (!flag)
-            seq_printf(m, "\n --\n");
+            seq_puts(m, "\n --\n");
     }
 
     /* controller events */
-    seq_printf(m,"\nController Events:\n");
+    seq_puts(m, "\nController Events:\n");
 
     for (id = -1;;) {
         id = gdth_read_event(ha, id, estr);
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index 6bb4611b238a..a1cfbd3dda47 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -50,6 +50,7 @@
 #include <linux/jiffies.h>
 #include <linux/percpu-defs.h>
 #include <linux/percpu.h>
+#include <asm/unaligned.h>
 #include <asm/div64.h>
 #include "hpsa_cmd.h"
 #include "hpsa.h"
@@ -59,8 +60,11 @@
 #define DRIVER_NAME "HP HPSA Driver (v " HPSA_DRIVER_VERSION ")"
 #define HPSA "hpsa"
 
-/* How long to wait (in milliseconds) for board to go into simple mode */
-#define MAX_CONFIG_WAIT 30000
+/* How long to wait for CISS doorbell communication */
+#define CLEAR_EVENT_WAIT_INTERVAL 20    /* ms for each msleep() call */
+#define MODE_CHANGE_WAIT_INTERVAL 10    /* ms for each msleep() call */
+#define MAX_CLEAR_EVENT_WAIT 30000      /* times 20 ms = 600 s */
+#define MAX_MODE_CHANGE_WAIT 2000       /* times 10 ms = 20 s */
 #define MAX_IOCTL_CONFIG_WAIT 1000
 
 /*define how many times we will try a command because of bus resets */
@@ -164,24 +168,24 @@ static struct board_type products[] = {
         {0x1926103C, "Smart Array P731m", &SA5_access},
         {0x1928103C, "Smart Array P230i", &SA5_access},
         {0x1929103C, "Smart Array P530", &SA5_access},
-        {0x21BD103C, "Smart Array", &SA5_access},
-        {0x21BE103C, "Smart Array", &SA5_access},
-        {0x21BF103C, "Smart Array", &SA5_access},
-        {0x21C0103C, "Smart Array", &SA5_access},
-        {0x21C1103C, "Smart Array", &SA5_access},
-        {0x21C2103C, "Smart Array", &SA5_access},
-        {0x21C3103C, "Smart Array", &SA5_access},
+        {0x21BD103C, "Smart Array P244br", &SA5_access},
+        {0x21BE103C, "Smart Array P741m", &SA5_access},
+        {0x21BF103C, "Smart HBA H240ar", &SA5_access},
+        {0x21C0103C, "Smart Array P440ar", &SA5_access},
+        {0x21C1103C, "Smart Array P840ar", &SA5_access},
+        {0x21C2103C, "Smart Array P440", &SA5_access},
+        {0x21C3103C, "Smart Array P441", &SA5_access},
         {0x21C4103C, "Smart Array", &SA5_access},
-        {0x21C5103C, "Smart Array", &SA5_access},
-        {0x21C6103C, "Smart Array", &SA5_access},
-        {0x21C7103C, "Smart Array", &SA5_access},
-        {0x21C8103C, "Smart Array", &SA5_access},
+        {0x21C5103C, "Smart Array P841", &SA5_access},
+        {0x21C6103C, "Smart HBA H244br", &SA5_access},
+        {0x21C7103C, "Smart HBA H240", &SA5_access},
+        {0x21C8103C, "Smart HBA H241", &SA5_access},
         {0x21C9103C, "Smart Array", &SA5_access},
-        {0x21CA103C, "Smart Array", &SA5_access},
-        {0x21CB103C, "Smart Array", &SA5_access},
+        {0x21CA103C, "Smart Array P246br", &SA5_access},
+        {0x21CB103C, "Smart Array P840", &SA5_access},
         {0x21CC103C, "Smart Array", &SA5_access},
         {0x21CD103C, "Smart Array", &SA5_access},
-        {0x21CE103C, "Smart Array", &SA5_access},
+        {0x21CE103C, "Smart HBA", &SA5_access},
         {0x00761590, "HP Storage P1224 Array Controller", &SA5_access},
         {0x00871590, "HP Storage P1224e Array Controller", &SA5_access},
         {0x007D1590, "HP Storage P1228 Array Controller", &SA5_access},
@@ -195,8 +199,6 @@ static int number_of_controllers;
 static irqreturn_t do_hpsa_intr_intx(int irq, void *dev_id);
 static irqreturn_t do_hpsa_intr_msi(int irq, void *dev_id);
 static int hpsa_ioctl(struct scsi_device *dev, int cmd, void __user *arg);
-static void lock_and_start_io(struct ctlr_info *h);
-static void start_io(struct ctlr_info *h, unsigned long *flags);
 
 #ifdef CONFIG_COMPAT
 static int hpsa_compat_ioctl(struct scsi_device *dev, int cmd,
@@ -204,18 +206,18 @@ static int hpsa_compat_ioctl(struct scsi_device *dev, int cmd,
 #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 int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
         void *buff, size_t size, u16 page_code, unsigned char *scsi3addr,
         int cmd_type);
+static void hpsa_free_cmd_pool(struct ctlr_info *h);
 #define VPD_PAGE (1 << 8)
 
 static int hpsa_scsi_queue_command(struct Scsi_Host *h, struct scsi_cmnd *cmd);
 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);
 
 static int hpsa_eh_device_reset_handler(struct scsi_cmnd *scsicmd);
 static int hpsa_eh_abort_handler(struct scsi_cmnd *scsicmd);
@@ -229,7 +231,7 @@ 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 min_blocks, int *bucket_map);
+        int nsgs, int min_blocks, u32 *bucket_map);
 static void hpsa_put_ctlr_into_performant_mode(struct ctlr_info *h);
 static inline u32 next_command(struct ctlr_info *h, u8 q);
 static int hpsa_find_cfg_addrs(struct pci_dev *pdev, void __iomem *vaddr,
@@ -241,14 +243,15 @@ static int hpsa_lookup_board_id(struct pci_dev *pdev, u32 *board_id);
 static int hpsa_wait_for_board_state(struct pci_dev *pdev, void __iomem *vaddr,
                                      int wait_for_ready);
 static inline void finish_cmd(struct CommandList *c);
-static void hpsa_wait_for_mode_change_ack(struct ctlr_info *h);
+static int hpsa_wait_for_mode_change_ack(struct ctlr_info *h);
 #define BOARD_NOT_READY 0
 #define BOARD_READY 1
 static void hpsa_drain_accel_commands(struct ctlr_info *h);
 static void hpsa_flush_cache(struct ctlr_info *h);
 static int hpsa_scsi_ioaccel_queue_command(struct ctlr_info *h,
         struct CommandList *c, u32 ioaccel_handle, u8 *cdb, int cdb_len,
-        u8 *scsi3addr);
+        u8 *scsi3addr, struct hpsa_scsi_dev_t *phys_disk);
+static void hpsa_command_resubmit_worker(struct work_struct *work);
 
 static inline struct ctlr_info *sdev_to_hba(struct scsi_device *sdev)
 {
@@ -505,8 +508,8 @@ static inline int is_logical_dev_addr_mode(unsigned char scsi3addr[])
         return (scsi3addr[3] & 0xC0) == 0x40;
 }
 
-static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
-        "1(ADM)", "UNKNOWN"
+static const char * const raid_label[] = { "0", "4", "1(+0)", "5", "5+1", "6",
+        "1(+0)ADM", "UNKNOWN"
 };
 #define HPSA_RAID_0     0
 #define HPSA_RAID_4     1
@@ -671,7 +674,7 @@ static struct scsi_host_template hpsa_driver_template = {
         .queuecommand           = hpsa_scsi_queue_command,
         .scan_start             = hpsa_scan_start,
         .scan_finished          = hpsa_scan_finished,
-        .change_queue_depth     = scsi_change_queue_depth,
+        .change_queue_depth     = hpsa_change_queue_depth,
         .this_id                = -1,
         .use_clustering         = ENABLE_CLUSTERING,
         .eh_abort_handler       = hpsa_eh_abort_handler,
@@ -688,13 +691,6 @@ static struct scsi_host_template hpsa_driver_template = {
         .no_write_same = 1,
 };
 
-
-/* Enqueuing and dequeuing functions for cmdlists. */
-static inline void addQ(struct list_head *list, struct CommandList *c)
-{
-        list_add_tail(&c->list, list);
-}
-
 static inline u32 next_command(struct ctlr_info *h, u8 q)
 {
         u32 a;
@@ -828,31 +824,21 @@ static void dial_up_lockup_detection_on_fw_flash_complete(struct ctlr_info *h,
 static void enqueue_cmd_and_start_io(struct ctlr_info *h,
         struct CommandList *c)
 {
-        unsigned long flags;
-
+        dial_down_lockup_detection_during_fw_flash(h, c);
+        atomic_inc(&h->commands_outstanding);
         switch (c->cmd_type) {
         case CMD_IOACCEL1:
                 set_ioaccel1_performant_mode(h, c);
+                writel(c->busaddr, h->vaddr + SA5_REQUEST_PORT_OFFSET);
                 break;
         case CMD_IOACCEL2:
                 set_ioaccel2_performant_mode(h, c);
+                writel(c->busaddr, h->vaddr + IOACCEL2_INBOUND_POSTQ_32);
                 break;
         default:
                 set_performant_mode(h, c);
+                h->access.submit_command(h, c);
         }
-        dial_down_lockup_detection_during_fw_flash(h, c);
-        spin_lock_irqsave(&h->lock, flags);
-        addQ(&h->reqQ, c);
-        h->Qdepth++;
-        start_io(h, &flags);
-        spin_unlock_irqrestore(&h->lock, flags);
-}
-
-static inline void removeQ(struct CommandList *c)
-{
-        if (WARN_ON(list_empty(&c->list)))
-                return;
-        list_del_init(&c->list);
 }
 
 static inline int is_hba_lunid(unsigned char scsi3addr[])
@@ -919,7 +905,7 @@ static int hpsa_scsi_add_entry(struct ctlr_info *h, int hostno,
 
         /* 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.
+         * unit no, zero otherwise.
          */
         if (device->scsi3addr[4] == 0) {
                 /* This is not a non-zero lun of a multi-lun device */
@@ -984,12 +970,24 @@ static void hpsa_scsi_update_entry(struct ctlr_info *h, int hostno,
         /* Raid level changed. */
         h->dev[entry]->raid_level = new_entry->raid_level;
 
-        /* Raid offload parameters changed. */
+        /* Raid offload parameters changed.  Careful about the ordering. */
+        if (new_entry->offload_config && new_entry->offload_enabled) {
+                /*
+                 * if drive is newly offload_enabled, we want to copy the
+                 * raid map data first.  If previously offload_enabled and
+                 * offload_config were set, raid map data had better be
+                 * the same as it was before.  if raid map data is changed
+                 * then it had better be the case that
+                 * h->dev[entry]->offload_enabled is currently 0.
+                 */
+                h->dev[entry]->raid_map = new_entry->raid_map;
+                h->dev[entry]->ioaccel_handle = new_entry->ioaccel_handle;
+                wmb(); /* ensure raid map updated prior to ->offload_enabled */
+        }
         h->dev[entry]->offload_config = new_entry->offload_config;
-        h->dev[entry]->offload_enabled = new_entry->offload_enabled;
-        h->dev[entry]->ioaccel_handle = new_entry->ioaccel_handle;
         h->dev[entry]->offload_to_mirror = new_entry->offload_to_mirror;
-        h->dev[entry]->raid_map = new_entry->raid_map;
+        h->dev[entry]->offload_enabled = new_entry->offload_enabled;
+        h->dev[entry]->queue_depth = new_entry->queue_depth;
 
         dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d updated.\n",
                 scsi_device_type(new_entry->devtype), hostno, new_entry->bus,
@@ -1115,6 +1113,8 @@ static inline int device_updated(struct hpsa_scsi_dev_t *dev1,
                 return 1;
         if (dev1->offload_enabled != dev2->offload_enabled)
                 return 1;
+        if (dev1->queue_depth != dev2->queue_depth)
+                return 1;
         return 0;
 }
 
@@ -1260,6 +1260,85 @@ static void hpsa_show_volume_status(struct ctlr_info *h,
         }
 }
 
+/*
+ * Figure the list of physical drive pointers for a logical drive with
+ * raid offload configured.
+ */
+static void hpsa_figure_phys_disk_ptrs(struct ctlr_info *h,
+                                struct hpsa_scsi_dev_t *dev[], int ndevices,
+                                struct hpsa_scsi_dev_t *logical_drive)
+{
+        struct raid_map_data *map = &logical_drive->raid_map;
+        struct raid_map_disk_data *dd = &map->data[0];
+        int i, j;
+        int total_disks_per_row = le16_to_cpu(map->data_disks_per_row) +
+                                le16_to_cpu(map->metadata_disks_per_row);
+        int nraid_map_entries = le16_to_cpu(map->row_cnt) *
+                                le16_to_cpu(map->layout_map_count) *
+                                total_disks_per_row;
+        int nphys_disk = le16_to_cpu(map->layout_map_count) *
+                                total_disks_per_row;
+        int qdepth;
+
+        if (nraid_map_entries > RAID_MAP_MAX_ENTRIES)
+                nraid_map_entries = RAID_MAP_MAX_ENTRIES;
+
+        qdepth = 0;
+        for (i = 0; i < nraid_map_entries; i++) {
+                logical_drive->phys_disk[i] = NULL;
+                if (!logical_drive->offload_config)
+                        continue;
+                for (j = 0; j < ndevices; j++) {
+                        if (dev[j]->devtype != TYPE_DISK)
+                                continue;
+                        if (is_logical_dev_addr_mode(dev[j]->scsi3addr))
+                                continue;
+                        if (dev[j]->ioaccel_handle != dd[i].ioaccel_handle)
+                                continue;
+
+                        logical_drive->phys_disk[i] = dev[j];
+                        if (i < nphys_disk)
+                                qdepth = min(h->nr_cmds, qdepth +
+                                    logical_drive->phys_disk[i]->queue_depth);
+                        break;
+                }
+
+                /*
+                 * This can happen if a physical drive is removed and
+                 * the logical drive is degraded.  In that case, the RAID
+                 * map data will refer to a physical disk which isn't actually
+                 * present.  And in that case offload_enabled should already
+                 * be 0, but we'll turn it off here just in case
+                 */
+                if (!logical_drive->phys_disk[i]) {
+                        logical_drive->offload_enabled = 0;
+                        logical_drive->queue_depth = h->nr_cmds;
+                }
+        }
+        if (nraid_map_entries)
+                /*
+                 * This is correct for reads, too high for full stripe writes,
+                 * way too high for partial stripe writes
+                 */
+                logical_drive->queue_depth = qdepth;
+        else
+                logical_drive->queue_depth = h->nr_cmds;
+}
+
+static void hpsa_update_log_drive_phys_drive_ptrs(struct ctlr_info *h,
+                                struct hpsa_scsi_dev_t *dev[], int ndevices)
+{
+        int i;
+
+        for (i = 0; i < ndevices; i++) {
+                if (dev[i]->devtype != TYPE_DISK)
+                        continue;
+                if (!is_logical_dev_addr_mode(dev[i]->scsi3addr))
+                        continue;
+                hpsa_figure_phys_disk_ptrs(h, dev, ndevices, dev[i]);
+        }
+}
+
 static void adjust_hpsa_scsi_table(struct ctlr_info *h, int hostno,
         struct hpsa_scsi_dev_t *sd[], int nsds)
 {
@@ -1444,8 +1523,12 @@ static int hpsa_slave_alloc(struct scsi_device *sdev)
         spin_lock_irqsave(&h->devlock, flags);
         sd = lookup_hpsa_scsi_dev(h, sdev_channel(sdev),
                 sdev_id(sdev), sdev->lun);
-        if (sd != NULL)
+        if (sd != NULL) {
                 sdev->hostdata = sd;
+                if (sd->queue_depth)
+                        scsi_change_queue_depth(sdev, sd->queue_depth);
+                atomic_set(&sd->ioaccel_cmds_out, 0);
+        }
         spin_unlock_irqrestore(&h->devlock, flags);
         return 0;
 }
@@ -1478,13 +1561,17 @@ static int hpsa_allocate_sg_chain_blocks(struct ctlr_info *h)
 
         h->cmd_sg_list = kzalloc(sizeof(*h->cmd_sg_list) * h->nr_cmds,
                                 GFP_KERNEL);
-        if (!h->cmd_sg_list)
+        if (!h->cmd_sg_list) {
+                dev_err(&h->pdev->dev, "Failed to allocate SG list\n");
                 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])
+                if (!h->cmd_sg_list[i]) {
+                        dev_err(&h->pdev->dev, "Failed to allocate cmd SG\n");
                         goto clean;
+                }
         }
         return 0;
 
@@ -1504,7 +1591,7 @@ static int hpsa_map_sg_chain_block(struct ctlr_info *h,
         chain_block = h->cmd_sg_list[c->cmdindex];
         chain_sg->Ext = cpu_to_le32(HPSA_SG_CHAIN);
         chain_len = sizeof(*chain_sg) *
-                (c->Header.SGTotal - h->max_cmd_sg_entries);
+                (le16_to_cpu(c->Header.SGTotal) - h->max_cmd_sg_entries);
         chain_sg->Len = cpu_to_le32(chain_len);
         temp64 = pci_map_single(h->pdev, chain_block, chain_len,
                                 PCI_DMA_TODEVICE);
@@ -1635,7 +1722,6 @@ static void process_ioaccel2_completion(struct ctlr_info *h,
                 struct hpsa_scsi_dev_t *dev)
 {
         struct io_accel2_cmd *c2 = &h->ioaccel2_cmd_pool[c->cmdindex];
-        int raid_retry = 0;
 
         /* check for good status */
         if (likely(c2->error_data.serv_response == 0 &&
@@ -1652,26 +1738,22 @@ static void process_ioaccel2_completion(struct ctlr_info *h,
         if (is_logical_dev_addr_mode(dev->scsi3addr) &&
                 c2->error_data.serv_response ==
                         IOACCEL2_SERV_RESPONSE_FAILURE) {
-                dev->offload_enabled = 0;
-                h->drv_req_rescan = 1;  /* schedule controller for a rescan */
-                cmd->result = DID_SOFT_ERROR << 16;
-                cmd_free(h, c);
-                cmd->scsi_done(cmd);
-                return;
-        }
-        raid_retry = handle_ioaccel_mode2_error(h, c, cmd, c2);
-        /* If error found, disable Smart Path, schedule a rescan,
-         * and force a retry on the standard path.
-         */
-        if (raid_retry) {
-                dev_warn(&h->pdev->dev, "%s: Retrying on standard path.\n",
-                        "HP SSD Smart Path");
-                dev->offload_enabled = 0; /* Disable Smart Path */
-                h->drv_req_rescan = 1;    /* schedule controller rescan */
-                cmd->result = DID_SOFT_ERROR << 16;
+                if (c2->error_data.status ==
+                        IOACCEL2_STATUS_SR_IOACCEL_DISABLED)
+                        dev->offload_enabled = 0;
+                goto retry_cmd;
         }
+
+        if (handle_ioaccel_mode2_error(h, c, cmd, c2))
+                goto retry_cmd;
+
         cmd_free(h, c);
         cmd->scsi_done(cmd);
+        return;
+
+retry_cmd:
+        INIT_WORK(&c->work, hpsa_command_resubmit_worker);
+        queue_work_on(raw_smp_processor_id(), h->resubmit_wq, &c->work);
 }
 
 static void complete_scsi_command(struct CommandList *cp)
@@ -1687,18 +1769,21 @@ static void complete_scsi_command(struct CommandList *cp)
         unsigned long sense_data_size;
 
         ei = cp->err_info;
-        cmd = (struct scsi_cmnd *) cp->scsi_cmd;
+        cmd = cp->scsi_cmd;
         h = cp->h;
         dev = cmd->device->hostdata;
 
         scsi_dma_unmap(cmd); /* undo the DMA mappings */
         if ((cp->cmd_type == CMD_SCSI) &&
-                (cp->Header.SGTotal > h->max_cmd_sg_entries))
+                (le16_to_cpu(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 */
 
+        if (cp->cmd_type == CMD_IOACCEL2 || cp->cmd_type == CMD_IOACCEL1)
+                atomic_dec(&cp->phys_disk->ioaccel_cmds_out);
+
         if (cp->cmd_type == CMD_IOACCEL2)
                 return process_ioaccel2_completion(h, cp, cmd, dev);
 
@@ -1706,6 +1791,8 @@ static void complete_scsi_command(struct CommandList *cp)
 
         scsi_set_resid(cmd, ei->ResidualCnt);
         if (ei->CommandStatus == 0) {
+                if (cp->cmd_type == CMD_IOACCEL1)
+                        atomic_dec(&cp->phys_disk->ioaccel_cmds_out);
                 cmd_free(h, cp);
                 cmd->scsi_done(cmd);
                 return;
@@ -1726,8 +1813,10 @@ static void complete_scsi_command(struct CommandList *cp)
          */
         if (cp->cmd_type == CMD_IOACCEL1) {
                 struct io_accel1_cmd *c = &h->ioaccel_cmd_pool[cp->cmdindex];
-                cp->Header.SGList = cp->Header.SGTotal = scsi_sg_count(cmd);
-                cp->Request.CDBLen = c->io_flags & IOACCEL1_IOFLAGS_CDBLEN_MASK;
+                cp->Header.SGList = scsi_sg_count(cmd);
+                cp->Header.SGTotal = cpu_to_le16(cp->Header.SGList);
+                cp->Request.CDBLen = le16_to_cpu(c->io_flags) &
+                        IOACCEL1_IOFLAGS_CDBLEN_MASK;
                 cp->Header.tag = c->tag;
                 memcpy(cp->Header.LUN.LunAddrBytes, c->CISS_LUN, 8);
                 memcpy(cp->Request.CDB, c->CDB, cp->Request.CDBLen);
@@ -1739,9 +1828,9 @@ static void complete_scsi_command(struct CommandList *cp)
                 if (is_logical_dev_addr_mode(dev->scsi3addr)) {
                         if (ei->CommandStatus == CMD_IOACCEL_DISABLED)
                                 dev->offload_enabled = 0;
-                        cmd->result = DID_SOFT_ERROR << 16;
-                        cmd_free(h, cp);
-                        cmd->scsi_done(cmd);
+                        INIT_WORK(&cp->work, hpsa_command_resubmit_worker);
+                        queue_work_on(raw_smp_processor_id(),
+                                        h->resubmit_wq, &cp->work);
                         return;
                 }
         }
@@ -1798,9 +1887,8 @@ static void complete_scsi_command(struct CommandList *cp)
         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);
+                dev_warn(&h->pdev->dev,
+                        "CDB %16phN data overrun\n", cp->Request.CDB);
                 break;
         case CMD_INVALID: {
                 /* print_bytes(cp, sizeof(*cp), 1, 0);
@@ -1816,34 +1904,38 @@ static void complete_scsi_command(struct CommandList *cp)
                 break;
         case CMD_PROTOCOL_ERR:
                 cmd->result = DID_ERROR << 16;
-                dev_warn(&h->pdev->dev, "cp %p has "
-                        "protocol error\n", cp);
+                dev_warn(&h->pdev->dev, "CDB %16phN : protocol error\n",
+                                cp->Request.CDB);
                 break;
         case CMD_HARDWARE_ERR:
                 cmd->result = DID_ERROR << 16;
-                dev_warn(&h->pdev->dev, "cp %p had  hardware error\n", cp);
+                dev_warn(&h->pdev->dev, "CDB %16phN : hardware error\n",
+                        cp->Request.CDB);
                 break;
         case CMD_CONNECTION_LOST:
                 cmd->result = DID_ERROR << 16;
-                dev_warn(&h->pdev->dev, "cp %p had connection lost\n", cp);
+                dev_warn(&h->pdev->dev, "CDB %16phN : connection lost\n",
+                        cp->Request.CDB);
                 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);
+                dev_warn(&h->pdev->dev, "CDB %16phN was aborted with status 0x%x\n",
+                                cp->Request.CDB, ei->ScsiStatus);
                 break;
         case CMD_ABORT_FAILED:
                 cmd->result = DID_ERROR << 16;
-                dev_warn(&h->pdev->dev, "cp %p reports abort failed\n", cp);
+                dev_warn(&h->pdev->dev, "CDB %16phN : abort failed\n",
+                        cp->Request.CDB);
                 break;
         case CMD_UNSOLICITED_ABORT:
                 cmd->result = DID_SOFT_ERROR << 16; /* retry the command */
-                dev_warn(&h->pdev->dev, "cp %p aborted due to an unsolicited "
-                        "abort\n", cp);
+                dev_warn(&h->pdev->dev, "CDB %16phN : unsolicited abort\n",
+                        cp->Request.CDB);
                 break;
         case CMD_TIMEOUT:
                 cmd->result = DID_TIME_OUT << 16;
-                dev_warn(&h->pdev->dev, "cp %p timedout\n", cp);
+                dev_warn(&h->pdev->dev, "CDB %16phN timed out\n",
+                        cp->Request.CDB);
                 break;
         case CMD_UNABORTABLE:
                 cmd->result = DID_ERROR << 16;
@@ -2048,10 +2140,10 @@ static int hpsa_scsi_do_inquiry(struct ctlr_info *h, unsigned char *scsi3addr,
         struct CommandList *c;
         struct ErrorInfo *ei;
 
-        c = cmd_special_alloc(h);
+        c = cmd_alloc(h);
 
-        if (c == NULL) {                        /* trouble... */
-                dev_warn(&h->pdev->dev, "cmd_special_alloc returned NULL!\n");
+        if (c == NULL) {
+                dev_warn(&h->pdev->dev, "cmd_alloc returned NULL!\n");
                 return -ENOMEM;
         }
 
@@ -2067,7 +2159,7 @@ static int hpsa_scsi_do_inquiry(struct ctlr_info *h, unsigned char *scsi3addr,
                 rc = -1;
         }
 out:
-        cmd_special_free(h, c);
+        cmd_free(h, c);
         return rc;
 }
 
@@ -2079,10 +2171,9 @@ static int hpsa_bmic_ctrl_mode_sense(struct ctlr_info *h,
         struct CommandList *c;
         struct ErrorInfo *ei;
 
-        c = cmd_special_alloc(h);
-
+        c = cmd_alloc(h);
         if (c == NULL) {                        /* trouble... */
-                dev_warn(&h->pdev->dev, "cmd_special_alloc returned NULL!\n");
+                dev_warn(&h->pdev->dev, "cmd_alloc returned NULL!\n");
                 return -ENOMEM;
         }
 
@@ -2098,7 +2189,7 @@ static int hpsa_bmic_ctrl_mode_sense(struct ctlr_info *h,
                 rc = -1;
         }
 out:
-        cmd_special_free(h, c);
+        cmd_free(h, c);
         return rc;
         }
 
@@ -2109,10 +2200,10 @@ static int hpsa_send_reset(struct ctlr_info *h, unsigned char *scsi3addr,
         struct CommandList *c;
         struct ErrorInfo *ei;
 
-        c = cmd_special_alloc(h);
+        c = cmd_alloc(h);
 
         if (c == NULL) {                        /* trouble... */
-                dev_warn(&h->pdev->dev, "cmd_special_alloc returned NULL!\n");
+                dev_warn(&h->pdev->dev, "cmd_alloc returned NULL!\n");
                 return -ENOMEM;
         }
 
@@ -2128,7 +2219,7 @@ static int hpsa_send_reset(struct ctlr_info *h, unsigned char *scsi3addr,
                 hpsa_scsi_interpret_error(h, c);
                 rc = -1;
         }
-        cmd_special_free(h, c);
+        cmd_free(h, c);
         return rc;
 }
 
@@ -2191,15 +2282,13 @@ static void hpsa_debug_map_buff(struct ctlr_info *h, int rc,
                         le16_to_cpu(map_buff->row_cnt));
         dev_info(&h->pdev->dev, "layout_map_count = %u\n",
                         le16_to_cpu(map_buff->layout_map_count));
-        dev_info(&h->pdev->dev, "flags = %u\n",
+        dev_info(&h->pdev->dev, "flags = 0x%x\n",
                         le16_to_cpu(map_buff->flags));
-        if (map_buff->flags & RAID_MAP_FLAG_ENCRYPT_ON)
-                dev_info(&h->pdev->dev, "encrypytion = ON\n");
-        else
-                dev_info(&h->pdev->dev, "encrypytion = OFF\n");
+        dev_info(&h->pdev->dev, "encrypytion = %s\n",
+                        le16_to_cpu(map_buff->flags) &
+                        RAID_MAP_FLAG_ENCRYPT_ON ?  "ON" : "OFF");
         dev_info(&h->pdev->dev, "dekindex = %u\n",
                         le16_to_cpu(map_buff->dekindex));
-
         map_cnt = le16_to_cpu(map_buff->layout_map_count);
         for (map = 0; map < map_cnt; map++) {
                 dev_info(&h->pdev->dev, "Map%u:\n", map);
@@ -2238,26 +2327,26 @@ static int hpsa_get_raid_map(struct ctlr_info *h,
         struct CommandList *c;
         struct ErrorInfo *ei;
 
-        c = cmd_special_alloc(h);
+        c = cmd_alloc(h);
         if (c == NULL) {
-                dev_warn(&h->pdev->dev, "cmd_special_alloc returned NULL!\n");
+                dev_warn(&h->pdev->dev, "cmd_alloc returned NULL!\n");
                 return -ENOMEM;
         }
         if (fill_cmd(c, HPSA_GET_RAID_MAP, h, &this_device->raid_map,
                         sizeof(this_device->raid_map), 0,
                         scsi3addr, TYPE_CMD)) {
                 dev_warn(&h->pdev->dev, "Out of memory in hpsa_get_raid_map()\n");
-                cmd_special_free(h, c);
+                cmd_free(h, c);
                 return -ENOMEM;
         }
         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(h, c);
-                cmd_special_free(h, c);
+                cmd_free(h, c);
                 return -1;
         }
-        cmd_special_free(h, c);
+        cmd_free(h, c);
 
         /* @todo in the future, dynamically allocate RAID map memory */
         if (le32_to_cpu(this_device->raid_map.structure_size) >
@@ -2269,6 +2358,34 @@ static int hpsa_get_raid_map(struct ctlr_info *h,
         return rc;
 }
 
+static int hpsa_bmic_id_physical_device(struct ctlr_info *h,
+                unsigned char scsi3addr[], u16 bmic_device_index,
+                struct bmic_identify_physical_device *buf, size_t bufsize)
+{
+        int rc = IO_OK;
+        struct CommandList *c;
+        struct ErrorInfo *ei;
+
+        c = cmd_alloc(h);
+        rc = fill_cmd(c, BMIC_IDENTIFY_PHYSICAL_DEVICE, h, buf, bufsize,
+                0, RAID_CTLR_LUNID, TYPE_CMD);
+        if (rc)
+                goto out;
+
+        c->Request.CDB[2] = bmic_device_index & 0xff;
+        c->Request.CDB[9] = (bmic_device_index >> 8) & 0xff;
+
+        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(h, c);
+                rc = -1;
+        }
+out:
+        cmd_free(h, c);
+        return rc;
+}
+
 static int hpsa_vpd_page_supported(struct ctlr_info *h,
         unsigned char scsi3addr[], u8 page)
 {
@@ -2369,7 +2486,7 @@ static int hpsa_get_device_id(struct ctlr_info *h, unsigned char *scsi3addr,
 }
 
 static int hpsa_scsi_do_report_luns(struct ctlr_info *h, int logical,
-                struct ReportLUNdata *buf, int bufsize,
+                void *buf, int bufsize,
                 int extended_response)
 {
         int rc = IO_OK;
@@ -2377,9 +2494,9 @@ static int hpsa_scsi_do_report_luns(struct ctlr_info *h, int logical,
         unsigned char scsi3addr[8];
         struct ErrorInfo *ei;
 
-        c = cmd_special_alloc(h);
+        c = cmd_alloc(h);
         if (c == NULL) {                        /* trouble... */
-                dev_err(&h->pdev->dev, "cmd_special_alloc returned NULL!\n");
+                dev_err(&h->pdev->dev, "cmd_alloc returned NULL!\n");
                 return -1;
         }
         /* address the controller */
@@ -2398,24 +2515,26 @@ static int hpsa_scsi_do_report_luns(struct ctlr_info *h, int logical,
                 hpsa_scsi_interpret_error(h, c);
                 rc = -1;
         } else {
-                if (buf->extended_response_flag != extended_response) {
+                struct ReportLUNdata *rld = buf;
+
+                if (rld->extended_response_flag != extended_response) {
                         dev_err(&h->pdev->dev,
                                 "report luns requested format %u, got %u\n",
                                 extended_response,
-                                buf->extended_response_flag);
+                                rld->extended_response_flag);
                         rc = -1;
                 }
         }
 out:
-        cmd_special_free(h, c);
+        cmd_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)
+                struct ReportExtendedLUNdata *buf, int bufsize)
 {
-        return hpsa_scsi_do_report_luns(h, 0, buf, bufsize, extended_response);
+        return hpsa_scsi_do_report_luns(h, 0, buf, bufsize,
+                                                HPSA_REPORT_PHYS_EXTENDED);
 }
 
 static inline int hpsa_scsi_do_report_log_luns(struct ctlr_info *h,
@@ -2590,6 +2709,7 @@ static int hpsa_update_device_info(struct ctlr_info *h,
                 this_device->offload_config = 0;
                 this_device->offload_enabled = 0;
                 this_device->volume_offline = 0;
+                this_device->queue_depth = h->nr_cmds;
         }
 
         if (is_OBDR_device) {
@@ -2732,7 +2852,6 @@ static int hpsa_get_pdisk_of_ioaccel2(struct ctlr_info *h,
 {
         struct ReportExtendedLUNdata *physicals = NULL;
         int responsesize = 24;  /* size of physical extended response */
-        int extended = 2;       /* flag forces reporting 'other dev info'. */
         int reportsize = sizeof(*physicals) + HPSA_MAX_PHYS_LUN * responsesize;
         u32 nphysicals = 0;     /* number of reported physical devs */
         int found = 0;          /* found match (1) or not (0) */
@@ -2741,8 +2860,8 @@ static int hpsa_get_pdisk_of_ioaccel2(struct ctlr_info *h,
         struct scsi_cmnd *scmd; /* scsi command within request being aborted */
         struct hpsa_scsi_dev_t *d; /* device of request being aborted */
         struct io_accel2_cmd *c2a; /* ioaccel2 command to abort */
-        u32 it_nexus;           /* 4 byte device handle for the ioaccel2 cmd */
-        u32 scsi_nexus;         /* 4 byte device handle for the ioaccel2 cmd */
+        __le32 it_nexus;        /* 4 byte device handle for the ioaccel2 cmd */
+        __le32 scsi_nexus;      /* 4 byte device handle for the ioaccel2 cmd */
 
         if (ioaccel2_cmd_to_abort->cmd_type != CMD_IOACCEL2)
                 return 0; /* no match */
@@ -2761,8 +2880,8 @@ static int hpsa_get_pdisk_of_ioaccel2(struct ctlr_info *h,
                 return 0; /* no match */
 
         it_nexus = cpu_to_le32(d->ioaccel_handle);
-        scsi_nexus = cpu_to_le32(c2a->scsi_nexus);
-        find = c2a->scsi_nexus;
+        scsi_nexus = c2a->scsi_nexus;
+        find = le32_to_cpu(c2a->scsi_nexus);
 
         if (h->raid_offload_debug > 0)
                 dev_info(&h->pdev->dev,
@@ -2779,8 +2898,7 @@ static int hpsa_get_pdisk_of_ioaccel2(struct ctlr_info *h,
         physicals = kzalloc(reportsize, GFP_KERNEL);
         if (physicals == NULL)
                 return 0;
-        if (hpsa_scsi_do_report_phys_luns(h, (struct ReportLUNdata *) physicals,
-                reportsize, extended)) {
+        if (hpsa_scsi_do_report_phys_luns(h, physicals, reportsize)) {
                 dev_err(&h->pdev->dev,
                         "Can't lookup %s device handle: report physical LUNs failed.\n",
                         "HP SSD Smart Path");
@@ -2821,34 +2939,20 @@ static int hpsa_get_pdisk_of_ioaccel2(struct ctlr_info *h,
  * Returns 0 on success, -1 otherwise.
  */
 static int hpsa_gather_lun_info(struct ctlr_info *h,
-        int reportphyslunsize, int reportloglunsize,
-        struct ReportLUNdata *physdev, u32 *nphysicals, int *physical_mode,
+        struct ReportExtendedLUNdata *physdev, u32 *nphysicals,
         struct ReportLUNdata *logdev, u32 *nlogicals)
 {
-        int physical_entry_size = 8;
-
-        *physical_mode = 0;
-
-        /* For I/O accelerator mode we need to read physical device handles */
-        if (h->transMethod & CFGTBL_Trans_io_accel1 ||
-                h->transMethod & CFGTBL_Trans_io_accel2) {
-                *physical_mode = HPSA_REPORT_PHYS_EXTENDED;
-                physical_entry_size = 24;
-        }
-        if (hpsa_scsi_do_report_phys_luns(h, physdev, reportphyslunsize,
-                                                        *physical_mode)) {
+        if (hpsa_scsi_do_report_phys_luns(h, physdev, sizeof(*physdev))) {
                 dev_err(&h->pdev->dev, "report physical LUNs failed.\n");
                 return -1;
         }
-        *nphysicals = be32_to_cpu(*((__be32 *)physdev->LUNListLength)) /
-                                                        physical_entry_size;
+        *nphysicals = be32_to_cpu(*((__be32 *)physdev->LUNListLength)) / 24;
         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);
+                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, reportloglunsize)) {
+        if (hpsa_scsi_do_report_log_luns(h, logdev, sizeof(*logdev))) {
                 dev_err(&h->pdev->dev, "report logical LUNs failed.\n");
                 return -1;
         }
@@ -2921,6 +3025,33 @@ static int hpsa_hba_mode_enabled(struct ctlr_info *h)
         return hba_mode_enabled;
 }
 
+/* get physical drive ioaccel handle and queue depth */
+static void hpsa_get_ioaccel_drive_info(struct ctlr_info *h,
+                struct hpsa_scsi_dev_t *dev,
+                u8 *lunaddrbytes,
+                struct bmic_identify_physical_device *id_phys)
+{
+        int rc;
+        struct ext_report_lun_entry *rle =
+                (struct ext_report_lun_entry *) lunaddrbytes;
+
+        dev->ioaccel_handle = rle->ioaccel_handle;
+        memset(id_phys, 0, sizeof(*id_phys));
+        rc = hpsa_bmic_id_physical_device(h, lunaddrbytes,
+                        GET_BMIC_DRIVE_NUMBER(lunaddrbytes), id_phys,
+                        sizeof(*id_phys));
+        if (!rc)
+                /* Reserve space for FW operations */
+#define DRIVE_CMDS_RESERVED_FOR_FW 2
+#define DRIVE_QUEUE_DEPTH 7
+                dev->queue_depth =
+                        le16_to_cpu(id_phys->current_queue_depth_limit) -
+                                DRIVE_CMDS_RESERVED_FOR_FW;
+        else
+                dev->queue_depth = DRIVE_QUEUE_DEPTH; /* conservative */
+        atomic_set(&dev->ioaccel_cmds_out, 0);
+}
+
 static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
 {
         /* the idea here is we could get notified
@@ -2935,9 +3066,9 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
          */
         struct ReportExtendedLUNdata *physdev_list = NULL;
         struct ReportLUNdata *logdev_list = NULL;
+        struct bmic_identify_physical_device *id_phys = NULL;
         u32 nphysicals = 0;
         u32 nlogicals = 0;
-        int physical_mode = 0;
         u32 ndev_allocated = 0;
         struct hpsa_scsi_dev_t **currentsd, *this_device, *tmpdevice;
         int ncurrent = 0;
@@ -2950,8 +3081,10 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
         physdev_list = kzalloc(sizeof(*physdev_list), GFP_KERNEL);
         logdev_list = kzalloc(sizeof(*logdev_list), GFP_KERNEL);
         tmpdevice = kzalloc(sizeof(*tmpdevice), GFP_KERNEL);
+        id_phys = kzalloc(sizeof(*id_phys), GFP_KERNEL);
 
-        if (!currentsd || !physdev_list || !logdev_list || !tmpdevice) {
+        if (!currentsd || !physdev_list || !logdev_list ||
+                !tmpdevice || !id_phys) {
                 dev_err(&h->pdev->dev, "out of memory\n");
                 goto out;
         }
@@ -2968,10 +3101,8 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
 
         h->hba_mode_enabled = rescan_hba_mode;
 
-        if (hpsa_gather_lun_info(h,
-                        sizeof(*physdev_list), sizeof(*logdev_list),
-                        (struct ReportLUNdata *) physdev_list, &nphysicals,
-                        &physical_mode, logdev_list, &nlogicals))
+        if (hpsa_gather_lun_info(h, physdev_list, &nphysicals,
+                        logdev_list, &nlogicals))
                 goto out;
 
         /* We might see up to the maximum number of logical and physical disks
@@ -3068,10 +3199,11 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
                                 ncurrent++;
                                 break;
                         }
-                        if (physical_mode == HPSA_REPORT_PHYS_EXTENDED) {
-                                memcpy(&this_device->ioaccel_handle,
-                                        &lunaddrbytes[20],
-                                        sizeof(this_device->ioaccel_handle));
+                        if (h->transMethod & CFGTBL_Trans_io_accel1 ||
+                                h->transMethod & CFGTBL_Trans_io_accel2) {
+                                hpsa_get_ioaccel_drive_info(h, this_device,
+                                                        lunaddrbytes, id_phys);
+                                atomic_set(&this_device->ioaccel_cmds_out, 0);
                                 ncurrent++;
                         }
                         break;
@@ -3095,6 +3227,7 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
                 if (ncurrent >= HPSA_MAX_DEVICES)
                         break;
         }
+        hpsa_update_log_drive_phys_drive_ptrs(h, currentsd, ncurrent);
         adjust_hpsa_scsi_table(h, hostno, currentsd, ncurrent);
 out:
         kfree(tmpdevice);
@@ -3103,9 +3236,22 @@ out:
         kfree(currentsd);
         kfree(physdev_list);
         kfree(logdev_list);
+        kfree(id_phys);
 }
 
-/* hpsa_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
+static void hpsa_set_sg_descriptor(struct SGDescriptor *desc,
+                                   struct scatterlist *sg)
+{
+        u64 addr64 = (u64) sg_dma_address(sg);
+        unsigned int len = sg_dma_len(sg);
+
+        desc->Addr = cpu_to_le64(addr64);
+        desc->Len = cpu_to_le32(len);
+        desc->Ext = 0;
+}
+
+/*
+ * 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.
  */
@@ -3113,9 +3259,7 @@ 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;
 
@@ -3138,13 +3282,11 @@ static int hpsa_scatter_gather(struct ctlr_info *h,
                         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 = cpu_to_le64(addr64);
-                curr_sg->Len = cpu_to_le32(len);
-                curr_sg->Ext = cpu_to_le32(0);
+                hpsa_set_sg_descriptor(curr_sg, sg);
                 curr_sg++;
         }
+
+        /* Back the pointer up to the last entry and mark it as "last". */
         (--curr_sg)->Ext = cpu_to_le32(HPSA_SG_LAST);
 
         if (use_sg + chained > h->maxSG)
@@ -3163,7 +3305,7 @@ static int hpsa_scatter_gather(struct ctlr_info *h,
 sglist_finished:
 
         cp->Header.SGList = (u8) use_sg;   /* no. SGs contig in this cmd */
-        cp->Header.SGTotal = cpu_to_le16(use_sg); /* total sgs in this cmd list */
+        cp->Header.SGTotal = cpu_to_le16(use_sg); /* total sgs in cmd list */
         return 0;
 }
 
@@ -3217,7 +3359,7 @@ static int fixup_ioaccel_cdb(u8 *cdb, int *cdb_len)
 
 static int hpsa_scsi_ioaccel1_queue_command(struct ctlr_info *h,
         struct CommandList *c, u32 ioaccel_handle, u8 *cdb, int cdb_len,
-        u8 *scsi3addr)
+        u8 *scsi3addr, struct hpsa_scsi_dev_t *phys_disk)
 {
         struct scsi_cmnd *cmd = c->scsi_cmd;
         struct io_accel1_cmd *cp = &h->ioaccel_cmd_pool[c->cmdindex];
@@ -3230,13 +3372,17 @@ static int hpsa_scsi_ioaccel1_queue_command(struct ctlr_info *h,
         u32 control = IOACCEL1_CONTROL_SIMPLEQUEUE;
 
         /* TODO: implement chaining support */
-        if (scsi_sg_count(cmd) > h->ioaccel_maxsg)
+        if (scsi_sg_count(cmd) > h->ioaccel_maxsg) {
+                atomic_dec(&phys_disk->ioaccel_cmds_out);
                 return IO_ACCEL_INELIGIBLE;
+        }
 
         BUG_ON(cmd->cmd_len > IOACCEL1_IOFLAGS_CDBLEN_MAX);
 
-        if (fixup_ioaccel_cdb(cdb, &cdb_len))
+        if (fixup_ioaccel_cdb(cdb, &cdb_len)) {
+                atomic_dec(&phys_disk->ioaccel_cmds_out);
                 return IO_ACCEL_INELIGIBLE;
+        }
 
         c->cmd_type = CMD_IOACCEL1;
 
@@ -3246,8 +3392,10 @@ static int hpsa_scsi_ioaccel1_queue_command(struct ctlr_info *h,
         BUG_ON(c->busaddr & 0x0000007F);
 
         use_sg = scsi_dma_map(cmd);
-        if (use_sg < 0)
+        if (use_sg < 0) {
+                atomic_dec(&phys_disk->ioaccel_cmds_out);
                 return use_sg;
+        }
 
         if (use_sg) {
                 curr_sg = cp->SG;
@@ -3284,11 +3432,11 @@ static int hpsa_scsi_ioaccel1_queue_command(struct ctlr_info *h,
 
         c->Header.SGList = use_sg;
         /* Fill out the command structure to submit */
-        cp->dev_handle = ioaccel_handle & 0xFFFF;
-        cp->transfer_len = total_len;
-        cp->io_flags = IOACCEL1_IOFLAGS_IO_REQ |
-                        (cdb_len & IOACCEL1_IOFLAGS_CDBLEN_MASK);
-        cp->control = control;
+        cp->dev_handle = cpu_to_le16(ioaccel_handle & 0xFFFF);
+        cp->transfer_len = cpu_to_le32(total_len);
+        cp->io_flags = cpu_to_le16(IOACCEL1_IOFLAGS_IO_REQ |
+                        (cdb_len & IOACCEL1_IOFLAGS_CDBLEN_MASK));
+        cp->control = cpu_to_le32(control);
         memcpy(cp->CDB, cdb, cdb_len);
         memcpy(cp->CISS_LUN, scsi3addr, 8);
         /* Tag was already set at init time. */
@@ -3306,8 +3454,10 @@ static int hpsa_scsi_ioaccel_direct_map(struct ctlr_info *h,
         struct scsi_cmnd *cmd = c->scsi_cmd;
         struct hpsa_scsi_dev_t *dev = cmd->device->hostdata;
 
+        c->phys_disk = dev;
+
         return hpsa_scsi_ioaccel_queue_command(h, c, dev->ioaccel_handle,
-                cmd->cmnd, cmd->cmd_len, dev->scsi3addr);
+                cmd->cmnd, cmd->cmd_len, dev->scsi3addr, dev);
 }
 
 /*
@@ -3321,10 +3471,8 @@ static void set_encrypt_ioaccel2(struct ctlr_info *h,
         struct raid_map_data *map = &dev->raid_map;
         u64 first_block;
 
-        BUG_ON(!(dev->offload_config && dev->offload_enabled));
-
         /* Are we doing encryption on this device */
-        if (!(map->flags & RAID_MAP_FLAG_ENCRYPT_ON))
+        if (!(le16_to_cpu(map->flags) & RAID_MAP_FLAG_ENCRYPT_ON))
                 return;
         /* Set the data encryption key index. */
         cp->dekindex = map->dekindex;
@@ -3340,101 +3488,38 @@ static void set_encrypt_ioaccel2(struct ctlr_info *h,
         /* Required? 6-byte cdbs eliminated by fixup_ioaccel_cdb */
         case WRITE_6:
         case READ_6:
-                if (map->volume_blk_size == 512) {
-                        cp->tweak_lower =
-                                (((u32) cmd->cmnd[2]) << 8) |
-                                        cmd->cmnd[3];
-                        cp->tweak_upper = 0;
-                } else {
-                        first_block =
-                                (((u64) cmd->cmnd[2]) << 8) |
-                                        cmd->cmnd[3];
-                        first_block = (first_block * map->volume_blk_size)/512;
-                        cp->tweak_lower = (u32)first_block;
-                        cp->tweak_upper = (u32)(first_block >> 32);
-                }
+                first_block = get_unaligned_be16(&cmd->cmnd[2]);
                 break;
         case WRITE_10:
         case READ_10:
-                if (map->volume_blk_size == 512) {
-                        cp->tweak_lower =
-                                (((u32) cmd->cmnd[2]) << 24) |
-                                (((u32) cmd->cmnd[3]) << 16) |
-                                (((u32) cmd->cmnd[4]) << 8) |
-                                        cmd->cmnd[5];
-                        cp->tweak_upper = 0;
-                } else {
-                        first_block =
-                                (((u64) cmd->cmnd[2]) << 24) |
-                                (((u64) cmd->cmnd[3]) << 16) |
-                                (((u64) cmd->cmnd[4]) << 8) |
-                                        cmd->cmnd[5];
-                        first_block = (first_block * map->volume_blk_size)/512;
-                        cp->tweak_lower = (u32)first_block;
-                        cp->tweak_upper = (u32)(first_block >> 32);
-                }
-                break;
         /* Required? 12-byte cdbs eliminated by fixup_ioaccel_cdb */
         case WRITE_12:
         case READ_12:
-                if (map->volume_blk_size == 512) {
-                        cp->tweak_lower =
-                                (((u32) cmd->cmnd[2]) << 24) |
-                                (((u32) cmd->cmnd[3]) << 16) |
-                                (((u32) cmd->cmnd[4]) << 8) |
-                                        cmd->cmnd[5];
-                        cp->tweak_upper = 0;
-                } else {
-                        first_block =
-                                (((u64) cmd->cmnd[2]) << 24) |
-                                (((u64) cmd->cmnd[3]) << 16) |
-                                (((u64) cmd->cmnd[4]) << 8) |
-                                        cmd->cmnd[5];
-                        first_block = (first_block * map->volume_blk_size)/512;
-                        cp->tweak_lower = (u32)first_block;
-                        cp->tweak_upper = (u32)(first_block >> 32);
-                }
+                first_block = get_unaligned_be32(&cmd->cmnd[2]);
                 break;
         case WRITE_16:
         case READ_16:
-                if (map->volume_blk_size == 512) {
-                        cp->tweak_lower =
-                                (((u32) cmd->cmnd[6]) << 24) |
-                                (((u32) cmd->cmnd[7]) << 16) |
-                                (((u32) cmd->cmnd[8]) << 8) |
-                                        cmd->cmnd[9];
-                        cp->tweak_upper =
-                                (((u32) cmd->cmnd[2]) << 24) |
-                                (((u32) cmd->cmnd[3]) << 16) |
-                                (((u32) cmd->cmnd[4]) << 8) |
-                                        cmd->cmnd[5];
-                } else {
-                        first_block =
-                                (((u64) cmd->cmnd[2]) << 56) |
-                                (((u64) cmd->cmnd[3]) << 48) |
-                                (((u64) cmd->cmnd[4]) << 40) |
-                                (((u64) cmd->cmnd[5]) << 32) |
-                                (((u64) cmd->cmnd[6]) << 24) |
-                                (((u64) cmd->cmnd[7]) << 16) |
-                                (((u64) cmd->cmnd[8]) << 8) |
-                                        cmd->cmnd[9];
-                        first_block = (first_block * map->volume_blk_size)/512;
-                        cp->tweak_lower = (u32)first_block;
-                        cp->tweak_upper = (u32)(first_block >> 32);
-                }
+                first_block = get_unaligned_be64(&cmd->cmnd[2]);
                 break;
         default:
                 dev_err(&h->pdev->dev,
-                        "ERROR: %s: IOACCEL request CDB size not supported for encryption\n",
-                        __func__);
+                        "ERROR: %s: size (0x%x) not supported for encryption\n",
+                        __func__, cmd->cmnd[0]);
                 BUG();
                 break;
         }
+
+        if (le32_to_cpu(map->volume_blk_size) != 512)
+                first_block = first_block *
+                                le32_to_cpu(map->volume_blk_size)/512;
+
+        cp->tweak_lower = cpu_to_le32(first_block);
+        cp->tweak_upper = cpu_to_le32(first_block >> 32);
 }
 
 static int hpsa_scsi_ioaccel2_queue_command(struct ctlr_info *h,
         struct CommandList *c, u32 ioaccel_handle, u8 *cdb, int cdb_len,
-        u8 *scsi3addr)
+        u8 *scsi3addr, struct hpsa_scsi_dev_t *phys_disk)
 {
         struct scsi_cmnd *cmd = c->scsi_cmd;
         struct io_accel2_cmd *cp = &h->ioaccel2_cmd_pool[c->cmdindex];
@@ -3445,11 +3530,16 @@ static int hpsa_scsi_ioaccel2_queue_command(struct ctlr_info *h,
         u32 len;
         u32 total_len = 0;
 
-        if (scsi_sg_count(cmd) > h->ioaccel_maxsg)
+        if (scsi_sg_count(cmd) > h->ioaccel_maxsg) {
+                atomic_dec(&phys_disk->ioaccel_cmds_out);
                 return IO_ACCEL_INELIGIBLE;
+        }
 
-        if (fixup_ioaccel_cdb(cdb, &cdb_len))
+        if (fixup_ioaccel_cdb(cdb, &cdb_len)) {
+                atomic_dec(&phys_disk->ioaccel_cmds_out);
                 return IO_ACCEL_INELIGIBLE;
+        }
+
         c->cmd_type = CMD_IOACCEL2;
         /* Adjust the DMA address to point to the accelerated command buffer */
         c->busaddr = (u32) h->ioaccel2_cmd_pool_dhandle +
@@ -3460,8 +3550,10 @@ static int hpsa_scsi_ioaccel2_queue_command(struct ctlr_info *h,
         cp->IU_type = IOACCEL2_IU_TYPE;
 
         use_sg = scsi_dma_map(cmd);
-        if (use_sg < 0)
+        if (use_sg < 0) {
+                atomic_dec(&phys_disk->ioaccel_cmds_out);
                 return use_sg;
+        }
 
         if (use_sg) {
                 BUG_ON(use_sg > IOACCEL2_MAXSGENTRIES);
@@ -3506,9 +3598,8 @@ static int hpsa_scsi_ioaccel2_queue_command(struct ctlr_info *h,
         /* Set encryption parameters, if necessary */
         set_encrypt_ioaccel2(h, c, cp);
 
-        cp->scsi_nexus = ioaccel_handle;
-        cp->Tag = (c->cmdindex << DIRECT_LOOKUP_SHIFT) |
-                                DIRECT_LOOKUP_BIT;
+        cp->scsi_nexus = cpu_to_le32(ioaccel_handle);
+        cp->Tag = cpu_to_le32(c->cmdindex << DIRECT_LOOKUP_SHIFT);
         memcpy(cp->cdb, cdb, sizeof(cp->cdb));
 
         /* fill in sg elements */
@@ -3528,14 +3619,22 @@ static int hpsa_scsi_ioaccel2_queue_command(struct ctlr_info *h,
  */
 static int hpsa_scsi_ioaccel_queue_command(struct ctlr_info *h,
         struct CommandList *c, u32 ioaccel_handle, u8 *cdb, int cdb_len,
-        u8 *scsi3addr)
+        u8 *scsi3addr, struct hpsa_scsi_dev_t *phys_disk)
 {
+        /* Try to honor the device's queue depth */
+        if (atomic_inc_return(&phys_disk->ioaccel_cmds_out) >
+                                        phys_disk->queue_depth) {
+                atomic_dec(&phys_disk->ioaccel_cmds_out);
+                return IO_ACCEL_INELIGIBLE;
+        }
         if (h->transMethod & CFGTBL_Trans_io_accel1)
                 return hpsa_scsi_ioaccel1_queue_command(h, c, ioaccel_handle,
-                                                cdb, cdb_len, scsi3addr);
+                                                cdb, cdb_len, scsi3addr,
+                                                phys_disk);
         else
                 return hpsa_scsi_ioaccel2_queue_command(h, c, ioaccel_handle,
-                                                cdb, cdb_len, scsi3addr);
+                                                cdb, cdb_len, scsi3addr,
+                                                phys_disk);
 }
 
 static void raid_map_helper(struct raid_map_data *map,
@@ -3543,21 +3642,22 @@ static void raid_map_helper(struct raid_map_data *map,
 {
         if (offload_to_mirror == 0)  {
                 /* use physical disk in the first mirrored group. */
-                *map_index %= map->data_disks_per_row;
+                *map_index %= le16_to_cpu(map->data_disks_per_row);
                 return;
         }
         do {
                 /* determine mirror group that *map_index indicates */
-                *current_group = *map_index / map->data_disks_per_row;
+                *current_group = *map_index /
+                        le16_to_cpu(map->data_disks_per_row);
                 if (offload_to_mirror == *current_group)
                         continue;
-                if (*current_group < (map->layout_map_count - 1)) {
+                if (*current_group < le16_to_cpu(map->layout_map_count) - 1) {
                         /* select map index from next group */
-                        *map_index += map->data_disks_per_row;
+                        *map_index += le16_to_cpu(map->data_disks_per_row);
                         (*current_group)++;
                 } else {
                         /* select map index from first group */
-                        *map_index %= map->data_disks_per_row;
+                        *map_index %= le16_to_cpu(map->data_disks_per_row);
                         *current_group = 0;
                 }
         } while (offload_to_mirror != *current_group);
@@ -3595,13 +3695,12 @@ static int hpsa_scsi_ioaccel_raid_map(struct ctlr_info *h,
         u32 disk_block_cnt;
         u8 cdb[16];
         u8 cdb_len;
+        u16 strip_size;
 #if BITS_PER_LONG == 32
         u64 tmpdiv;
 #endif
         int offload_to_mirror;
 
-        BUG_ON(!(dev->offload_config && dev->offload_enabled));
-
         /* check for valid opcode, get LBA and block count */
         switch (cmd->cmnd[0]) {
         case WRITE_6:
@@ -3668,11 +3767,14 @@ static int hpsa_scsi_ioaccel_raid_map(struct ctlr_info *h,
                 return IO_ACCEL_INELIGIBLE;
 
         /* check for invalid block or wraparound */
-        if (last_block >= map->volume_blk_cnt || last_block < first_block)
+        if (last_block >= le64_to_cpu(map->volume_blk_cnt) ||
+                last_block < first_block)
                 return IO_ACCEL_INELIGIBLE;
 
         /* calculate stripe information for the request */
-        blocks_per_row = map->data_disks_per_row * map->strip_size;
+        blocks_per_row = le16_to_cpu(map->data_disks_per_row) *
+                                le16_to_cpu(map->strip_size);
+        strip_size = le16_to_cpu(map->strip_size);
 #if BITS_PER_LONG == 32
         tmpdiv = first_block;
         (void) do_div(tmpdiv, blocks_per_row);
@@ -3683,18 +3785,18 @@ static int hpsa_scsi_ioaccel_raid_map(struct ctlr_info *h,
         first_row_offset = (u32) (first_block - (first_row * blocks_per_row));
         last_row_offset = (u32) (last_block - (last_row * blocks_per_row));
         tmpdiv = first_row_offset;
-        (void) do_div(tmpdiv,  map->strip_size);
+        (void) do_div(tmpdiv, strip_size);
         first_column = tmpdiv;
         tmpdiv = last_row_offset;
-        (void) do_div(tmpdiv, map->strip_size);
+        (void) do_div(tmpdiv, strip_size);
         last_column = tmpdiv;
 #else
         first_row = first_block / blocks_per_row;
         last_row = last_block / blocks_per_row;
         first_row_offset = (u32) (first_block - (first_row * blocks_per_row));
         last_row_offset = (u32) (last_block - (last_row * blocks_per_row));
-        first_column = first_row_offset / map->strip_size;
-        last_column = last_row_offset / map->strip_size;
+        first_column = first_row_offset / strip_size;
+        last_column = last_row_offset / strip_size;
 #endif
 
         /* if this isn't a single row/column then give to the controller */
@@ -3702,10 +3804,10 @@ static int hpsa_scsi_ioaccel_raid_map(struct ctlr_info *h,
                 return IO_ACCEL_INELIGIBLE;
 
         /* proceeding with driver mapping */
-        total_disks_per_row = map->data_disks_per_row +
-                                map->metadata_disks_per_row;
+        total_disks_per_row = le16_to_cpu(map->data_disks_per_row) +
+                                le16_to_cpu(map->metadata_disks_per_row);
         map_row = ((u32)(first_row >> map->parity_rotation_shift)) %
-                                map->row_cnt;
+                                le16_to_cpu(map->row_cnt);
         map_index = (map_row * total_disks_per_row) + first_column;
 
         switch (dev->raid_level) {
@@ -3716,23 +3818,24 @@ static int hpsa_scsi_ioaccel_raid_map(struct ctlr_info *h,
                  * (2-drive R1 and R10 with even # of drives.)
                  * Appropriate for SSDs, not optimal for HDDs
                  */
-                BUG_ON(map->layout_map_count != 2);
+                BUG_ON(le16_to_cpu(map->layout_map_count) != 2);
                 if (dev->offload_to_mirror)
-                        map_index += map->data_disks_per_row;
+                        map_index += le16_to_cpu(map->data_disks_per_row);
                 dev->offload_to_mirror = !dev->offload_to_mirror;
                 break;
         case HPSA_RAID_ADM:
                 /* Handles N-way mirrors  (R1-ADM)
                  * and R10 with # of drives divisible by 3.)
                  */
-                BUG_ON(map->layout_map_count != 3);
+                BUG_ON(le16_to_cpu(map->layout_map_count) != 3);
 
                 offload_to_mirror = dev->offload_to_mirror;
                 raid_map_helper(map, offload_to_mirror,
                                 &map_index, &current_group);
                 /* set mirror group to use next time */
                 offload_to_mirror =
-                        (offload_to_mirror >= map->layout_map_count - 1)
+                        (offload_to_mirror >=
+                        le16_to_cpu(map->layout_map_count) - 1)
                         ? 0 : offload_to_mirror + 1;
                 dev->offload_to_mirror = offload_to_mirror;
                 /* Avoid direct use of dev->offload_to_mirror within this
@@ -3742,14 +3845,16 @@ static int hpsa_scsi_ioaccel_raid_map(struct ctlr_info *h,
                 break;
         case HPSA_RAID_5:
         case HPSA_RAID_6:
-                if (map->layout_map_count <= 1)
+                if (le16_to_cpu(map->layout_map_count) <= 1)
                         break;
 
                 /* Verify first and last block are in same RAID group */
                 r5or6_blocks_per_row =
-                        map->strip_size * map->data_disks_per_row;
+                        le16_to_cpu(map->strip_size) *
+                        le16_to_cpu(map->data_disks_per_row);
                 BUG_ON(r5or6_blocks_per_row == 0);
-                stripesize = r5or6_blocks_per_row * map->layout_map_count;
+                stripesize = r5or6_blocks_per_row *
+                        le16_to_cpu(map->layout_map_count);
 #if BITS_PER_LONG == 32
                 tmpdiv = first_block;
                 first_group = do_div(tmpdiv, stripesize);
@@ -3812,28 +3917,35 @@ static int hpsa_scsi_ioaccel_raid_map(struct ctlr_info *h,
                                                 r5or6_blocks_per_row);
 
                 first_column = r5or6_first_column =
-                        r5or6_first_row_offset / map->strip_size;
+                        r5or6_first_row_offset / le16_to_cpu(map->strip_size);
                 r5or6_last_column =
-                        r5or6_last_row_offset / map->strip_size;
+                        r5or6_last_row_offset / le16_to_cpu(map->strip_size);
 #endif
                 if (r5or6_first_column != r5or6_last_column)
                         return IO_ACCEL_INELIGIBLE;
 
                 /* Request is eligible */
                 map_row = ((u32)(first_row >> map->parity_rotation_shift)) %
-                        map->row_cnt;
+                        le16_to_cpu(map->row_cnt);
 
                 map_index = (first_group *
-                        (map->row_cnt * total_disks_per_row)) +
+                        (le16_to_cpu(map->row_cnt) * total_disks_per_row)) +
                         (map_row * total_disks_per_row) + first_column;
                 break;
         default:
                 return IO_ACCEL_INELIGIBLE;
         }
 
+        if (unlikely(map_index >= RAID_MAP_MAX_ENTRIES))
+                return IO_ACCEL_INELIGIBLE;
+
+        c->phys_disk = dev->phys_disk[map_index];
+
         disk_handle = dd[map_index].ioaccel_handle;
-        disk_block = map->disk_starting_blk + (first_row * map->strip_size) +
-                        (first_row_offset - (first_column * map->strip_size));
+        disk_block = le64_to_cpu(map->disk_starting_blk) +
+                        first_row * le16_to_cpu(map->strip_size) +
+                        (first_row_offset - first_column *
+                        le16_to_cpu(map->strip_size));
         disk_block_cnt = block_cnt;
 
         /* handle differing logical/physical block sizes */
@@ -3876,78 +3988,21 @@ static int hpsa_scsi_ioaccel_raid_map(struct ctlr_info *h,
                 cdb_len = 10;
         }
         return hpsa_scsi_ioaccel_queue_command(h, c, disk_handle, cdb, cdb_len,
-                                                dev->scsi3addr);
+                                                dev->scsi3addr,
+                                                dev->phys_disk[map_index]);
 }
 
-/*
- * Running in struct Scsi_Host->host_lock less mode using LLD internal
- * struct ctlr_info *h->lock w/ spin_lock_irqsave() protection.
- */
-static int hpsa_scsi_queue_command(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
+/* Submit commands down the "normal" RAID stack path */
+static int hpsa_ciss_submit(struct ctlr_info *h,
+        struct CommandList *c, struct scsi_cmnd *cmd,
+        unsigned char scsi3addr[])
 {
-        struct ctlr_info *h;
-        struct hpsa_scsi_dev_t *dev;
-        unsigned char scsi3addr[8];
-        struct CommandList *c;
-        int rc = 0;
-
-        /* 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;
-                cmd->scsi_done(cmd);
-                return 0;
-        }
-        memcpy(scsi3addr, dev->scsi3addr, sizeof(scsi3addr));
-
-        if (unlikely(lockup_detected(h))) {
-                cmd->result = DID_ERROR << 16;
-                cmd->scsi_done(cmd);
-                return 0;
-        }
-        c = cmd_alloc(h);
-        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 */
-        /* save c in case we have to abort it  */
         cmd->host_scribble = (unsigned char *) c;
-
         c->cmd_type = CMD_SCSI;
         c->scsi_cmd = cmd;
-
-        /* Call alternate submit routine for I/O accelerated commands.
-         * Retries always go down the normal I/O path.
-         */
-        if (likely(cmd->retries == 0 &&
-                cmd->request->cmd_type == REQ_TYPE_FS &&
-                h->acciopath_status)) {
-                if (dev->offload_enabled) {
-                        rc = hpsa_scsi_ioaccel_raid_map(h, c);
-                        if (rc == 0)
-                                return 0; /* Sent on ioaccel path */
-                        if (rc < 0) {   /* scsi_dma_map failed. */
-                                cmd_free(h, c);
-                                return SCSI_MLQUEUE_HOST_BUSY;
-                        }
-                } else if (dev->ioaccel_handle) {
-                        rc = hpsa_scsi_ioaccel_direct_map(h, c);
-                        if (rc == 0)
-                                return 0; /* Sent on direct map path */
-                        if (rc < 0) {   /* scsi_dma_map failed. */
-                                cmd_free(h, c);
-                                return SCSI_MLQUEUE_HOST_BUSY;
-                        }
-                }
-        }
-
         c->Header.ReplyQueue = 0;  /* unused in simple mode */
         memcpy(&c->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
-        c->Header.tag = cpu_to_le64((c->cmdindex << DIRECT_LOOKUP_SHIFT) |
-                                        DIRECT_LOOKUP_BIT);
+        c->Header.tag = cpu_to_le64((c->cmdindex << DIRECT_LOOKUP_SHIFT));
 
         /* Fill in the request block... */
 
@@ -4003,25 +4058,108 @@ static int hpsa_scsi_queue_command(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
         return 0;
 }
 
-static int do_not_scan_if_controller_locked_up(struct ctlr_info *h)
+static void hpsa_command_resubmit_worker(struct work_struct *work)
 {
-        unsigned long flags;
+        struct scsi_cmnd *cmd;
+        struct hpsa_scsi_dev_t *dev;
+        struct CommandList *c =
+                        container_of(work, struct CommandList, work);
+
+        cmd = c->scsi_cmd;
+        dev = cmd->device->hostdata;
+        if (!dev) {
+                cmd->result = DID_NO_CONNECT << 16;
+                cmd->scsi_done(cmd);
+                return;
+        }
+        if (hpsa_ciss_submit(c->h, c, cmd, dev->scsi3addr)) {
+                /*
+                 * If we get here, it means dma mapping failed. Try
+                 * again via scsi mid layer, which will then get
+                 * SCSI_MLQUEUE_HOST_BUSY.
+                 */
+                cmd->result = DID_IMM_RETRY << 16;
+                cmd->scsi_done(cmd);
+        }
+}
+
+/* Running in struct Scsi_Host->host_lock less mode */
+static int hpsa_scsi_queue_command(struct Scsi_Host *sh, struct scsi_cmnd *cmd)
+{
+        struct ctlr_info *h;
+        struct hpsa_scsi_dev_t *dev;
+        unsigned char scsi3addr[8];
+        struct CommandList *c;
+        int rc = 0;
+
+        /* 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;
+                cmd->scsi_done(cmd);
+                return 0;
+        }
+        memcpy(scsi3addr, dev->scsi3addr, sizeof(scsi3addr));
+
+        if (unlikely(lockup_detected(h))) {
+                cmd->result = DID_ERROR << 16;
+                cmd->scsi_done(cmd);
+                return 0;
+        }
+        c = cmd_alloc(h);
+        if (c == NULL) {                        /* trouble... */
+                dev_err(&h->pdev->dev, "cmd_alloc returned NULL!\n");
+                return SCSI_MLQUEUE_HOST_BUSY;
+        }
+        if (unlikely(lockup_detected(h))) {
+                cmd->result = DID_ERROR << 16;
+                cmd_free(h, c);
+                cmd->scsi_done(cmd);
+                return 0;
+        }
 
         /*
-         * Don't let rescans be initiated on a controller known
-         * to be locked up.  If the controller locks up *during*
-         * a rescan, that thread is probably hosed, but at least
-         * we can prevent new rescan threads from piling up on a
-         * locked up controller.
+         * Call alternate submit routine for I/O accelerated commands.
+         * Retries always go down the normal I/O path.
          */
-        if (unlikely(lockup_detected(h))) {
-                spin_lock_irqsave(&h->scan_lock, flags);
-                h->scan_finished = 1;
-                wake_up_all(&h->scan_wait_queue);
-                spin_unlock_irqrestore(&h->scan_lock, flags);
-                return 1;
+        if (likely(cmd->retries == 0 &&
+                cmd->request->cmd_type == REQ_TYPE_FS &&
+                h->acciopath_status)) {
+
+                cmd->host_scribble = (unsigned char *) c;
+                c->cmd_type = CMD_SCSI;
+                c->scsi_cmd = cmd;
+
+                if (dev->offload_enabled) {
+                        rc = hpsa_scsi_ioaccel_raid_map(h, c);
+                        if (rc == 0)
+                                return 0; /* Sent on ioaccel path */
+                        if (rc < 0) {   /* scsi_dma_map failed. */
+                                cmd_free(h, c);
+                                return SCSI_MLQUEUE_HOST_BUSY;
+                        }
+                } else if (dev->ioaccel_handle) {
+                        rc = hpsa_scsi_ioaccel_direct_map(h, c);
+                        if (rc == 0)
+                                return 0; /* Sent on direct map path */
+                        if (rc < 0) {   /* scsi_dma_map failed. */
+                                cmd_free(h, c);
+                                return SCSI_MLQUEUE_HOST_BUSY;
+                        }
+                }
         }
-        return 0;
+        return hpsa_ciss_submit(h, c, cmd, scsi3addr);
+}
+
+static void hpsa_scan_complete(struct ctlr_info *h)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&h->scan_lock, flags);
+        h->scan_finished = 1;
+        wake_up_all(&h->scan_wait_queue);
+        spin_unlock_irqrestore(&h->scan_lock, flags);
 }
 
 static void hpsa_scan_start(struct Scsi_Host *sh)
@@ -4029,8 +4167,14 @@ static void hpsa_scan_start(struct Scsi_Host *sh)
         struct ctlr_info *h = shost_to_hba(sh);
         unsigned long flags;
 
-        if (do_not_scan_if_controller_locked_up(h))
-                return;
+        /*
+         * Don't let rescans be initiated on a controller known to be locked
+         * up.  If the controller locks up *during* a rescan, that thread is
+         * probably hosed, but at least we can prevent new rescan threads from
+         * piling up on a locked up controller.
+         */
+        if (unlikely(lockup_detected(h)))
+                return hpsa_scan_complete(h);
 
         /* wait until any scan already in progress is finished. */
         while (1) {
@@ -4048,15 +4192,27 @@ static void hpsa_scan_start(struct Scsi_Host *sh)
         h->scan_finished = 0; /* mark scan as in progress */
         spin_unlock_irqrestore(&h->scan_lock, flags);
 
-        if (do_not_scan_if_controller_locked_up(h))
-                return;
+        if (unlikely(lockup_detected(h)))
+                return hpsa_scan_complete(h);
 
         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);
+        hpsa_scan_complete(h);
+}
+
+static int hpsa_change_queue_depth(struct scsi_device *sdev, int qdepth)
+{
+        struct hpsa_scsi_dev_t *logical_drive = sdev->hostdata;
+
+        if (!logical_drive)
+                return -ENODEV;
+
+        if (qdepth < 1)
+                qdepth = 1;
+        else if (qdepth > logical_drive->queue_depth)
+                qdepth = logical_drive->queue_depth;
+
+        return scsi_change_queue_depth(sdev, qdepth);
 }
 
 static int hpsa_scan_finished(struct Scsi_Host *sh,
@@ -4096,11 +4252,11 @@ static int hpsa_register_scsi(struct ctlr_info *h)
         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;
-        if (h->hba_mode_enabled)
-                sh->cmd_per_lun = 7;
-        else
-                sh->cmd_per_lun = h->nr_cmds;
+        sh->can_queue = h->nr_cmds -
+                        HPSA_CMDS_RESERVED_FOR_ABORTS -
+                        HPSA_CMDS_RESERVED_FOR_DRIVER -
+                        HPSA_MAX_CONCURRENT_PASSTHRUS;
+        sh->cmd_per_lun = sh->can_queue;
         sh->sg_tablesize = h->maxsgentries;
         h->scsi_host = sh;
         sh->hostdata[0] = (unsigned long) h;
@@ -4131,7 +4287,7 @@ static int wait_for_device_to_become_ready(struct ctlr_info *h,
         int waittime = 1; /* seconds */
         struct CommandList *c;
 
-        c = cmd_special_alloc(h);
+        c = cmd_alloc(h);
         if (!c) {
                 dev_warn(&h->pdev->dev, "out of memory in "
                         "wait_for_device_to_become_ready.\n");
@@ -4177,7 +4333,7 @@ static int wait_for_device_to_become_ready(struct ctlr_info *h,
         else
                 dev_warn(&h->pdev->dev, "device is ready.\n");
 
-        cmd_special_free(h, c);
+        cmd_free(h, c);
         return rc;
 }
 
@@ -4194,6 +4350,10 @@ static int hpsa_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
         h = sdev_to_hba(scsicmd->device);
         if (h == NULL) /* paranoia */
                 return FAILED;
+
+        if (lockup_detected(h))
+                return FAILED;
+
         dev = scsicmd->device->hostdata;
         if (!dev) {
                 dev_err(&h->pdev->dev, "hpsa_eh_device_reset_handler: "
@@ -4227,13 +4387,15 @@ static void swizzle_abort_tag(u8 *tag)
 }
 
 static void hpsa_get_tag(struct ctlr_info *h,
-        struct CommandList *c, u32 *taglower, u32 *tagupper)
+        struct CommandList *c, __le32 *taglower, __le32 *tagupper)
 {
+        u64 tag;
         if (c->cmd_type == CMD_IOACCEL1) {
                 struct io_accel1_cmd *cm1 = (struct io_accel1_cmd *)
                         &h->ioaccel_cmd_pool[c->cmdindex];
-                *tagupper = (u32) (cm1->tag >> 32);
-                *taglower = (u32) (cm1->tag & 0x0ffffffffULL);
+                tag = le64_to_cpu(cm1->tag);
+                *tagupper = cpu_to_le32(tag >> 32);
+                *taglower = cpu_to_le32(tag);
                 return;
         }
         if (c->cmd_type == CMD_IOACCEL2) {
@@ -4244,8 +4406,9 @@ static void hpsa_get_tag(struct ctlr_info *h,
                 *taglower = cm2->Tag;
                 return;
         }
-        *tagupper = (u32) (c->Header.tag >> 32);
-        *taglower = (u32) (c->Header.tag & 0x0ffffffffULL);
+        tag = le64_to_cpu(c->Header.tag);
+        *tagupper = cpu_to_le32(tag >> 32);
+        *taglower = cpu_to_le32(tag);
 }
 
 static int hpsa_send_abort(struct ctlr_info *h, unsigned char *scsi3addr,
@@ -4254,11 +4417,11 @@ static int hpsa_send_abort(struct ctlr_info *h, unsigned char *scsi3addr,
         int rc = IO_OK;
         struct CommandList *c;
         struct ErrorInfo *ei;
-        u32 tagupper, taglower;
+        __le32 tagupper, taglower;
 
-        c = cmd_special_alloc(h);
+        c = cmd_alloc(h);
         if (c == NULL) {        /* trouble... */
-                dev_warn(&h->pdev->dev, "cmd_special_alloc returned NULL!\n");
+                dev_warn(&h->pdev->dev, "cmd_alloc returned NULL!\n");
                 return -ENOMEM;
         }
 
@@ -4287,62 +4450,12 @@ static int hpsa_send_abort(struct ctlr_info *h, unsigned char *scsi3addr,
                 rc = -1;
                 break;
         }
-        cmd_special_free(h, c);
+        cmd_free(h, c);
         dev_dbg(&h->pdev->dev, "%s: Tag:0x%08x:%08x: Finished.\n",
                 __func__, tagupper, taglower);
         return rc;
 }
 
-/*
- * hpsa_find_cmd_in_queue
- *
- * Used to determine whether a command (find) is still present
- * in queue_head.   Optionally excludes the last element of queue_head.
- *
- * This is used to avoid unnecessary aborts.  Commands in h->reqQ have
- * not yet been submitted, and so can be aborted by the driver without
- * sending an abort to the hardware.
- *
- * Returns pointer to command if found in queue, NULL otherwise.
- */
-static struct CommandList *hpsa_find_cmd_in_queue(struct ctlr_info *h,
-                        struct scsi_cmnd *find, struct list_head *queue_head)
-{
-        unsigned long flags;
-        struct CommandList *c = NULL;   /* ptr into cmpQ */
-
-        if (!find)
-                return NULL;
-        spin_lock_irqsave(&h->lock, flags);
-        list_for_each_entry(c, queue_head, list) {
-                if (c->scsi_cmd == NULL) /* e.g.: passthru ioctl */
-                        continue;
-                if (c->scsi_cmd == find) {
-                        spin_unlock_irqrestore(&h->lock, flags);
-                        return c;
-                }
-        }
-        spin_unlock_irqrestore(&h->lock, flags);
-        return NULL;
-}
-
-static struct CommandList *hpsa_find_cmd_in_queue_by_tag(struct ctlr_info *h,
-                                        u8 *tag, struct list_head *queue_head)
-{
-        unsigned long flags;
-        struct CommandList *c;
-
-        spin_lock_irqsave(&h->lock, flags);
-        list_for_each_entry(c, queue_head, list) {
-                if (memcmp(&c->Header.tag, tag, 8) != 0)
-                        continue;
-                spin_unlock_irqrestore(&h->lock, flags);
-                return c;
-        }
-        spin_unlock_irqrestore(&h->lock, flags);
-        return NULL;
-}
-
 /* ioaccel2 path firmware cannot handle abort task requests.
  * Change abort requests to physical target reset, and send to the
  * address of the physical disk used for the ioaccel 2 command.
@@ -4360,7 +4473,7 @@ static int hpsa_send_reset_as_abort_ioaccel2(struct ctlr_info *h,
         unsigned char *psa = &phys_scsi3addr[0];
 
         /* Get a pointer to the hpsa logical device. */
-        scmd = (struct scsi_cmnd *) abort->scsi_cmd;
+        scmd = abort->scsi_cmd;
         dev = (struct hpsa_scsi_dev_t *)(scmd->device->hostdata);
         if (dev == NULL) {
                 dev_warn(&h->pdev->dev,
@@ -4429,10 +4542,6 @@ static int hpsa_send_reset_as_abort_ioaccel2(struct ctlr_info *h,
 static int hpsa_send_abort_both_ways(struct ctlr_info *h,
         unsigned char *scsi3addr, struct CommandList *abort)
 {
-        u8 swizzled_tag[8];
-        struct CommandList *c;
-        int rc = 0, rc2 = 0;
-
         /* ioccelerator mode 2 commands should be aborted via the
          * accelerated path, since RAID path is unaware of these commands,
          * but underlying firmware can't handle abort TMF.
@@ -4441,27 +4550,8 @@ static int hpsa_send_abort_both_ways(struct ctlr_info *h,
         if (abort->cmd_type == CMD_IOACCEL2)
                 return hpsa_send_reset_as_abort_ioaccel2(h, scsi3addr, abort);
 
-        /* we do not expect to find the swizzled tag in our queue, but
-         * check anyway just to be sure the assumptions which make this
-         * the case haven't become wrong.
-         */
-        memcpy(swizzled_tag, &abort->Request.CDB[4], 8);
-        swizzle_abort_tag(swizzled_tag);
-        c = hpsa_find_cmd_in_queue_by_tag(h, swizzled_tag, &h->cmpQ);
-        if (c != NULL) {
-                dev_warn(&h->pdev->dev, "Unexpectedly found byte-swapped tag in completion queue.\n");
-                return hpsa_send_abort(h, scsi3addr, abort, 0);
-        }
-        rc = hpsa_send_abort(h, scsi3addr, abort, 0);
-
-        /* if the command is still in our queue, we can't conclude that it was
-         * aborted (it might have just completed normally) but in any case
-         * we don't need to try to abort it another way.
-         */
-        c = hpsa_find_cmd_in_queue(h, abort->scsi_cmd, &h->cmpQ);
-        if (c)
-                rc2 = hpsa_send_abort(h, scsi3addr, abort, 1);
-        return rc && rc2;
+        return hpsa_send_abort(h, scsi3addr, abort, 0) &&
+                        hpsa_send_abort(h, scsi3addr, abort, 1);
 }
 
 /* Send an abort for the specified command.
@@ -4475,11 +4565,11 @@ static int hpsa_eh_abort_handler(struct scsi_cmnd *sc)
         struct ctlr_info *h;
         struct hpsa_scsi_dev_t *dev;
         struct CommandList *abort; /* pointer to command to be aborted */
-        struct CommandList *found;
         struct scsi_cmnd *as;   /* ptr to scsi cmd inside aborted command. */
         char msg[256];          /* For debug messaging. */
         int ml = 0;
-        u32 tagupper, taglower;
+        __le32 tagupper, taglower;
+        int refcount;
 
         /* Find the controller of the command to be aborted */
         h = sdev_to_hba(sc->device);
@@ -4487,6 +4577,9 @@ static int hpsa_eh_abort_handler(struct scsi_cmnd *sc)
                         "ABORT REQUEST FAILED, Controller lookup failed.\n"))
                 return FAILED;
 
+        if (lockup_detected(h))
+                return FAILED;
+
         /* Check that controller supports some kind of task abort */
         if (!(HPSATMF_PHYS_TASK_ABORT & h->TMFSupportFlags) &&
                 !(HPSATMF_LOG_TASK_ABORT & h->TMFSupportFlags))
@@ -4508,41 +4601,23 @@ static int hpsa_eh_abort_handler(struct scsi_cmnd *sc)
         /* Get SCSI command to be aborted */
         abort = (struct CommandList *) sc->host_scribble;
         if (abort == NULL) {
-                dev_err(&h->pdev->dev, "%s FAILED, Command to abort is NULL.\n",
-                                msg);
-                return FAILED;
+                /* This can happen if the command already completed. */
+                return SUCCESS;
+        }
+        refcount = atomic_inc_return(&abort->refcount);
+        if (refcount == 1) { /* Command is done already. */
+                cmd_free(h, abort);
+                return SUCCESS;
         }
         hpsa_get_tag(h, abort, &taglower, &tagupper);
         ml += sprintf(msg+ml, "Tag:0x%08x:%08x ", tagupper, taglower);
-        as  = (struct scsi_cmnd *) abort->scsi_cmd;
+        as  = abort->scsi_cmd;
         if (as != NULL)
                 ml += sprintf(msg+ml, "Command:0x%x SN:0x%lx ",
                         as->cmnd[0], as->serial_number);
         dev_dbg(&h->pdev->dev, "%s\n", msg);
         dev_warn(&h->pdev->dev, "Abort request on C%d:B%d:T%d:L%d\n",
                 h->scsi_host->host_no, dev->bus, dev->target, dev->lun);
-
-        /* Search reqQ to See if command is queued but not submitted,
-         * if so, complete the command with aborted status and remove
-         * it from the reqQ.
-         */
-        found = hpsa_find_cmd_in_queue(h, sc, &h->reqQ);
-        if (found) {
-                found->err_info->CommandStatus = CMD_ABORTED;
-                finish_cmd(found);
-                dev_info(&h->pdev->dev, "%s Request SUCCEEDED (driver queue).\n",
-                                msg);
-                return SUCCESS;
-        }
-
-        /* not in reqQ, if also not in cmpQ, must have already completed */
-        found = hpsa_find_cmd_in_queue(h, sc, &h->cmpQ);
-        if (!found)  {
-                dev_dbg(&h->pdev->dev, "%s Request SUCCEEDED (not known to driver).\n",
-                                msg);
-                return SUCCESS;
-        }
-
         /*
          * Command is in flight, or possibly already completed
          * by the firmware (but not to the scsi mid layer) but we can't
@@ -4554,6 +4629,7 @@ static int hpsa_eh_abort_handler(struct scsi_cmnd *sc)
                 dev_warn(&h->pdev->dev, "FAILED abort on device C%d:B%d:T%d:L%d\n",
                         h->scsi_host->host_no,
                         dev->bus, dev->target, dev->lun);
+                cmd_free(h, abort);
                 return FAILED;
         }
         dev_info(&h->pdev->dev, "%s REQUEST SUCCEEDED.\n", msg);
@@ -4565,32 +4641,38 @@ static int hpsa_eh_abort_handler(struct scsi_cmnd *sc)
          */
 #define ABORT_COMPLETE_WAIT_SECS 30
         for (i = 0; i < ABORT_COMPLETE_WAIT_SECS * 10; i++) {
-                found = hpsa_find_cmd_in_queue(h, sc, &h->cmpQ);
-                if (!found)
+                refcount = atomic_read(&abort->refcount);
+                if (refcount < 2) {
+                        cmd_free(h, abort);
                         return SUCCESS;
-                msleep(100);
+                } else {
+                        msleep(100);
+                }
         }
         dev_warn(&h->pdev->dev, "%s FAILED. Aborted command has not completed after %d seconds.\n",
                 msg, ABORT_COMPLETE_WAIT_SECS);
+        cmd_free(h, abort);
         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;
-        int loopcount;
+        int refcount;
+        unsigned long offset;
 
-        /* There is some *extremely* small but non-zero chance that that
+        /*
+         * There is some *extremely* small but non-zero chance that that
          * multiple threads could get in here, and one thread could
          * be scanning through the list of bits looking for a free
          * one, but the free ones are always behind him, and other
@@ -4601,24 +4683,30 @@ static struct CommandList *cmd_alloc(struct ctlr_info *h)
          * infrequently as to be indistinguishable from never.
          */
 
-        loopcount = 0;
-        do {
-                i = find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds);
-                if (i == h->nr_cmds)
-                        i = 0;
-                loopcount++;
-        } while (test_and_set_bit(i & (BITS_PER_LONG - 1),
-                  h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0 &&
-                loopcount < 10);
-
-        /* Thread got starved?  We do not expect this to ever happen. */
-        if (loopcount >= 10)
-                return NULL;
-
-        c = h->cmd_pool + i;
-        memset(c, 0, sizeof(*c));
-        cmd_dma_handle = h->cmd_pool_dhandle
-            + i * sizeof(*c);
+        offset = h->last_allocation; /* benignly racy */
+        for (;;) {
+                i = find_next_zero_bit(h->cmd_pool_bits, h->nr_cmds, offset);
+                if (unlikely(i == h->nr_cmds)) {
+                        offset = 0;
+                        continue;
+                }
+                c = h->cmd_pool + i;
+                refcount = atomic_inc_return(&c->refcount);
+                if (unlikely(refcount > 1)) {
+                        cmd_free(h, c); /* already in use */
+                        offset = (i + 1) % h->nr_cmds;
+                        continue;
+                }
+                set_bit(i & (BITS_PER_LONG - 1),
+                        h->cmd_pool_bits + (i / BITS_PER_LONG));
+                break; /* it's ours now. */
+        }
+        h->last_allocation = i; /* benignly racy */
+
+        /* Zero out all of commandlist except the last field, refcount */
+        memset(c, 0, offsetof(struct CommandList, refcount));
+        c->Header.tag = cpu_to_le64((u64) (i << DIRECT_LOOKUP_SHIFT));
+        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
@@ -4626,45 +4714,10 @@ static struct CommandList *cmd_alloc(struct ctlr_info *h)
 
         c->cmdindex = i;
 
-        INIT_LIST_HEAD(&c->list);
         c->busaddr = (u32) cmd_dma_handle;
         temp64.val = (u64) err_dma_handle;
-        c->ErrDesc.Addr = cpu_to_le64(err_dma_handle);
-        c->ErrDesc.Len = cpu_to_le32(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;
-        dma_addr_t cmd_dma_handle, err_dma_handle;
-
-        c = pci_zalloc_consistent(h->pdev, sizeof(*c), &cmd_dma_handle);
-        if (c == NULL)
-                return NULL;
-
-        c->cmd_type = CMD_SCSI;
-        c->cmdindex = -1;
-
-        c->err_info = pci_zalloc_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;
-        }
-
-        INIT_LIST_HEAD(&c->list);
-        c->busaddr = (u32) cmd_dma_handle;
-        c->ErrDesc.Addr = cpu_to_le64(err_dma_handle);
-        c->ErrDesc.Len = cpu_to_le32(sizeof(*c->err_info));
+        c->ErrDesc.Addr = cpu_to_le64((u64) err_dma_handle);
+        c->ErrDesc.Len = cpu_to_le32((u32) sizeof(*c->err_info));
 
         c->h = h;
         return c;
@@ -4672,20 +4725,13 @@ static struct CommandList *cmd_special_alloc(struct ctlr_info *h)
 
 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));
-}
+        if (atomic_dec_and_test(&c->refcount)) {
+                int i;
 
-static void cmd_special_free(struct ctlr_info *h, struct CommandList *c)
-{
-        pci_free_consistent(h->pdev, sizeof(*c->err_info),
-                            c->err_info,
-                            (dma_addr_t) le64_to_cpu(c->ErrDesc.Addr));
-        pci_free_consistent(h->pdev, sizeof(*c),
-                            c, (dma_addr_t) (c->busaddr & DIRECT_LOOKUP_MASK));
+                i = c - h->cmd_pool;
+                clear_bit(i & (BITS_PER_LONG - 1),
+                          h->cmd_pool_bits + (i / BITS_PER_LONG));
+        }
 }
 
 #ifdef CONFIG_COMPAT
@@ -4866,7 +4912,7 @@ static int hpsa_passthru_ioctl(struct ctlr_info *h, void __user *argp)
                         memset(buff, 0, iocommand.buf_size);
                 }
         }
-        c = cmd_special_alloc(h);
+        c = cmd_alloc(h);
         if (c == NULL) {
                 rc = -ENOMEM;
                 goto out_kfree;
@@ -4883,8 +4929,6 @@ static int hpsa_passthru_ioctl(struct ctlr_info *h, void __user *argp)
                 c->Header.SGTotal = cpu_to_le16(0);
         }
         memcpy(&c->Header.LUN, &iocommand.LUN_info, sizeof(c->Header.LUN));
-        /* use the kernel address the cmd block for tag */
-        c->Header.tag = c->busaddr;
 
         /* Fill in Request block */
         memcpy(&c->Request, &iocommand.Request,
@@ -4925,7 +4969,7 @@ static int hpsa_passthru_ioctl(struct ctlr_info *h, void __user *argp)
                 }
         }
 out:
-        cmd_special_free(h, c);
+        cmd_free(h, c);
 out_kfree:
         kfree(buff);
         return rc;
@@ -4940,7 +4984,6 @@ static int hpsa_big_passthru_ioctl(struct ctlr_info *h, void __user *argp)
         u64 temp64;
         BYTE sg_used = 0;
         int status = 0;
-        int i;
         u32 left;
         u32 sz;
         BYTE __user *data_ptr;
@@ -5004,7 +5047,7 @@ static int hpsa_big_passthru_ioctl(struct ctlr_info *h, void __user *argp)
                 data_ptr += sz;
                 sg_used++;
         }
-        c = cmd_special_alloc(h);
+        c = cmd_alloc(h);
         if (c == NULL) {
                 status = -ENOMEM;
                 goto cleanup1;
@@ -5014,7 +5057,6 @@ static int hpsa_big_passthru_ioctl(struct ctlr_info *h, void __user *argp)
         c->Header.SGList = (u8) sg_used;
         c->Header.SGTotal = cpu_to_le16(sg_used);
         memcpy(&c->Header.LUN, &ioc->LUN_info, sizeof(c->Header.LUN));
-        c->Header.tag = c->busaddr;
         memcpy(&c->Request, &ioc->Request, sizeof(c->Request));
         if (ioc->buf_size > 0) {
                 int i;
@@ -5047,6 +5089,8 @@ static int hpsa_big_passthru_ioctl(struct ctlr_info *h, void __user *argp)
                 goto cleanup0;
         }
         if ((ioc->Request.Type.Direction & XFER_READ) && ioc->buf_size > 0) {
+                int i;
+
                 /* Copy the data out of the buffer we created */
                 BYTE __user *ptr = ioc->buf;
                 for (i = 0; i < sg_used; i++) {
@@ -5059,9 +5103,11 @@ static int hpsa_big_passthru_ioctl(struct ctlr_info *h, void __user *argp)
         }
         status = 0;
 cleanup0:
-        cmd_special_free(h, c);
+        cmd_free(h, c);
 cleanup1:
         if (buff) {
+                int i;
+
                 for (i = 0; i < sg_used; i++)
                         kfree(buff[i]);
                 kfree(buff);
@@ -5079,35 +5125,6 @@ static void check_ioctl_unit_attention(struct ctlr_info *h,
                 (void) check_for_unit_attention(h, c);
 }
 
-static int increment_passthru_count(struct ctlr_info *h)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&h->passthru_count_lock, flags);
-        if (h->passthru_count >= HPSA_MAX_CONCURRENT_PASSTHRUS) {
-                spin_unlock_irqrestore(&h->passthru_count_lock, flags);
-                return -1;
-        }
-        h->passthru_count++;
-        spin_unlock_irqrestore(&h->passthru_count_lock, flags);
-        return 0;
-}
-
-static void decrement_passthru_count(struct ctlr_info *h)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&h->passthru_count_lock, flags);
-        if (h->passthru_count <= 0) {
-                spin_unlock_irqrestore(&h->passthru_count_lock, flags);
-                /* not expecting to get here. */
-                dev_warn(&h->pdev->dev, "Bug detected, passthru_count seems to be incorrect.\n");
-                return;
-        }
-        h->passthru_count--;
-        spin_unlock_irqrestore(&h->passthru_count_lock, flags);
-}
-
 /*
  * ioctl
  */
@@ -5130,16 +5147,16 @@ static int hpsa_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
         case CCISS_GETDRIVVER:
                 return hpsa_getdrivver_ioctl(h, argp);
         case CCISS_PASSTHRU:
-                if (increment_passthru_count(h))
+                if (atomic_dec_if_positive(&h->passthru_cmds_avail) < 0)
                         return -EAGAIN;
                 rc = hpsa_passthru_ioctl(h, argp);
-                decrement_passthru_count(h);
+                atomic_inc(&h->passthru_cmds_avail);
                 return rc;
         case CCISS_BIG_PASSTHRU:
-                if (increment_passthru_count(h))
+                if (atomic_dec_if_positive(&h->passthru_cmds_avail) < 0)
                         return -EAGAIN;
                 rc = hpsa_big_passthru_ioctl(h, argp);
-                decrement_passthru_count(h);
+                atomic_inc(&h->passthru_cmds_avail);
                 return rc;
         default:
                 return -ENOTTY;
@@ -5173,7 +5190,6 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
 {
         int pci_dir = XFER_NONE;
         struct CommandList *a; /* for commands to be aborted */
-        u32 tupper, tlower;
 
         c->cmd_type = CMD_IOCTL_PEND;
         c->Header.ReplyQueue = 0;
@@ -5184,7 +5200,6 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
                 c->Header.SGList = 0;
                 c->Header.SGTotal = cpu_to_le16(0);
         }
-        c->Header.tag = c->busaddr;
         memcpy(c->Header.LUN.LunAddrBytes, scsi3addr, 8);
 
         if (cmd_type == TYPE_CMD) {
@@ -5256,6 +5271,16 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
                         c->Request.CDB[7] = (size >> 16) & 0xFF;
                         c->Request.CDB[8] = (size >> 8) & 0xFF;
                         break;
+                case BMIC_IDENTIFY_PHYSICAL_DEVICE:
+                        c->Request.CDBLen = 10;
+                        c->Request.type_attr_dir =
+                                TYPE_ATTR_DIR(cmd_type, ATTR_SIMPLE, XFER_READ);
+                        c->Request.Timeout = 0;
+                        c->Request.CDB[0] = BMIC_READ;
+                        c->Request.CDB[6] = BMIC_IDENTIFY_PHYSICAL_DEVICE;
+                        c->Request.CDB[7] = (size >> 16) & 0xFF;
+                        c->Request.CDB[8] = (size >> 8) & 0XFF;
+                        break;
                 default:
                         dev_warn(&h->pdev->dev, "unknown command 0x%c\n", cmd);
                         BUG();
@@ -5281,10 +5306,9 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
                         break;
                 case  HPSA_ABORT_MSG:
                         a = buff;       /* point to command to be aborted */
-                        dev_dbg(&h->pdev->dev, "Abort Tag:0x%016llx using request Tag:0x%016llx",
+                        dev_dbg(&h->pdev->dev,
+                                "Abort Tag:0x%016llx request Tag:0x%016llx",
                                 a->Header.tag, c->Header.tag);
-                        tlower = (u32) (a->Header.tag >> 32);
-                        tupper = (u32) (a->Header.tag & 0x0ffffffffULL);
                         c->Request.CDBLen = 16;
                         c->Request.type_attr_dir =
                                         TYPE_ATTR_DIR(cmd_type,
@@ -5295,14 +5319,8 @@ static int fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
                         c->Request.CDB[2] = 0x00; /* reserved */
                         c->Request.CDB[3] = 0x00; /* reserved */
                         /* Tag to abort goes in CDB[4]-CDB[11] */
-                        c->Request.CDB[4] = tlower & 0xFF;
-                        c->Request.CDB[5] = (tlower >> 8) & 0xFF;
-                        c->Request.CDB[6] = (tlower >> 16) & 0xFF;
-                        c->Request.CDB[7] = (tlower >> 24) & 0xFF;
-                        c->Request.CDB[8] = tupper & 0xFF;
-                        c->Request.CDB[9] = (tupper >> 8) & 0xFF;
-                        c->Request.CDB[10] = (tupper >> 16) & 0xFF;
-                        c->Request.CDB[11] = (tupper >> 24) & 0xFF;
+                        memcpy(&c->Request.CDB[4], &a->Header.tag,
+                                sizeof(a->Header.tag));
                         c->Request.CDB[12] = 0x00; /* reserved */
                         c->Request.CDB[13] = 0x00; /* reserved */
                         c->Request.CDB[14] = 0x00; /* reserved */
@@ -5349,47 +5367,6 @@ static void __iomem *remap_pci_mem(ulong base, ulong 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.
- * Assumes h->lock is held
- */
-static void start_io(struct ctlr_info *h, unsigned long *flags)
-{
-        struct CommandList *c;
-
-        while (!list_empty(&h->reqQ)) {
-                c = list_entry(h->reqQ.next, struct CommandList, list);
-                /* can't do anything if fifo is full */
-                if ((h->access.fifo_full(h))) {
-                        h->fifo_recently_full = 1;
-                        dev_warn(&h->pdev->dev, "fifo full\n");
-                        break;
-                }
-                h->fifo_recently_full = 0;
-
-                /* Get the first entry from the Request Q */
-                removeQ(c);
-                h->Qdepth--;
-
-                /* Put job onto the completed Q */
-                addQ(&h->cmpQ, c);
-                atomic_inc(&h->commands_outstanding);
-                spin_unlock_irqrestore(&h->lock, *flags);
-                /* Tell the controller execute command */
-                h->access.submit_command(h, c);
-                spin_lock_irqsave(&h->lock, *flags);
-        }
-}
-
-static void lock_and_start_io(struct ctlr_info *h)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&h->lock, flags);
-        start_io(h, &flags);
-        spin_unlock_irqrestore(&h->lock, flags);
-}
-
 static inline unsigned long get_next_completion(struct ctlr_info *h, u8 q)
 {
         return h->access.command_completed(h, q);
@@ -5418,53 +5395,12 @@ static inline int bad_tag(struct ctlr_info *h, u32 tag_index,
 
 static inline void finish_cmd(struct CommandList *c)
 {
-        unsigned long flags;
-        int io_may_be_stalled = 0;
-        struct ctlr_info *h = c->h;
-        int count;
-
-        spin_lock_irqsave(&h->lock, flags);
-        removeQ(c);
-
-        /*
-         * Check for possibly stalled i/o.
-         *
-         * If a fifo_full condition is encountered, requests will back up
-         * in h->reqQ.  This queue is only emptied out by start_io which is
-         * only called when a new i/o request comes in.  If no i/o's are
-         * forthcoming, the i/o's in h->reqQ can get stuck.  So we call
-         * start_io from here if we detect such a danger.
-         *
-         * Normally, we shouldn't hit this case, but pounding on the
-         * CCISS_PASSTHRU ioctl can provoke it.  Only call start_io if
-         * commands_outstanding is low.  We want to avoid calling
-         * start_io from in here as much as possible, and esp. don't
-         * want to get in a cycle where we call start_io every time
-         * through here.
-         */
-        count = atomic_read(&h->commands_outstanding);
-        spin_unlock_irqrestore(&h->lock, flags);
-        if (unlikely(h->fifo_recently_full) && count < 5)
-                io_may_be_stalled = 1;
-
         dial_up_lockup_detection_on_fw_flash_complete(c->h, c);
         if (likely(c->cmd_type == CMD_IOACCEL1 || c->cmd_type == CMD_SCSI
                         || c->cmd_type == CMD_IOACCEL2))
                 complete_scsi_command(c);
         else if (c->cmd_type == CMD_IOCTL_PEND)
                 complete(c->waiting);
-        if (unlikely(io_may_be_stalled))
-                lock_and_start_io(h);
-}
-
-static inline u32 hpsa_tag_contains_index(u32 tag)
-{
-        return tag & DIRECT_LOOKUP_BIT;
-}
-
-static inline u32 hpsa_tag_to_index(u32 tag)
-{
-        return tag >> DIRECT_LOOKUP_SHIFT;
 }
 
 
@@ -5484,34 +5420,13 @@ static inline void process_indexed_cmd(struct ctlr_info *h,
         u32 tag_index;
         struct CommandList *c;
 
-        tag_index = hpsa_tag_to_index(raw_tag);
+        tag_index = raw_tag >> DIRECT_LOOKUP_SHIFT;
         if (!bad_tag(h, tag_index, raw_tag)) {
                 c = h->cmd_pool + tag_index;
                 finish_cmd(c);
         }
 }
 
-/* process completion of a non-indexed command */
-static inline void process_nonindexed_cmd(struct ctlr_info *h,
-        u32 raw_tag)
-{
-        u32 tag;
-        struct CommandList *c = NULL;
-        unsigned long flags;
-
-        tag = hpsa_tag_discard_error_bits(h, raw_tag);
-        spin_lock_irqsave(&h->lock, flags);
-        list_for_each_entry(c, &h->cmpQ, list) {
-                if ((c->busaddr & 0xFFFFFFE0) == (tag & 0xFFFFFFE0)) {
-                        spin_unlock_irqrestore(&h->lock, flags);
-                        finish_cmd(c);
-                        return;
-                }
-        }
-        spin_unlock_irqrestore(&h->lock, flags);
-        bad_tag(h, h->nr_cmds + 1, raw_tag);
-}
-
 /* Some controllers, like p400, will give us one interrupt
  * after a soft reset, even if we turned interrupts off.
  * Only need to check for this in the hpsa_xxx_discard_completions
@@ -5589,10 +5504,7 @@ static irqreturn_t do_hpsa_intr_intx(int irq, void *queue)
         while (interrupt_pending(h)) {
                 raw_tag = get_next_completion(h, q);
                 while (raw_tag != FIFO_EMPTY) {
-                        if (likely(hpsa_tag_contains_index(raw_tag)))
-                                process_indexed_cmd(h, raw_tag);
-                        else
-                                process_nonindexed_cmd(h, raw_tag);
+                        process_indexed_cmd(h, raw_tag);
                         raw_tag = next_command(h, q);
                 }
         }
@@ -5608,10 +5520,7 @@ static irqreturn_t do_hpsa_intr_msi(int irq, void *queue)
         h->last_intr_timestamp = get_jiffies_64();
         raw_tag = get_next_completion(h, q);
         while (raw_tag != FIFO_EMPTY) {
-                if (likely(hpsa_tag_contains_index(raw_tag)))
-                        process_indexed_cmd(h, raw_tag);
-                else
-                        process_nonindexed_cmd(h, raw_tag);
+                process_indexed_cmd(h, raw_tag);
                 raw_tag = next_command(h, q);
         }
         return IRQ_HANDLED;
@@ -5633,7 +5542,8 @@ static int hpsa_message(struct pci_dev *pdev, unsigned char opcode,
         static const size_t cmd_sz = sizeof(*cmd) +
                                         sizeof(cmd->ErrorDescriptor);
         dma_addr_t paddr64;
-        uint32_t paddr32, tag;
+        __le32 paddr32;
+        u32 tag;
         void __iomem *vaddr;
         int i, err;
 
@@ -5648,7 +5558,7 @@ static int hpsa_message(struct pci_dev *pdev, unsigned char opcode,
         err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
         if (err) {
                 iounmap(vaddr);
-                return -ENOMEM;
+                return err;
         }
 
         cmd = pci_alloc_consistent(pdev, cmd_sz, &paddr64);
@@ -5661,12 +5571,12 @@ static int hpsa_message(struct pci_dev *pdev, unsigned char opcode,
          * although there's no guarantee, we assume that the address is at
          * least 4-byte aligned (most likely, it's page-aligned).
          */
-        paddr32 = paddr64;
+        paddr32 = cpu_to_le32(paddr64);
 
         cmd->CommandHeader.ReplyQueue = 0;
         cmd->CommandHeader.SGList = 0;
         cmd->CommandHeader.SGTotal = cpu_to_le16(0);
-        cmd->CommandHeader.tag = paddr32;
+        cmd->CommandHeader.tag = cpu_to_le64(paddr64);
         memset(&cmd->CommandHeader.LUN.LunAddrBytes, 0, 8);
 
         cmd->Request.CDBLen = 16;
@@ -5677,14 +5587,14 @@ static int hpsa_message(struct pci_dev *pdev, unsigned char opcode,
         cmd->Request.CDB[1] = type;
         memset(&cmd->Request.CDB[2], 0, 14); /* rest of the CDB is reserved */
         cmd->ErrorDescriptor.Addr =
-                        cpu_to_le64((paddr32 + sizeof(*cmd)));
+                        cpu_to_le64((le32_to_cpu(paddr32) + sizeof(*cmd)));
         cmd->ErrorDescriptor.Len = cpu_to_le32(sizeof(struct ErrorInfo));
 
-        writel(paddr32, vaddr + SA5_REQUEST_PORT_OFFSET);
+        writel(le32_to_cpu(paddr32), vaddr + SA5_REQUEST_PORT_OFFSET);
 
         for (i = 0; i < HPSA_MSG_SEND_RETRY_LIMIT; i++) {
                 tag = readl(vaddr + SA5_REPLY_PORT_OFFSET);
-                if ((tag & ~HPSA_SIMPLE_ERROR_BITS) == paddr32)
+                if ((tag & ~HPSA_SIMPLE_ERROR_BITS) == paddr64)
                         break;
                 msleep(HPSA_MSG_SEND_RETRY_INTERVAL_MSECS);
         }
@@ -5718,8 +5628,6 @@ static int hpsa_message(struct pci_dev *pdev, unsigned char opcode,
 static int hpsa_controller_hard_reset(struct pci_dev *pdev,
         void __iomem *vaddr, u32 use_doorbell)
 {
-        u16 pmcsr;
-        int pos;
 
         if (use_doorbell) {
                 /* For everything after the P600, the PCI power state method
@@ -5745,26 +5653,21 @@ static int hpsa_controller_hard_reset(struct pci_dev *pdev,
                  * this causes a secondary PCI reset which will reset the
                  * controller." */
 
-                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;
-                }
+                int rc = 0;
+
                 dev_info(&pdev->dev, "using PCI PM to reset controller\n");
+
                 /* 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);
+                rc = pci_set_power_state(pdev, PCI_D3hot);
+                if (rc)
+                        return rc;
 
                 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);
+                rc = pci_set_power_state(pdev, PCI_D0);
+                if (rc)
+                        return rc;
 
                 /*
                  * The P600 requires a small delay when changing states.
@@ -5858,8 +5761,12 @@ static int hpsa_kdump_hard_reset_controller(struct pci_dev *pdev)
          */
 
         rc = hpsa_lookup_board_id(pdev, &board_id);
-        if (rc < 0 || !ctlr_is_resettable(board_id)) {
-                dev_warn(&pdev->dev, "Not resetting device.\n");
+        if (rc < 0) {
+                dev_warn(&pdev->dev, "Board ID not found\n");
+                return rc;
+        }
+        if (!ctlr_is_resettable(board_id)) {
+                dev_warn(&pdev->dev, "Controller not resettable\n");
                 return -ENODEV;
         }
 
@@ -5892,7 +5799,7 @@ static int hpsa_kdump_hard_reset_controller(struct pci_dev *pdev)
         }
         rc = write_driver_ver_to_cfgtable(cfgtable);
         if (rc)
-                goto unmap_vaddr;
+                goto unmap_cfgtable;
 
         /* If reset via doorbell register is supported, use that.
          * There are two such methods.  Favor the newest method.
@@ -5904,8 +5811,8 @@ static int hpsa_kdump_hard_reset_controller(struct pci_dev *pdev)
         } else {
                 use_doorbell = misc_fw_support & MISC_FW_DOORBELL_RESET;
                 if (use_doorbell) {
-                        dev_warn(&pdev->dev, "Soft reset not supported. "
-                                "Firmware update is required.\n");
+                        dev_warn(&pdev->dev,
+                                "Soft reset not supported. Firmware update is required.\n");
                         rc = -ENOTSUPP; /* try soft reset */
                         goto unmap_cfgtable;
                 }
@@ -5925,8 +5832,7 @@ static int hpsa_kdump_hard_reset_controller(struct pci_dev *pdev)
         rc = hpsa_wait_for_board_state(pdev, vaddr, BOARD_READY);
         if (rc) {
                 dev_warn(&pdev->dev,
-                        "failed waiting for board to become ready "
-                        "after hard reset\n");
+                        "Failed waiting for board to become ready after hard reset\n");
                 goto unmap_cfgtable;
         }
 
@@ -5977,7 +5883,7 @@ static void print_cfg_table(struct device *dev, struct CfgTable __iomem *tb)
                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",
+        dev_info(dev, "   Max outstanding commands = %d\n",
                readl(&(tb->CmdsOutMax)));
         dev_info(dev, "   Bus Types = 0x%x\n", readl(&(tb->BusTypes)));
         for (i = 0; i < 16; i++)
@@ -6025,7 +5931,7 @@ static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
 }
 
 /* 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.
+ * controllers that are capable. If not, we use legacy INTx mode.
  */
 
 static void hpsa_interrupt_mode(struct ctlr_info *h)
@@ -6044,7 +5950,7 @@ static void hpsa_interrupt_mode(struct ctlr_info *h)
             (h->board_id == 0x40820E11) || (h->board_id == 0x40830E11))
                 goto default_int_mode;
         if (pci_find_capability(h->pdev, PCI_CAP_ID_MSIX)) {
-                dev_info(&h->pdev->dev, "MSIX\n");
+                dev_info(&h->pdev->dev, "MSI-X capable controller\n");
                 h->msix_vector = MAX_REPLY_QUEUES;
                 if (h->msix_vector > num_online_cpus())
                         h->msix_vector = num_online_cpus();
@@ -6065,7 +5971,7 @@ static void hpsa_interrupt_mode(struct ctlr_info *h)
         }
 single_msi_mode:
         if (pci_find_capability(h->pdev, PCI_CAP_ID_MSI)) {
-                dev_info(&h->pdev->dev, "MSI\n");
+                dev_info(&h->pdev->dev, "MSI capable controller\n");
                 if (!pci_enable_msi(h->pdev))
                         h->msi_vector = 1;
                 else
@@ -6172,8 +6078,10 @@ static int hpsa_find_cfgtables(struct ctlr_info *h)
                 return rc;
         h->cfgtable = remap_pci_mem(pci_resource_start(h->pdev,
                        cfg_base_addr_index) + cfg_offset, sizeof(*h->cfgtable));
-        if (!h->cfgtable)
+        if (!h->cfgtable) {
+                dev_err(&h->pdev->dev, "Failed mapping cfgtable\n");
                 return -ENOMEM;
+        }
         rc = write_driver_ver_to_cfgtable(h->cfgtable);
         if (rc)
                 return rc;
@@ -6204,6 +6112,15 @@ static void hpsa_get_max_perf_mode_cmds(struct ctlr_info *h)
         }
 }
 
+/* If the controller reports that the total max sg entries is greater than 512,
+ * then we know that chained SG blocks work.  (Original smart arrays did not
+ * support chained SG blocks and would return zero for max sg entries.)
+ */
+static int hpsa_supports_chained_sg_blocks(struct ctlr_info *h)
+{
+        return h->maxsgentries > 512;
+}
+
 /* Interrogate the hardware for some limits:
  * max commands, max SG elements without chaining, and with chaining,
  * SG chain block size, etc.
@@ -6211,21 +6128,23 @@ static void hpsa_get_max_perf_mode_cmds(struct ctlr_info *h)
 static void hpsa_find_board_params(struct ctlr_info *h)
 {
         hpsa_get_max_perf_mode_cmds(h);
-        h->nr_cmds = h->max_commands - 4; /* Allow room for some ioctls */
+        h->nr_cmds = h->max_commands;
         h->maxsgentries = readl(&(h->cfgtable->MaxScatterGatherElements));
         h->fw_support = readl(&(h->cfgtable->misc_fw_support));
-        /*
-         * 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) {
+        if (hpsa_supports_chained_sg_blocks(h)) {
+                /* Limit in-command s/g elements to 32 save dma'able memory. */
                 h->max_cmd_sg_entries = 32;
                 h->chainsize = h->maxsgentries - h->max_cmd_sg_entries;
                 h->maxsgentries--; /* save one for chain pointer */
         } else {
-                h->chainsize = 0;
+                /*
+                 * Original smart arrays supported at most 31 s/g entries
+                 * embedded inline in the command (trying to use more
+                 * would lock up the controller)
+                 */
+                h->max_cmd_sg_entries = 31;
                 h->maxsgentries = 31; /* default to traditional values */
+                h->chainsize = 0;
         }
 
         /* Find out what task management functions are supported and cache */
@@ -6239,7 +6158,7 @@ static void hpsa_find_board_params(struct ctlr_info *h)
 static inline bool hpsa_CISS_signature_present(struct ctlr_info *h)
 {
         if (!check_signature(h->cfgtable->Signature, "CISS", 4)) {
-                dev_warn(&h->pdev->dev, "not a valid CISS config table\n");
+                dev_err(&h->pdev->dev, "not a valid CISS config table\n");
                 return false;
         }
         return true;
@@ -6272,24 +6191,27 @@ static inline void hpsa_p600_dma_prefetch_quirk(struct ctlr_info *h)
         writel(dma_prefetch, h->vaddr + I2O_DMA1_CFG);
 }
 
-static void hpsa_wait_for_clear_event_notify_ack(struct ctlr_info *h)
+static int hpsa_wait_for_clear_event_notify_ack(struct ctlr_info *h)
 {
         int i;
         u32 doorbell_value;
         unsigned long flags;
         /* wait until the clear_event_notify bit 6 is cleared by controller. */
-        for (i = 0; i < MAX_CONFIG_WAIT; i++) {
+        for (i = 0; i < MAX_CLEAR_EVENT_WAIT; i++) {
                 spin_lock_irqsave(&h->lock, flags);
                 doorbell_value = readl(h->vaddr + SA5_DOORBELL);
                 spin_unlock_irqrestore(&h->lock, flags);
                 if (!(doorbell_value & DOORBELL_CLEAR_EVENTS))
-                        break;
+                        goto done;
                 /* delay and try again */
-                msleep(20);
+                msleep(CLEAR_EVENT_WAIT_INTERVAL);
         }
+        return -ENODEV;
+done:
+        return 0;
 }
 
-static void hpsa_wait_for_mode_change_ack(struct ctlr_info *h)
+static int hpsa_wait_for_mode_change_ack(struct ctlr_info *h)
 {
         int i;
         u32 doorbell_value;
@@ -6299,17 +6221,21 @@ static void hpsa_wait_for_mode_change_ack(struct ctlr_info *h)
          * (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++) {
+        for (i = 0; i < MAX_MODE_CHANGE_WAIT; i++) {
                 spin_lock_irqsave(&h->lock, flags);
                 doorbell_value = readl(h->vaddr + SA5_DOORBELL);
                 spin_unlock_irqrestore(&h->lock, flags);
                 if (!(doorbell_value & CFGTBL_ChangeReq))
-                        break;
+                        goto done;
                 /* delay and try again */
-                usleep_range(10000, 20000);
+                msleep(MODE_CHANGE_WAIT_INTERVAL);
         }
+        return -ENODEV;
+done:
+        return 0;
 }
 
+/* return -ENODEV or other reason on error, 0 on success */
 static int hpsa_enter_simple_mode(struct ctlr_info *h)
 {
         u32 trans_support;
@@ -6324,14 +6250,15 @@ static int hpsa_enter_simple_mode(struct ctlr_info *h)
         writel(CFGTBL_Trans_Simple, &(h->cfgtable->HostWrite.TransportRequest));
         writel(0, &h->cfgtable->HostWrite.command_pool_addr_hi);
         writel(CFGTBL_ChangeReq, h->vaddr + SA5_DOORBELL);
-        hpsa_wait_for_mode_change_ack(h);
+        if (hpsa_wait_for_mode_change_ack(h))
+                goto error;
         print_cfg_table(&h->pdev->dev, h->cfgtable);
         if (!(readl(&(h->cfgtable->TransportActive)) & CFGTBL_Trans_Simple))
                 goto error;
         h->transMethod = CFGTBL_Trans_Simple;
         return 0;
 error:
-        dev_warn(&h->pdev->dev, "unable to get board into simple mode\n");
+        dev_err(&h->pdev->dev, "failed to enter simple mode\n");
         return -ENODEV;
 }
 
@@ -6341,7 +6268,7 @@ static int hpsa_pci_init(struct ctlr_info *h)
 
         prod_index = hpsa_lookup_board_id(h->pdev, &h->board_id);
         if (prod_index < 0)
-                return -ENODEV;
+                return prod_index;
         h->product_name = products[prod_index].product_name;
         h->access = *(products[prod_index].access);
 
@@ -6422,6 +6349,7 @@ static void hpsa_hba_inquiry(struct ctlr_info *h)
 static int hpsa_init_reset_devices(struct pci_dev *pdev)
 {
         int rc, i;
+        void __iomem *vaddr;
 
         if (!reset_devices)
                 return 0;
@@ -6445,6 +6373,14 @@ static int hpsa_init_reset_devices(struct pci_dev *pdev)
 
         pci_set_master(pdev);
 
+        vaddr = pci_ioremap_bar(pdev, 0);
+        if (vaddr == NULL) {
+                rc = -ENOMEM;
+                goto out_disable;
+        }
+        writel(SA5_INTR_OFF, vaddr + SA5_REPLY_INTR_MASK_OFFSET);
+        iounmap(vaddr);
+
         /* Reset the controller with a PCI power-cycle or via doorbell */
         rc = hpsa_kdump_hard_reset_controller(pdev);
 
@@ -6453,14 +6389,11 @@ static int hpsa_init_reset_devices(struct pci_dev *pdev)
          * "performant mode".  Or, it might be 640x, which can't reset
          * due to concerns about shared bbwc between 6402/6404 pair.
          */
-        if (rc) {
-                if (rc != -ENOTSUPP) /* just try to do the kdump anyhow. */
-                        rc = -ENODEV;
+        if (rc)
                 goto out_disable;
-        }
 
         /* Now try to get the controller to respond to a no-op */
-        dev_warn(&pdev->dev, "Waiting for controller to respond to no-op\n");
+        dev_info(&pdev->dev, "Waiting for controller to respond to no-op\n");
         for (i = 0; i < HPSA_POST_RESET_NOOP_RETRIES; i++) {
                 if (hpsa_noop(pdev) == 0)
                         break;
@@ -6490,9 +6423,12 @@ static int hpsa_allocate_cmd_pool(struct ctlr_info *h)
             || (h->cmd_pool == NULL)
             || (h->errinfo_pool == NULL)) {
                 dev_err(&h->pdev->dev, "out of memory in %s", __func__);
-                return -ENOMEM;
+                goto clean_up;
         }
         return 0;
+clean_up:
+        hpsa_free_cmd_pool(h);
+        return -ENOMEM;
 }
 
 static void hpsa_free_cmd_pool(struct ctlr_info *h)
@@ -6519,16 +6455,38 @@ static void hpsa_free_cmd_pool(struct ctlr_info *h)
 
 static void hpsa_irq_affinity_hints(struct ctlr_info *h)
 {
-        int i, cpu, rc;
+        int i, cpu;
 
         cpu = cpumask_first(cpu_online_mask);
         for (i = 0; i < h->msix_vector; i++) {
-                rc = irq_set_affinity_hint(h->intr[i], get_cpu_mask(cpu));
+                irq_set_affinity_hint(h->intr[i], get_cpu_mask(cpu));
                 cpu = cpumask_next(cpu, cpu_online_mask);
         }
 }
 
-static int hpsa_request_irq(struct ctlr_info *h,
+/* clear affinity hints and free MSI-X, MSI, or legacy INTx vectors */
+static void hpsa_free_irqs(struct ctlr_info *h)
+{
+        int i;
+
+        if (!h->msix_vector || h->intr_mode != PERF_MODE_INT) {
+                /* Single reply queue, only one irq to free */
+                i = h->intr_mode;
+                irq_set_affinity_hint(h->intr[i], NULL);
+                free_irq(h->intr[i], &h->q[i]);
+                return;
+        }
+
+        for (i = 0; i < h->msix_vector; i++) {
+                irq_set_affinity_hint(h->intr[i], NULL);
+                free_irq(h->intr[i], &h->q[i]);
+        }
+        for (; i < MAX_REPLY_QUEUES; i++)
+                h->q[i] = 0;
+}
+
+/* returns 0 on success; cleans up and returns -Enn on error */
+static int hpsa_request_irqs(struct ctlr_info *h,
         irqreturn_t (*msixhandler)(int, void *),
         irqreturn_t (*intxhandler)(int, void *))
 {
@@ -6543,10 +6501,25 @@ static int hpsa_request_irq(struct ctlr_info *h,
 
         if (h->intr_mode == PERF_MODE_INT && h->msix_vector > 0) {
                 /* If performant mode and MSI-X, use multiple reply queues */
-                for (i = 0; i < h->msix_vector; i++)
+                for (i = 0; i < h->msix_vector; i++) {
                         rc = request_irq(h->intr[i], msixhandler,
                                         0, h->devname,
                                         &h->q[i]);
+                        if (rc) {
+                                int j;
+
+                                dev_err(&h->pdev->dev,
+                                        "failed to get irq %d for %s\n",
+                                       h->intr[i], h->devname);
+                                for (j = 0; j < i; j++) {
+                                        free_irq(h->intr[j], &h->q[j]);
+                                        h->q[j] = 0;
+                                }
+                                for (; j < MAX_REPLY_QUEUES; j++)
+                                        h->q[j] = 0;
+                                return rc;
+                        }
+                }
                 hpsa_irq_affinity_hints(h);
         } else {
                 /* Use single reply pool */
@@ -6592,27 +6565,9 @@ static int hpsa_kdump_soft_reset(struct ctlr_info *h)
         return 0;
 }
 
-static void free_irqs(struct ctlr_info *h)
-{
-        int i;
-
-        if (!h->msix_vector || h->intr_mode != PERF_MODE_INT) {
-                /* Single reply queue, only one irq to free */
-                i = h->intr_mode;
-                irq_set_affinity_hint(h->intr[i], NULL);
-                free_irq(h->intr[i], &h->q[i]);
-                return;
-        }
-
-        for (i = 0; i < h->msix_vector; i++) {
-                irq_set_affinity_hint(h->intr[i], NULL);
-                free_irq(h->intr[i], &h->q[i]);
-        }
-}
-
 static void hpsa_free_irqs_and_disable_msix(struct ctlr_info *h)
 {
-        free_irqs(h);
+        hpsa_free_irqs(h);
 #ifdef CONFIG_PCI_MSI
         if (h->msix_vector) {
                 if (h->pdev->msix_enabled)
@@ -6658,16 +6613,20 @@ static void hpsa_undo_allocations_after_kdump_soft_reset(struct ctlr_info *h)
 }
 
 /* Called when controller lockup detected. */
-static void fail_all_cmds_on_list(struct ctlr_info *h, struct list_head *list)
+static void fail_all_outstanding_cmds(struct ctlr_info *h)
 {
-        struct CommandList *c = NULL;
+        int i, refcount;
+        struct CommandList *c;
 
-        assert_spin_locked(&h->lock);
-        /* Mark all outstanding commands as failed and complete them. */
-        while (!list_empty(list)) {
-                c = list_entry(list->next, struct CommandList, list);
-                c->err_info->CommandStatus = CMD_HARDWARE_ERR;
-                finish_cmd(c);
+        flush_workqueue(h->resubmit_wq); /* ensure all cmds are fully built */
+        for (i = 0; i < h->nr_cmds; i++) {
+                c = h->cmd_pool + i;
+                refcount = atomic_inc_return(&c->refcount);
+                if (refcount > 1) {
+                        c->err_info->CommandStatus = CMD_HARDWARE_ERR;
+                        finish_cmd(c);
+                }
+                cmd_free(h, c);
         }
 }
 
@@ -6704,10 +6663,7 @@ static void controller_lockup_detected(struct ctlr_info *h)
         dev_warn(&h->pdev->dev, "Controller lockup detected: 0x%08x\n",
                         lockup_detected);
         pci_disable_device(h->pdev);
-        spin_lock_irqsave(&h->lock, flags);
-        fail_all_cmds_on_list(h, &h->cmpQ);
-        fail_all_cmds_on_list(h, &h->reqQ);
-        spin_unlock_irqrestore(&h->lock, flags);
+        fail_all_outstanding_cmds(h);
 }
 
 static void detect_controller_lockup(struct ctlr_info *h)
@@ -6750,8 +6706,8 @@ static void hpsa_ack_ctlr_events(struct ctlr_info *h)
         int i;
         char *event_type;
 
-        /* Clear the driver-requested rescan flag */
-        h->drv_req_rescan = 0;
+        if (!(h->fw_support & MISC_FW_EVENT_NOTIFY))
+                return;
 
         /* Ask the controller to clear the events we're handling. */
         if ((h->transMethod & (CFGTBL_Trans_io_accel1
@@ -6798,9 +6754,6 @@ static void hpsa_ack_ctlr_events(struct ctlr_info *h)
  */
 static int hpsa_ctlr_needs_rescan(struct ctlr_info *h)
 {
-        if (h->drv_req_rescan)
-                return 1;
-
         if (!(h->fw_support & MISC_FW_EVENT_NOTIFY))
                 return 0;
 
@@ -6834,34 +6787,58 @@ static int hpsa_offline_devices_ready(struct ctlr_info *h)
         return 0;
 }
 
-
-static void hpsa_monitor_ctlr_worker(struct work_struct *work)
+static void hpsa_rescan_ctlr_worker(struct work_struct *work)
 {
         unsigned long flags;
         struct ctlr_info *h = container_of(to_delayed_work(work),
-                                        struct ctlr_info, monitor_ctlr_work);
-        detect_controller_lockup(h);
-        if (lockup_detected(h))
+                                        struct ctlr_info, rescan_ctlr_work);
+
+
+        if (h->remove_in_progress)
                 return;
 
         if (hpsa_ctlr_needs_rescan(h) || hpsa_offline_devices_ready(h)) {
                 scsi_host_get(h->scsi_host);
-                h->drv_req_rescan = 0;
                 hpsa_ack_ctlr_events(h);
                 hpsa_scan_start(h->scsi_host);
                 scsi_host_put(h->scsi_host);
         }
-
         spin_lock_irqsave(&h->lock, flags);
-        if (h->remove_in_progress) {
-                spin_unlock_irqrestore(&h->lock, flags);
+        if (!h->remove_in_progress)
+                queue_delayed_work(h->rescan_ctlr_wq, &h->rescan_ctlr_work,
+                                h->heartbeat_sample_interval);
+        spin_unlock_irqrestore(&h->lock, flags);
+}
+
+static void hpsa_monitor_ctlr_worker(struct work_struct *work)
+{
+        unsigned long flags;
+        struct ctlr_info *h = container_of(to_delayed_work(work),
+                                        struct ctlr_info, monitor_ctlr_work);
+
+        detect_controller_lockup(h);
+        if (lockup_detected(h))
                 return;
-        }
-        schedule_delayed_work(&h->monitor_ctlr_work,
+
+        spin_lock_irqsave(&h->lock, flags);
+        if (!h->remove_in_progress)
+                schedule_delayed_work(&h->monitor_ctlr_work,
                                 h->heartbeat_sample_interval);
         spin_unlock_irqrestore(&h->lock, flags);
 }
 
+static struct workqueue_struct *hpsa_create_controller_wq(struct ctlr_info *h,
+                                                char *name)
+{
+        struct workqueue_struct *wq = NULL;
+
+        wq = alloc_ordered_workqueue("%s_%d_hpsa", 0, name, h->ctlr);
+        if (!wq)
+                dev_err(&h->pdev->dev, "failed to create %s workqueue\n", name);
+
+        return wq;
+}
+
 static int hpsa_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
         int dac, rc;
@@ -6898,13 +6875,23 @@ reinit_after_soft_reset:
 
         h->pdev = pdev;
         h->intr_mode = hpsa_simple_mode ? SIMPLE_MODE_INT : PERF_MODE_INT;
-        INIT_LIST_HEAD(&h->cmpQ);
-        INIT_LIST_HEAD(&h->reqQ);
         INIT_LIST_HEAD(&h->offline_device_list);
         spin_lock_init(&h->lock);
         spin_lock_init(&h->offline_device_lock);
         spin_lock_init(&h->scan_lock);
-        spin_lock_init(&h->passthru_count_lock);
+        atomic_set(&h->passthru_cmds_avail, HPSA_MAX_CONCURRENT_PASSTHRUS);
+
+        h->rescan_ctlr_wq = hpsa_create_controller_wq(h, "rescan");
+        if (!h->rescan_ctlr_wq) {
+                rc = -ENOMEM;
+                goto clean1;
+        }
+
+        h->resubmit_wq = hpsa_create_controller_wq(h, "resubmit");
+        if (!h->resubmit_wq) {
+                rc = -ENOMEM;
+                goto clean1;
+        }
 
         /* Allocate and clear per-cpu variable lockup_detected */
         h->lockup_detected = alloc_percpu(u32);
@@ -6939,13 +6926,14 @@ reinit_after_soft_reset:
         /* make sure the board interrupts are off */
         h->access.set_intr_mask(h, HPSA_INTR_OFF);
 
-        if (hpsa_request_irq(h, do_hpsa_intr_msi, do_hpsa_intr_intx))
+        if (hpsa_request_irqs(h, do_hpsa_intr_msi, do_hpsa_intr_intx))
                 goto clean2;
         dev_info(&pdev->dev, "%s: <0x%x> at IRQ %d%s using DAC\n",
                h->devname, pdev->device,
                h->intr[h->intr_mode], dac ? "" : " not");
-        if (hpsa_allocate_cmd_pool(h))
-                goto clean4;
+        rc = hpsa_allocate_cmd_pool(h);
+        if (rc)
+                goto clean2_and_free_irqs;
         if (hpsa_allocate_sg_chain_blocks(h))
                 goto clean4;
         init_waitqueue_head(&h->scan_wait_queue);
@@ -6974,12 +6962,12 @@ reinit_after_soft_reset:
                 spin_lock_irqsave(&h->lock, flags);
                 h->access.set_intr_mask(h, HPSA_INTR_OFF);
                 spin_unlock_irqrestore(&h->lock, flags);
-                free_irqs(h);
-                rc = hpsa_request_irq(h, hpsa_msix_discard_completions,
+                hpsa_free_irqs(h);
+                rc = hpsa_request_irqs(h, hpsa_msix_discard_completions,
                                         hpsa_intx_discard_completions);
                 if (rc) {
-                        dev_warn(&h->pdev->dev, "Failed to request_irq after "
-                                "soft reset.\n");
+                        dev_warn(&h->pdev->dev,
+                                "Failed to request_irq after soft reset.\n");
                         goto clean4;
                 }
 
@@ -7016,7 +7004,6 @@ reinit_after_soft_reset:
                 /* Enable Accelerated IO path at driver layer */
                 h->acciopath_status = 1;
 
-        h->drv_req_rescan = 0;
 
         /* Turn the interrupts on so we can service requests */
         h->access.set_intr_mask(h, HPSA_INTR_ON);
@@ -7029,14 +7016,22 @@ reinit_after_soft_reset:
         INIT_DELAYED_WORK(&h->monitor_ctlr_work, hpsa_monitor_ctlr_worker);
         schedule_delayed_work(&h->monitor_ctlr_work,
                                 h->heartbeat_sample_interval);
+        INIT_DELAYED_WORK(&h->rescan_ctlr_work, hpsa_rescan_ctlr_worker);
+        queue_delayed_work(h->rescan_ctlr_wq, &h->rescan_ctlr_work,
+                                h->heartbeat_sample_interval);
         return 0;
 
 clean4:
         hpsa_free_sg_chain_blocks(h);
         hpsa_free_cmd_pool(h);
-        free_irqs(h);
+clean2_and_free_irqs:
+        hpsa_free_irqs(h);
 clean2:
 clean1:
+        if (h->resubmit_wq)
+                destroy_workqueue(h->resubmit_wq);
+        if (h->rescan_ctlr_wq)
+                destroy_workqueue(h->rescan_ctlr_wq);
         if (h->lockup_detected)
                 free_percpu(h->lockup_detected);
         kfree(h);
@@ -7055,9 +7050,9 @@ static void hpsa_flush_cache(struct ctlr_info *h)
         if (!flush_buf)
                 return;
 
-        c = cmd_special_alloc(h);
+        c = cmd_alloc(h);
         if (!c) {
-                dev_warn(&h->pdev->dev, "cmd_special_alloc returned NULL!\n");
+                dev_warn(&h->pdev->dev, "cmd_alloc returned NULL!\n");
                 goto out_of_memory;
         }
         if (fill_cmd(c, HPSA_CACHE_FLUSH, h, flush_buf, 4, 0,
@@ -7069,7 +7064,7 @@ static void hpsa_flush_cache(struct ctlr_info *h)
 out:
                 dev_warn(&h->pdev->dev,
                         "error flushing cache on controller\n");
-        cmd_special_free(h, c);
+        cmd_free(h, c);
 out_of_memory:
         kfree(flush_buf);
 }
@@ -7110,9 +7105,11 @@ static void hpsa_remove_one(struct pci_dev *pdev)
         /* Get rid of any controller monitoring work items */
         spin_lock_irqsave(&h->lock, flags);
         h->remove_in_progress = 1;
-        cancel_delayed_work(&h->monitor_ctlr_work);
         spin_unlock_irqrestore(&h->lock, flags);
-
+        cancel_delayed_work_sync(&h->monitor_ctlr_work);
+        cancel_delayed_work_sync(&h->rescan_ctlr_work);
+        destroy_workqueue(h->rescan_ctlr_wq);
+        destroy_workqueue(h->resubmit_wq);
         hpsa_unregister_scsi(h);        /* unhook from SCSI subsystem */
         hpsa_shutdown(pdev);
         iounmap(h->vaddr);
@@ -7172,7 +7169,7 @@ static struct pci_driver hpsa_pci_driver = {
  * bits of the command address.
  */
 static void  calc_bucket_map(int bucket[], int num_buckets,
-        int nsgs, int min_blocks, int *bucket_map)
+        int nsgs, int min_blocks, u32 *bucket_map)
 {
         int i, j, b, size;
 
@@ -7193,7 +7190,8 @@ static void  calc_bucket_map(int bucket[], int num_buckets,
         }
 }
 
-static void hpsa_enter_performant_mode(struct ctlr_info *h, u32 trans_support)
+/* return -ENODEV or other reason on error, 0 on success */
+static int hpsa_enter_performant_mode(struct ctlr_info *h, u32 trans_support)
 {
         int i;
         unsigned long register_value;
@@ -7285,12 +7283,16 @@ static void hpsa_enter_performant_mode(struct ctlr_info *h, u32 trans_support)
                 }
         }
         writel(CFGTBL_ChangeReq, h->vaddr + SA5_DOORBELL);
-        hpsa_wait_for_mode_change_ack(h);
+        if (hpsa_wait_for_mode_change_ack(h)) {
+                dev_err(&h->pdev->dev,
+                        "performant mode problem - doorbell timeout\n");
+                return -ENODEV;
+        }
         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;
+                dev_err(&h->pdev->dev,
+                        "performant mode problem - transport not active\n");
+                return -ENODEV;
         }
         /* Change the access methods to the performant access methods */
         h->access = access;
@@ -7298,7 +7300,7 @@ static void hpsa_enter_performant_mode(struct ctlr_info *h, u32 trans_support)
 
         if (!((trans_support & CFGTBL_Trans_io_accel1) ||
                 (trans_support & CFGTBL_Trans_io_accel2)))
-                return;
+                return 0;
 
         if (trans_support & CFGTBL_Trans_io_accel1) {
                 /* Set up I/O accelerator mode */
@@ -7328,12 +7330,12 @@ static void hpsa_enter_performant_mode(struct ctlr_info *h, u32 trans_support)
                                         (i * sizeof(struct ErrorInfo)));
                         cp->err_info_len = sizeof(struct ErrorInfo);
                         cp->sgl_offset = IOACCEL1_SGLOFFSET;
-                        cp->host_context_flags = IOACCEL1_HCFLAGS_CISS_FORMAT;
+                        cp->host_context_flags =
+                                cpu_to_le16(IOACCEL1_HCFLAGS_CISS_FORMAT);
                         cp->timeout_sec = 0;
                         cp->ReplyQueue = 0;
                         cp->tag =
-                                cpu_to_le64((i << DIRECT_LOOKUP_SHIFT) |
-                                                DIRECT_LOOKUP_BIT);
+                                cpu_to_le64((i << DIRECT_LOOKUP_SHIFT));
                         cp->host_addr =
                                 cpu_to_le64(h->ioaccel_cmd_pool_dhandle +
                                         (i * sizeof(struct io_accel1_cmd)));
@@ -7362,7 +7364,12 @@ static void hpsa_enter_performant_mode(struct ctlr_info *h, u32 trans_support)
                         writel(bft2[i], &h->ioaccel2_bft2_regs[i]);
         }
         writel(CFGTBL_ChangeReq, h->vaddr + SA5_DOORBELL);
-        hpsa_wait_for_mode_change_ack(h);
+        if (hpsa_wait_for_mode_change_ack(h)) {
+                dev_err(&h->pdev->dev,
+                        "performant mode problem - enabling ioaccel mode\n");
+                return -ENODEV;
+        }
+        return 0;
 }
 
 static int hpsa_alloc_ioaccel_cmd_and_bft(struct ctlr_info *h)
@@ -7508,17 +7515,18 @@ static int is_accelerated_cmd(struct CommandList *c)
 static void hpsa_drain_accel_commands(struct ctlr_info *h)
 {
         struct CommandList *c = NULL;
-        unsigned long flags;
-        int accel_cmds_out;
+        int i, accel_cmds_out;
+        int refcount;
 
-        do { /* wait for all outstanding commands to drain out */
+        do { /* wait for all outstanding ioaccel commands to drain out */
                 accel_cmds_out = 0;
-                spin_lock_irqsave(&h->lock, flags);
-                list_for_each_entry(c, &h->cmpQ, list)
-                        accel_cmds_out += is_accelerated_cmd(c);
-                list_for_each_entry(c, &h->reqQ, list)
-                        accel_cmds_out += is_accelerated_cmd(c);
-                spin_unlock_irqrestore(&h->lock, flags);
+                for (i = 0; i < h->nr_cmds; i++) {
+                        c = h->cmd_pool + i;
+                        refcount = atomic_inc_return(&c->refcount);
+                        if (refcount > 1) /* Command is allocated */
+                                accel_cmds_out += is_accelerated_cmd(c);
+                        cmd_free(h, c);
+                }
                 if (accel_cmds_out <= 0)
                         break;
                 msleep(100);
diff --git a/drivers/scsi/hpsa.h b/drivers/scsi/hpsa.h
index 8e06d9e280ec..657713050349 100644
--- a/drivers/scsi/hpsa.h
+++ b/drivers/scsi/hpsa.h
@@ -32,7 +32,6 @@ 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, u8 q);
 };
@@ -47,6 +46,11 @@ struct hpsa_scsi_dev_t {
         unsigned char model[16];        /* bytes 16-31 of inquiry data */
         unsigned char raid_level;       /* from inquiry page 0xC1 */
         unsigned char volume_offline;   /* discovered via TUR or VPD */
+        u16 queue_depth;                /* max queue_depth for this device */
+        atomic_t ioaccel_cmds_out;      /* Only used for physical devices
+                                         * counts commands sent to physical
+                                         * device via "ioaccel" path.
+                                         */
         u32 ioaccel_handle;
         int offload_config;             /* I/O accel RAID offload configured */
         int offload_enabled;            /* I/O accel RAID offload enabled */
@@ -55,6 +59,15 @@ struct hpsa_scsi_dev_t {
                                          */
         struct raid_map_data raid_map;  /* I/O accelerator RAID map */
 
+        /*
+         * Pointers from logical drive map indices to the phys drives that
+         * make those logical drives.  Note, multiple logical drives may
+         * share physical drives.  You can have for instance 5 physical
+         * drives with 3 logical drives each using those same 5 physical
+         * disks. We need these pointers for counting i/o's out to physical
+         * devices in order to honor physical device queue depth limits.
+         */
+        struct hpsa_scsi_dev_t *phys_disk[RAID_MAP_MAX_ENTRIES];
 };
 
 struct reply_queue_buffer {
@@ -115,9 +128,12 @@ struct ctlr_info {
         void __iomem *vaddr;
         unsigned long paddr;
         int     nr_cmds; /* Number of commands allowed on this controller */
+#define HPSA_CMDS_RESERVED_FOR_ABORTS 2
+#define HPSA_CMDS_RESERVED_FOR_DRIVER 1
         struct CfgTable __iomem *cfgtable;
         int     interrupts_enabled;
         int     max_commands;
+        int last_allocation;
         atomic_t commands_outstanding;
 #       define PERF_MODE_INT    0
 #       define DOORBELL_INT     1
@@ -131,8 +147,6 @@ struct ctlr_info {
         char hba_mode_enabled;
 
         /* queue and queue Info */
-        struct list_head reqQ;
-        struct list_head cmpQ;
         unsigned int Qdepth;
         unsigned int maxSG;
         spinlock_t lock;
@@ -168,9 +182,8 @@ struct ctlr_info {
         unsigned long transMethod;
 
         /* cap concurrent passthrus at some reasonable maximum */
-#define HPSA_MAX_CONCURRENT_PASSTHRUS (20)
-        spinlock_t passthru_count_lock; /* protects passthru_count */
-        int passthru_count;
+#define HPSA_MAX_CONCURRENT_PASSTHRUS (10)
+        atomic_t passthru_cmds_avail;
 
         /*
          * Performant mode completion buffers
@@ -194,8 +207,8 @@ struct ctlr_info {
         atomic_t firmware_flash_in_progress;
         u32 __percpu *lockup_detected;
         struct delayed_work monitor_ctlr_work;
+        struct delayed_work rescan_ctlr_work;
         int remove_in_progress;
-        u32 fifo_recently_full;
         /* Address of h->q[x] is passed to intr handler to know which queue */
         u8 q[MAX_REPLY_QUEUES];
         u32 TMFSupportFlags; /* cache what task mgmt funcs are supported. */
@@ -237,8 +250,9 @@ struct ctlr_info {
         spinlock_t offline_device_lock;
         struct list_head offline_device_list;
         int     acciopath_status;
-        int     drv_req_rescan; /* flag for driver to request rescan event */
         int     raid_offload_debug;
+        struct workqueue_struct *resubmit_wq;
+        struct workqueue_struct *rescan_ctlr_wq;
 };
 
 struct offline_device_entry {
@@ -297,6 +311,8 @@ struct offline_device_entry {
  */
 #define SA5_DOORBELL    0x20
 #define SA5_REQUEST_PORT_OFFSET 0x40
+#define SA5_REQUEST_PORT64_LO_OFFSET 0xC0
+#define SA5_REQUEST_PORT64_HI_OFFSET 0xC4
 #define SA5_REPLY_INTR_MASK_OFFSET      0x34
 #define SA5_REPLY_PORT_OFFSET           0x44
 #define SA5_INTR_STATUS         0x30
@@ -353,10 +369,7 @@ static void SA5_submit_command_no_read(struct ctlr_info *h,
 static void SA5_submit_command_ioaccel2(struct ctlr_info *h,
         struct CommandList *c)
 {
-        if (c->cmd_type == CMD_IOACCEL2)
-                writel(c->busaddr, h->vaddr + IOACCEL2_INBOUND_POSTQ_32);
-        else
-                writel(c->busaddr, h->vaddr + SA5_REQUEST_PORT_OFFSET);
+        writel(c->busaddr, h->vaddr + SA5_REQUEST_PORT_OFFSET);
 }
 
 /*
@@ -398,19 +411,19 @@ static unsigned long SA5_performant_completed(struct ctlr_info *h, u8 q)
         unsigned long register_value = FIFO_EMPTY;
 
         /* msi auto clears the interrupt pending bit. */
-        if (!(h->msi_vector || h->msix_vector)) {
+        if (unlikely(!(h->msi_vector || h->msix_vector))) {
                 /* flush the controller write of the reply queue by reading
                  * outbound doorbell status register.
                  */
-                register_value = readl(h->vaddr + SA5_OUTDB_STATUS);
+                (void) readl(h->vaddr + SA5_OUTDB_STATUS);
                 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);
+                (void) readl(h->vaddr + SA5_OUTDB_STATUS);
         }
 
-        if ((rq->head[rq->current_entry] & 1) == rq->wraparound) {
+        if ((((u32) rq->head[rq->current_entry]) & 1) == rq->wraparound) {
                 register_value = rq->head[rq->current_entry];
                 rq->current_entry++;
                 atomic_dec(&h->commands_outstanding);
@@ -426,14 +439,6 @@ static unsigned long SA5_performant_completed(struct ctlr_info *h, u8 q)
 }
 
 /*
- *  Returns true if fifo is full.
- *
- */
-static unsigned long SA5_fifo_full(struct ctlr_info *h)
-{
-        return atomic_read(&h->commands_outstanding) >= h->max_commands;
-}
-/*
  *   returns value read from hardware.
  *     returns FIFO_EMPTY if there is nothing to read
  */
@@ -473,9 +478,6 @@ static bool SA5_performant_intr_pending(struct ctlr_info *h)
         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;
@@ -525,7 +527,6 @@ static unsigned long SA5_ioaccel_mode1_completed(struct ctlr_info *h, u8 q)
 static struct access_method SA5_access = {
         SA5_submit_command,
         SA5_intr_mask,
-        SA5_fifo_full,
         SA5_intr_pending,
         SA5_completed,
 };
@@ -533,7 +534,6 @@ static struct access_method SA5_access = {
 static struct access_method SA5_ioaccel_mode1_access = {
         SA5_submit_command,
         SA5_performant_intr_mask,
-        SA5_fifo_full,
         SA5_ioaccel_mode1_intr_pending,
         SA5_ioaccel_mode1_completed,
 };
@@ -541,7 +541,6 @@ static struct access_method SA5_ioaccel_mode1_access = {
 static struct access_method SA5_ioaccel_mode2_access = {
         SA5_submit_command_ioaccel2,
         SA5_performant_intr_mask,
-        SA5_fifo_full,
         SA5_performant_intr_pending,
         SA5_performant_completed,
 };
@@ -549,7 +548,6 @@ static struct access_method SA5_ioaccel_mode2_access = {
 static struct access_method SA5_performant_access = {
         SA5_submit_command,
         SA5_performant_intr_mask,
-        SA5_fifo_full,
         SA5_performant_intr_pending,
         SA5_performant_completed,
 };
@@ -557,7 +555,6 @@ static struct access_method SA5_performant_access = {
 static struct access_method SA5_performant_access_no_read = {
         SA5_submit_command_no_read,
         SA5_performant_intr_mask,
-        SA5_fifo_full,
         SA5_performant_intr_pending,
         SA5_performant_completed,
 };
diff --git a/drivers/scsi/hpsa_cmd.h b/drivers/scsi/hpsa_cmd.h
index cb988c41cad9..3a621c74b76f 100644
--- a/drivers/scsi/hpsa_cmd.h
+++ b/drivers/scsi/hpsa_cmd.h
@@ -206,27 +206,27 @@ struct raid_map_disk_data {
 };
 
 struct raid_map_data {
-        u32   structure_size;           /* Size of entire structure in bytes */
-        u32   volume_blk_size;          /* bytes / block in the volume */
-        u64   volume_blk_cnt;           /* logical blocks on the volume */
+        __le32   structure_size;        /* Size of entire structure in bytes */
+        __le32   volume_blk_size;       /* bytes / block in the volume */
+        __le64   volume_blk_cnt;        /* logical blocks on the volume */
         u8    phys_blk_shift;           /* Shift factor to convert between
                                          * units of logical blocks and physical
                                          * disk blocks */
         u8    parity_rotation_shift;    /* Shift factor to convert between units
                                          * of logical stripes and physical
                                          * stripes */
-        u16   strip_size;               /* blocks used on each disk / stripe */
-        u64   disk_starting_blk;        /* First disk block used in volume */
-        u64   disk_blk_cnt;             /* disk blocks used by volume / disk */
-        u16   data_disks_per_row;       /* data disk entries / row in the map */
-        u16   metadata_disks_per_row;   /* mirror/parity disk entries / row
+        __le16   strip_size;            /* blocks used on each disk / stripe */
+        __le64   disk_starting_blk;     /* First disk block used in volume */
+        __le64   disk_blk_cnt;          /* disk blocks used by volume / disk */
+        __le16   data_disks_per_row;    /* data disk entries / row in the map */
+        __le16   metadata_disks_per_row;/* mirror/parity disk entries / row
                                          * in the map */
-        u16   row_cnt;                  /* rows in each layout map */
-        u16   layout_map_count;         /* layout maps (1 map per mirror/parity
+        __le16   row_cnt;               /* rows in each layout map */
+        __le16   layout_map_count;      /* layout maps (1 map per mirror/parity
                                          * group) */
-        u16   flags;                    /* Bit 0 set if encryption enabled */
+        __le16   flags;                 /* Bit 0 set if encryption enabled */
 #define RAID_MAP_FLAG_ENCRYPT_ON  0x01
-        u16   dekindex;                 /* Data encryption key index. */
+        __le16   dekindex;              /* Data encryption key index. */
         u8    reserved[16];
         struct raid_map_disk_data data[RAID_MAP_MAX_ENTRIES];
 };
@@ -240,6 +240,10 @@ struct ReportLUNdata {
 
 struct ext_report_lun_entry {
         u8 lunid[8];
+#define GET_BMIC_BUS(lunid) ((lunid)[7] & 0x3F)
+#define GET_BMIC_LEVEL_TWO_TARGET(lunid) ((lunid)[6])
+#define GET_BMIC_DRIVE_NUMBER(lunid) (((GET_BMIC_BUS((lunid)) - 1) << 8) + \
+                        GET_BMIC_LEVEL_TWO_TARGET((lunid)))
         u8 wwid[8];
         u8 device_type;
         u8 device_flags;
@@ -268,6 +272,7 @@ struct SenseSubsystem_info {
 #define HPSA_CACHE_FLUSH 0x01   /* C2 was already being used by HPSA */
 #define BMIC_FLASH_FIRMWARE 0xF7
 #define BMIC_SENSE_CONTROLLER_PARAMETERS 0x64
+#define BMIC_IDENTIFY_PHYSICAL_DEVICE 0x15
 
 /* Command List Structure */
 union SCSI3Addr {
@@ -313,8 +318,8 @@ union LUNAddr {
 struct CommandListHeader {
         u8              ReplyQueue;
         u8              SGList;
-        u16             SGTotal;
-        u64             tag;
+        __le16          SGTotal;
+        __le64          tag;
         union LUNAddr     LUN;
 };
 
@@ -338,14 +343,14 @@ struct RequestBlock {
 };
 
 struct ErrDescriptor {
-        u64 Addr;
-        u32  Len;
+        __le64 Addr;
+        __le32 Len;
 };
 
 struct SGDescriptor {
-        u64 Addr;
-        u32  Len;
-        u32  Ext;
+        __le64 Addr;
+        __le32 Len;
+        __le32 Ext;
 };
 
 union MoreErrInfo {
@@ -375,22 +380,19 @@ struct ErrorInfo {
 #define CMD_IOACCEL1    0x04
 #define CMD_IOACCEL2    0x05
 
-#define DIRECT_LOOKUP_SHIFT 5
-#define DIRECT_LOOKUP_BIT 0x10
+#define DIRECT_LOOKUP_SHIFT 4
 #define DIRECT_LOOKUP_MASK (~((1 << DIRECT_LOOKUP_SHIFT) - 1))
 
 #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
+/* The size of this structure needs to be divisible by 128
+ * on all architectures.  The low 4 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.
  */
 
 #define COMMANDLIST_ALIGNMENT 128
@@ -405,9 +407,21 @@ struct CommandList {
         struct ctlr_info           *h;
         int                        cmd_type;
         long                       cmdindex;
-        struct list_head list;
         struct completion *waiting;
-        void   *scsi_cmd;
+        struct scsi_cmnd *scsi_cmd;
+        struct work_struct work;
+
+        /*
+         * For commands using either of the two "ioaccel" paths to
+         * bypass the RAID stack and go directly to the physical disk
+         * phys_disk is a pointer to the hpsa_scsi_dev_t to which the
+         * i/o is destined.  We need to store that here because the command
+         * may potentially encounter TASK SET FULL and need to be resubmitted
+         * For "normal" i/o's not using the "ioaccel" paths, phys_disk is
+         * not used.
+         */
+        struct hpsa_scsi_dev_t *phys_disk;
+        atomic_t refcount; /* Must be last to avoid memset in cmd_alloc */
 } __aligned(COMMANDLIST_ALIGNMENT);
 
 /* Max S/G elements in I/O accelerator command */
@@ -420,7 +434,7 @@ struct CommandList {
  */
 #define IOACCEL1_COMMANDLIST_ALIGNMENT 128
 struct io_accel1_cmd {
-        u16 dev_handle;                 /* 0x00 - 0x01 */
+        __le16 dev_handle;              /* 0x00 - 0x01 */
         u8  reserved1;                  /* 0x02 */
         u8  function;                   /* 0x03 */
         u8  reserved2[8];               /* 0x04 - 0x0B */
@@ -430,20 +444,20 @@ struct io_accel1_cmd {
         u8  reserved4;                  /* 0x13 */
         u8  sgl_offset;                 /* 0x14 */
         u8  reserved5[7];               /* 0x15 - 0x1B */
-        u32 transfer_len;               /* 0x1C - 0x1F */
+        __le32 transfer_len;            /* 0x1C - 0x1F */
         u8  reserved6[4];               /* 0x20 - 0x23 */
-        u16 io_flags;                   /* 0x24 - 0x25 */
+        __le16 io_flags;                /* 0x24 - 0x25 */
         u8  reserved7[14];              /* 0x26 - 0x33 */
         u8  LUN[8];                     /* 0x34 - 0x3B */
-        u32 control;                    /* 0x3C - 0x3F */
+        __le32 control;                 /* 0x3C - 0x3F */
         u8  CDB[16];                    /* 0x40 - 0x4F */
         u8  reserved8[16];              /* 0x50 - 0x5F */
-        u16 host_context_flags;         /* 0x60 - 0x61 */
-        u16 timeout_sec;                /* 0x62 - 0x63 */
+        __le16 host_context_flags;      /* 0x60 - 0x61 */
+        __le16 timeout_sec;             /* 0x62 - 0x63 */
         u8  ReplyQueue;                 /* 0x64 */
         u8  reserved9[3];               /* 0x65 - 0x67 */
-        u64 tag;                        /* 0x68 - 0x6F */
-        u64 host_addr;                  /* 0x70 - 0x77 */
+        __le64 tag;                     /* 0x68 - 0x6F */
+        __le64 host_addr;               /* 0x70 - 0x77 */
         u8  CISS_LUN[8];                /* 0x78 - 0x7F */
         struct SGDescriptor SG[IOACCEL1_MAXSGENTRIES];
 } __aligned(IOACCEL1_COMMANDLIST_ALIGNMENT);
@@ -470,8 +484,8 @@ struct io_accel1_cmd {
 #define IOACCEL1_BUSADDR_CMDTYPE        0x00000060
 
 struct ioaccel2_sg_element {
-        u64 address;
-        u32 length;
+        __le64 address;
+        __le32 length;
         u8 reserved[3];
         u8 chain_indicator;
 #define IOACCEL2_CHAIN 0x80
@@ -526,20 +540,20 @@ struct io_accel2_cmd {
                                              /*     0=off, 1=on */
         u8  reply_queue;                /* Reply Queue ID */
         u8  reserved1;                  /* Reserved */
-        u32 scsi_nexus;                 /* Device Handle */
-        u32 Tag;                        /* cciss tag, lower 4 bytes only */
-        u32 tweak_lower;                /* Encryption tweak, lower 4 bytes */
+        __le32 scsi_nexus;              /* Device Handle */
+        __le32 Tag;                     /* cciss tag, lower 4 bytes only */
+        __le32 tweak_lower;             /* Encryption tweak, lower 4 bytes */
         u8  cdb[16];                    /* SCSI Command Descriptor Block */
         u8  cciss_lun[8];               /* 8 byte SCSI address */
-        u32 data_len;                   /* Total bytes to transfer */
+        __le32 data_len;                /* Total bytes to transfer */
         u8  cmd_priority_task_attr;     /* priority and task attrs */
 #define IOACCEL2_PRIORITY_MASK 0x78
 #define IOACCEL2_ATTR_MASK 0x07
         u8  sg_count;                   /* Number of sg elements */
-        u16 dekindex;                   /* Data encryption key index */
-        u64 err_ptr;                    /* Error Pointer */
-        u32 err_len;                    /* Error Length*/
-        u32 tweak_upper;                /* Encryption tweak, upper 4 bytes */
+        __le16 dekindex;                /* Data encryption key index */
+        __le64 err_ptr;                 /* Error Pointer */
+        __le32 err_len;                 /* Error Length*/
+        __le32 tweak_upper;             /* Encryption tweak, upper 4 bytes */
         struct ioaccel2_sg_element sg[IOACCEL2_MAXSGENTRIES];
         struct io_accel2_scsi_response error_data;
 } __aligned(IOACCEL2_COMMANDLIST_ALIGNMENT);
@@ -563,18 +577,18 @@ struct hpsa_tmf_struct {
         u8 reserved1;           /* byte 3 Reserved */
         u32 it_nexus;           /* SCSI I-T Nexus */
         u8 lun_id[8];           /* LUN ID for TMF request */
-        u64 tag;                /* cciss tag associated w/ request */
-        u64 abort_tag;          /* cciss tag of SCSI cmd or task to abort */
-        u64 error_ptr;          /* Error Pointer */
-        u32 error_len;          /* Error Length */
+        __le64 tag;             /* cciss tag associated w/ request */
+        __le64 abort_tag;       /* cciss tag of SCSI cmd or TMF to abort */
+        __le64 error_ptr;               /* Error Pointer */
+        __le32 error_len;               /* Error Length */
 };
 
 /* Configuration Table Structure */
 struct HostWrite {
-        u32 TransportRequest;
-        u32 command_pool_addr_hi;
-        u32 CoalIntDelay;
-        u32 CoalIntCount;
+        __le32          TransportRequest;
+        __le32          command_pool_addr_hi;
+        __le32          CoalIntDelay;
+        __le32          CoalIntCount;
 };
 
 #define SIMPLE_MODE     0x02
@@ -585,54 +599,54 @@ struct HostWrite {
 #define DRIVER_SUPPORT_UA_ENABLE        0x00000001
 
 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           driver_support;
-#define                 ENABLE_SCSI_PREFETCH 0x100
-#define                 ENABLE_UNIT_ATTN 0x01
-        u32             MaxScatterGatherElements;
-        u32             MaxLogicalUnits;
-        u32             MaxPhysicalDevices;
-        u32             MaxPhysicalDrivesPerLogicalUnit;
-        u32             MaxPerformantModeCommands;
-        u32             MaxBlockFetch;
-        u32             PowerConservationSupport;
-        u32             PowerConservationEnable;
-        u32             TMFSupportFlags;
+        u8              Signature[4];
+        __le32          SpecValence;
+        __le32          TransportSupport;
+        __le32          TransportActive;
+        struct HostWrite HostWrite;
+        __le32          CmdsOutMax;
+        __le32          BusTypes;
+        __le32          TransMethodOffset;
+        u8              ServerName[16];
+        __le32          HeartBeat;
+        __le32          driver_support;
+#define                 ENABLE_SCSI_PREFETCH            0x100
+#define                 ENABLE_UNIT_ATTN                0x01
+        __le32          MaxScatterGatherElements;
+        __le32          MaxLogicalUnits;
+        __le32          MaxPhysicalDevices;
+        __le32          MaxPhysicalDrivesPerLogicalUnit;
+        __le32          MaxPerformantModeCommands;
+        __le32          MaxBlockFetch;
+        __le32          PowerConservationSupport;
+        __le32          PowerConservationEnable;
+        __le32          TMFSupportFlags;
         u8              TMFTagMask[8];
         u8              reserved[0x78 - 0x70];
-        u32             misc_fw_support; /* offset 0x78 */
-#define                 MISC_FW_DOORBELL_RESET (0x02)
-#define                 MISC_FW_DOORBELL_RESET2 (0x010)
-#define                 MISC_FW_RAID_OFFLOAD_BASIC (0x020)
-#define                 MISC_FW_EVENT_NOTIFY (0x080)
+        __le32          misc_fw_support;                /* offset 0x78 */
+#define                 MISC_FW_DOORBELL_RESET          0x02
+#define                 MISC_FW_DOORBELL_RESET2         0x010
+#define                 MISC_FW_RAID_OFFLOAD_BASIC      0x020
+#define                 MISC_FW_EVENT_NOTIFY            0x080
         u8              driver_version[32];
-        u32             max_cached_write_size;
-        u8              driver_scratchpad[16];
-        u32             max_error_info_length;
-        u32             io_accel_max_embedded_sg_count;
-        u32             io_accel_request_size_offset;
-        u32             event_notify;
-#define HPSA_EVENT_NOTIFY_ACCEL_IO_PATH_STATE_CHANGE (1 << 30)
-#define HPSA_EVENT_NOTIFY_ACCEL_IO_PATH_CONFIG_CHANGE (1 << 31)
-        u32             clear_event_notify;
+        __le32          max_cached_write_size;
+        u8              driver_scratchpad[16];
+        __le32          max_error_info_length;
+        __le32          io_accel_max_embedded_sg_count;
+        __le32          io_accel_request_size_offset;
+        __le32          event_notify;
+#define         HPSA_EVENT_NOTIFY_ACCEL_IO_PATH_STATE_CHANGE (1 << 30)
+#define         HPSA_EVENT_NOTIFY_ACCEL_IO_PATH_CONFIG_CHANGE (1 << 31)
+        __le32          clear_event_notify;
 };
 
 #define NUM_BLOCKFETCH_ENTRIES 8
 struct TransTable_struct {
-        u32            BlockFetch[NUM_BLOCKFETCH_ENTRIES];
-        u32            RepQSize;
-        u32            RepQCount;
-        u32            RepQCtrAddrLow32;
-        u32            RepQCtrAddrHigh32;
+        __le32          BlockFetch[NUM_BLOCKFETCH_ENTRIES];
+        __le32          RepQSize;
+        __le32          RepQCount;
+        __le32          RepQCtrAddrLow32;
+        __le32          RepQCtrAddrHigh32;
 #define MAX_REPLY_QUEUES 64
         struct vals32  RepQAddr[MAX_REPLY_QUEUES];
 };
@@ -644,5 +658,137 @@ struct hpsa_pci_info {
         u32             board_id;
 };
 
+struct bmic_identify_physical_device {
+        u8    scsi_bus;          /* SCSI Bus number on controller */
+        u8    scsi_id;           /* SCSI ID on this bus */
+        __le16 block_size;           /* sector size in bytes */
+        __le32 total_blocks;         /* number for sectors on drive */
+        __le32 reserved_blocks;   /* controller reserved (RIS) */
+        u8    model[40];         /* Physical Drive Model */
+        u8    serial_number[40]; /* Drive Serial Number */
+        u8    firmware_revision[8]; /* drive firmware revision */
+        u8    scsi_inquiry_bits; /* inquiry byte 7 bits */
+        u8    compaq_drive_stamp; /* 0 means drive not stamped */
+        u8    last_failure_reason;
+#define BMIC_LAST_FAILURE_TOO_SMALL_IN_LOAD_CONFIG              0x01
+#define BMIC_LAST_FAILURE_ERROR_ERASING_RIS                     0x02
+#define BMIC_LAST_FAILURE_ERROR_SAVING_RIS                      0x03
+#define BMIC_LAST_FAILURE_FAIL_DRIVE_COMMAND                    0x04
+#define BMIC_LAST_FAILURE_MARK_BAD_FAILED                       0x05
+#define BMIC_LAST_FAILURE_MARK_BAD_FAILED_IN_FINISH_REMAP       0x06
+#define BMIC_LAST_FAILURE_TIMEOUT                               0x07
+#define BMIC_LAST_FAILURE_AUTOSENSE_FAILED                      0x08
+#define BMIC_LAST_FAILURE_MEDIUM_ERROR_1                        0x09
+#define BMIC_LAST_FAILURE_MEDIUM_ERROR_2                        0x0a
+#define BMIC_LAST_FAILURE_NOT_READY_BAD_SENSE                   0x0b
+#define BMIC_LAST_FAILURE_NOT_READY                             0x0c
+#define BMIC_LAST_FAILURE_HARDWARE_ERROR                        0x0d
+#define BMIC_LAST_FAILURE_ABORTED_COMMAND                       0x0e
+#define BMIC_LAST_FAILURE_WRITE_PROTECTED                       0x0f
+#define BMIC_LAST_FAILURE_SPIN_UP_FAILURE_IN_RECOVER            0x10
+#define BMIC_LAST_FAILURE_REBUILD_WRITE_ERROR                   0x11
+#define BMIC_LAST_FAILURE_TOO_SMALL_IN_HOT_PLUG                 0x12
+#define BMIC_LAST_FAILURE_BUS_RESET_RECOVERY_ABORTED            0x13
+#define BMIC_LAST_FAILURE_REMOVED_IN_HOT_PLUG                   0x14
+#define BMIC_LAST_FAILURE_INIT_REQUEST_SENSE_FAILED             0x15
+#define BMIC_LAST_FAILURE_INIT_START_UNIT_FAILED                0x16
+#define BMIC_LAST_FAILURE_INQUIRY_FAILED                        0x17
+#define BMIC_LAST_FAILURE_NON_DISK_DEVICE                       0x18
+#define BMIC_LAST_FAILURE_READ_CAPACITY_FAILED                  0x19
+#define BMIC_LAST_FAILURE_INVALID_BLOCK_SIZE                    0x1a
+#define BMIC_LAST_FAILURE_HOT_PLUG_REQUEST_SENSE_FAILED         0x1b
+#define BMIC_LAST_FAILURE_HOT_PLUG_START_UNIT_FAILED            0x1c
+#define BMIC_LAST_FAILURE_WRITE_ERROR_AFTER_REMAP               0x1d
+#define BMIC_LAST_FAILURE_INIT_RESET_RECOVERY_ABORTED           0x1e
+#define BMIC_LAST_FAILURE_DEFERRED_WRITE_ERROR                  0x1f
+#define BMIC_LAST_FAILURE_MISSING_IN_SAVE_RIS                   0x20
+#define BMIC_LAST_FAILURE_WRONG_REPLACE                         0x21
+#define BMIC_LAST_FAILURE_GDP_VPD_INQUIRY_FAILED                0x22
+#define BMIC_LAST_FAILURE_GDP_MODE_SENSE_FAILED                 0x23
+#define BMIC_LAST_FAILURE_DRIVE_NOT_IN_48BIT_MODE               0x24
+#define BMIC_LAST_FAILURE_DRIVE_TYPE_MIX_IN_HOT_PLUG            0x25
+#define BMIC_LAST_FAILURE_DRIVE_TYPE_MIX_IN_LOAD_CFG            0x26
+#define BMIC_LAST_FAILURE_PROTOCOL_ADAPTER_FAILED               0x27
+#define BMIC_LAST_FAILURE_FAULTY_ID_BAY_EMPTY                   0x28
+#define BMIC_LAST_FAILURE_FAULTY_ID_BAY_OCCUPIED                0x29
+#define BMIC_LAST_FAILURE_FAULTY_ID_INVALID_BAY                 0x2a
+#define BMIC_LAST_FAILURE_WRITE_RETRIES_FAILED                  0x2b
+
+#define BMIC_LAST_FAILURE_SMART_ERROR_REPORTED                  0x37
+#define BMIC_LAST_FAILURE_PHY_RESET_FAILED                      0x38
+#define BMIC_LAST_FAILURE_ONLY_ONE_CTLR_CAN_SEE_DRIVE           0x40
+#define BMIC_LAST_FAILURE_KC_VOLUME_FAILED                      0x41
+#define BMIC_LAST_FAILURE_UNEXPECTED_REPLACEMENT                0x42
+#define BMIC_LAST_FAILURE_OFFLINE_ERASE                         0x80
+#define BMIC_LAST_FAILURE_OFFLINE_TOO_SMALL                     0x81
+#define BMIC_LAST_FAILURE_OFFLINE_DRIVE_TYPE_MIX                0x82
+#define BMIC_LAST_FAILURE_OFFLINE_ERASE_COMPLETE                0x83
+
+        u8     flags;
+        u8     more_flags;
+        u8     scsi_lun;          /* SCSI LUN for phys drive */
+        u8     yet_more_flags;
+        u8     even_more_flags;
+        __le32 spi_speed_rules;/* SPI Speed data:Ultra disable diagnose */
+        u8     phys_connector[2];         /* connector number on controller */
+        u8     phys_box_on_bus;  /* phys enclosure this drive resides */
+        u8     phys_bay_in_box;  /* phys drv bay this drive resides */
+        __le32 rpm;              /* Drive rotational speed in rpm */
+        u8     device_type;       /* type of drive */
+        u8     sata_version;     /* only valid when drive_type is SATA */
+        __le64 big_total_block_count;
+        __le64 ris_starting_lba;
+        __le32 ris_size;
+        u8     wwid[20];
+        u8     controller_phy_map[32];
+        __le16 phy_count;
+        u8     phy_connected_dev_type[256];
+        u8     phy_to_drive_bay_num[256];
+        __le16 phy_to_attached_dev_index[256];
+        u8     box_index;
+        u8     reserved;
+        __le16 extra_physical_drive_flags;
+#define BMIC_PHYS_DRIVE_SUPPORTS_GAS_GAUGE(idphydrv) \
+        (idphydrv->extra_physical_drive_flags & (1 << 10))
+        u8     negotiated_link_rate[256];
+        u8     phy_to_phy_map[256];
+        u8     redundant_path_present_map;
+        u8     redundant_path_failure_map;
+        u8     active_path_number;
+        __le16 alternate_paths_phys_connector[8];
+        u8     alternate_paths_phys_box_on_port[8];
+        u8     multi_lun_device_lun_count;
+        u8     minimum_good_fw_revision[8];
+        u8     unique_inquiry_bytes[20];
+        u8     current_temperature_degreesC;
+        u8     temperature_threshold_degreesC;
+        u8     max_temperature_degreesC;
+        u8     logical_blocks_per_phys_block_exp; /* phyblocksize = 512*2^exp */
+        __le16 current_queue_depth_limit;
+        u8     switch_name[10];
+        __le16 switch_port;
+        u8     alternate_paths_switch_name[40];
+        u8     alternate_paths_switch_port[8];
+        __le16 power_on_hours; /* valid only if gas gauge supported */
+        __le16 percent_endurance_used; /* valid only if gas gauge supported. */
+#define BMIC_PHYS_DRIVE_SSD_WEAROUT(idphydrv) \
+        ((idphydrv->percent_endurance_used & 0x80) || \
+         (idphydrv->percent_endurance_used > 10000))
+        u8     drive_authentication;
+#define BMIC_PHYS_DRIVE_AUTHENTICATED(idphydrv) \
+        (idphydrv->drive_authentication == 0x80)
+        u8     smart_carrier_authentication;
+#define BMIC_SMART_CARRIER_AUTHENTICATION_SUPPORTED(idphydrv) \
+        (idphydrv->smart_carrier_authentication != 0x0)
+#define BMIC_SMART_CARRIER_AUTHENTICATED(idphydrv) \
+        (idphydrv->smart_carrier_authentication == 0x01)
+        u8     smart_carrier_app_fw_version;
+        u8     smart_carrier_bootloader_fw_version;
+        u8     encryption_key_name[64];
+        __le32 misc_drive_flags;
+        __le16 dek_index;
+        u8     padding[112];
+};
+
 #pragma pack()
 #endif /* HPSA_CMD_H */
diff --git a/drivers/scsi/in2000.c b/drivers/scsi/in2000.c
index ddf0694d87f0..3882d9f519c8 100644
--- a/drivers/scsi/in2000.c
+++ b/drivers/scsi/in2000.c
@@ -2226,36 +2226,36 @@ static int in2000_show_info(struct seq_file *m, struct Scsi_Host *instance)
 
         if (hd->proc & PR_INFO) {
                 seq_printf(m, "\ndip_switch=%02x: irq=%d io=%02x floppy=%s sync/DOS5=%s", (hd->dip_switch & 0x7f), instance->irq, hd->io_base, (hd->dip_switch & 0x40) ? "Yes" : "No", (hd->dip_switch & 0x20) ? "Yes" : "No");
-                seq_printf(m, "\nsync_xfer[] =       ");
+                seq_puts(m, "\nsync_xfer[] =       ");
                 for (x = 0; x < 7; x++)
                         seq_printf(m, "\t%02x", hd->sync_xfer[x]);
-                seq_printf(m, "\nsync_stat[] =       ");
+                seq_puts(m, "\nsync_stat[] =       ");
                 for (x = 0; x < 7; x++)
                         seq_printf(m, "\t%02x", hd->sync_stat[x]);
         }
 #ifdef PROC_STATISTICS
         if (hd->proc & PR_STATISTICS) {
-                seq_printf(m, "\ncommands issued:    ");
+                seq_puts(m, "\ncommands issued:    ");
                 for (x = 0; x < 7; x++)
                         seq_printf(m, "\t%ld", hd->cmd_cnt[x]);
-                seq_printf(m, "\ndisconnects allowed:");
+                seq_puts(m, "\ndisconnects allowed:");
                 for (x = 0; x < 7; x++)
                         seq_printf(m, "\t%ld", hd->disc_allowed_cnt[x]);
-                seq_printf(m, "\ndisconnects done:   ");
+                seq_puts(m, "\ndisconnects done:   ");
                 for (x = 0; x < 7; x++)
                         seq_printf(m, "\t%ld", hd->disc_done_cnt[x]);
                 seq_printf(m, "\ninterrupts:      \t%ld", hd->int_cnt);
         }
 #endif
         if (hd->proc & PR_CONNECTED) {
-                seq_printf(m, "\nconnected:     ");
+                seq_puts(m, "\nconnected:     ");
                 if (hd->connected) {
                         cmd = (Scsi_Cmnd *) hd->connected;
                         seq_printf(m, " %d:%llu(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
                 }
         }
         if (hd->proc & PR_INPUTQ) {
-                seq_printf(m, "\ninput_Q:       ");
+                seq_puts(m, "\ninput_Q:       ");
                 cmd = (Scsi_Cmnd *) hd->input_Q;
                 while (cmd) {
                         seq_printf(m, " %d:%llu(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
@@ -2263,7 +2263,7 @@ static int in2000_show_info(struct seq_file *m, struct Scsi_Host *instance)
                 }
         }
         if (hd->proc & PR_DISCQ) {
-                seq_printf(m, "\ndisconnected_Q:");
+                seq_puts(m, "\ndisconnected_Q:");
                 cmd = (Scsi_Cmnd *) hd->disconnected_Q;
                 while (cmd) {
                         seq_printf(m, " %d:%llu(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
@@ -2273,7 +2273,7 @@ static int in2000_show_info(struct seq_file *m, struct Scsi_Host *instance)
         if (hd->proc & PR_TEST) {
                 ;               /* insert your own custom function here */
         }
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
         spin_unlock_irqrestore(instance->host_lock, flags);
 #endif                          /* PROC_INTERFACE */
         return 0;
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 9219953ee949..d9afc51af7d3 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -6815,7 +6815,8 @@ static struct ata_port_operations ipr_sata_ops = {
 };
 
 static struct ata_port_info sata_port_info = {
-        .flags          = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA,
+        .flags          = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA |
+                          ATA_FLAG_SAS_HOST,
         .pio_mask       = ATA_PIO4_ONLY,
         .mwdma_mask     = ATA_MWDMA2,
         .udma_mask      = ATA_UDMA6,
diff --git a/drivers/scsi/ips.c b/drivers/scsi/ips.c
index e5c28435d768..7542f11d3fcd 100644
--- a/drivers/scsi/ips.c
+++ b/drivers/scsi/ips.c
@@ -2038,15 +2038,14 @@ ips_host_info(ips_ha_t *ha, struct seq_file *m)
 {
         METHOD_TRACE("ips_host_info", 1);
 
-        seq_printf(m, "\nIBM ServeRAID General Information:\n\n");
+        seq_puts(m, "\nIBM ServeRAID General Information:\n\n");
 
         if ((le32_to_cpu(ha->nvram->signature) == IPS_NVRAM_P5_SIG) &&
             (le16_to_cpu(ha->nvram->adapter_type) != 0))
                 seq_printf(m, "\tController Type                   : %s\n",
                           ips_adapter_name[ha->ad_type - 1]);
         else
-                seq_printf(m,
-                          "\tController Type                   : Unknown\n");
+                seq_puts(m, "\tController Type                   : Unknown\n");
 
         if (ha->io_addr)
                 seq_printf(m,
@@ -2138,7 +2137,7 @@ ips_host_info(ips_ha_t *ha, struct seq_file *m)
         seq_printf(m, "\tCurrent Active PT Commands        : %d\n",
                   ha->num_ioctl);
 
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
 
         return 0;
 }
diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
index 932d9cc98d2f..9c706d8c1441 100644
--- a/drivers/scsi/libsas/sas_ata.c
+++ b/drivers/scsi/libsas/sas_ata.c
@@ -547,7 +547,8 @@ static struct ata_port_operations sas_sata_ops = {
 };
 
 static struct ata_port_info sata_port_info = {
-        .flags = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA | ATA_FLAG_NCQ,
+        .flags = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA | ATA_FLAG_NCQ |
+                 ATA_FLAG_SAS_HOST,
         .pio_mask = ATA_PIO4,
         .mwdma_mask = ATA_MWDMA2,
         .udma_mask = ATA_UDMA6,
diff --git a/drivers/scsi/libsas/sas_discover.c b/drivers/scsi/libsas/sas_discover.c
index 62b58d38ce2e..60de66252fa2 100644
--- a/drivers/scsi/libsas/sas_discover.c
+++ b/drivers/scsi/libsas/sas_discover.c
@@ -500,6 +500,7 @@ static void sas_revalidate_domain(struct work_struct *work)
         struct sas_discovery_event *ev = to_sas_discovery_event(work);
         struct asd_sas_port *port = ev->port;
         struct sas_ha_struct *ha = port->ha;
+        struct domain_device *ddev = port->port_dev;
 
         /* prevent revalidation from finding sata links in recovery */
         mutex_lock(&ha->disco_mutex);
@@ -514,8 +515,9 @@ static void sas_revalidate_domain(struct work_struct *work)
         SAS_DPRINTK("REVALIDATING DOMAIN on port %d, pid:%d\n", port->id,
                     task_pid_nr(current));
 
-        if (port->port_dev)
-                res = sas_ex_revalidate_domain(port->port_dev);
+        if (ddev && (ddev->dev_type == SAS_FANOUT_EXPANDER_DEVICE ||
+                     ddev->dev_type == SAS_EDGE_EXPANDER_DEVICE))
+                res = sas_ex_revalidate_domain(ddev);
 
         SAS_DPRINTK("done REVALIDATING DOMAIN on port %d, pid:%d, res 0x%x\n",
                     port->id, task_pid_nr(current), res);
diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
index 4c25485aa934..c66088d0fd2a 100644
--- a/drivers/scsi/lpfc/lpfc_els.c
+++ b/drivers/scsi/lpfc/lpfc_els.c
@@ -2225,6 +2225,15 @@ lpfc_adisc_done(struct lpfc_vport *vport)
         if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
             !(vport->fc_flag & FC_RSCN_MODE) &&
             (phba->sli_rev < LPFC_SLI_REV4)) {
+                /* The ADISCs are complete.  Doesn't matter if they
+                 * succeeded or failed because the ADISC completion
+                 * routine guarantees to call the state machine and
+                 * the RPI is either unregistered (failed ADISC response)
+                 * or the RPI is still valid and the node is marked
+                 * mapped for a target.  The exchanges should be in the
+                 * correct state. This code is specific to SLI3.
+                 */
+                lpfc_issue_clear_la(phba, vport);
                 lpfc_issue_reg_vpi(phba, vport);
                 return;
         }
diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index 2485255f3414..bc7b34c02723 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -2240,7 +2240,7 @@ proc_show_battery(struct seq_file *m, void *v)
                 goto free_pdev;
 
         if( mega_adapinq(adapter, dma_handle) != 0 ) {
-                seq_printf(m, "Adapter inquiry failed.\n");
+                seq_puts(m, "Adapter inquiry failed.\n");
                 printk(KERN_WARNING "megaraid: inquiry failed.\n");
                 goto free_inquiry;
         }
diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
index 0d44d91c2fce..14e5c7cea929 100644
--- a/drivers/scsi/megaraid/megaraid_sas.h
+++ b/drivers/scsi/megaraid/megaraid_sas.h
@@ -35,7 +35,7 @@
 /*
  * MegaRAID SAS Driver meta data
  */
-#define MEGASAS_VERSION                         "06.805.06.01-rc1"
+#define MEGASAS_VERSION                         "06.806.08.00-rc1"
 
 /*
  * Device IDs
@@ -969,7 +969,20 @@ struct megasas_ctrl_info {
 
         struct {
 #if defined(__BIG_ENDIAN_BITFIELD)
-                u32     reserved:25;
+                u32     reserved:12;
+                u32     discardCacheDuringLDDelete:1;
+                u32     supportSecurityonJBOD:1;
+                u32     supportCacheBypassModes:1;
+                u32     supportDisableSESMonitoring:1;
+                u32     supportForceFlash:1;
+                u32     supportNVDRAM:1;
+                u32     supportDrvActivityLEDSetting:1;
+                u32     supportAllowedOpsforDrvRemoval:1;
+                u32     supportHOQRebuild:1;
+                u32     supportForceTo512e:1;
+                u32     supportNVCacheErase:1;
+                u32     supportDebugQueue:1;
+                u32     supportSwZone:1;
                 u32     supportCrashDump:1;
                 u32     supportMaxExtLDs:1;
                 u32     supportT10RebuildAssist:1;
@@ -981,9 +994,22 @@ struct megasas_ctrl_info {
                 u32     supportThermalPollInterval:1;
                 u32     supportDisableImmediateIO:1;
                 u32     supportT10RebuildAssist:1;
-                u32     supportMaxExtLDs:1;
-                u32     supportCrashDump:1;
-                u32     reserved:25;
+                u32     supportMaxExtLDs:1;
+                u32     supportCrashDump:1;
+                u32     supportSwZone:1;
+                u32     supportDebugQueue:1;
+                u32     supportNVCacheErase:1;
+                u32     supportForceTo512e:1;
+                u32     supportHOQRebuild:1;
+                u32     supportAllowedOpsforDrvRemoval:1;
+                u32     supportDrvActivityLEDSetting:1;
+                u32     supportNVDRAM:1;
+                u32     supportForceFlash:1;
+                u32     supportDisableSESMonitoring:1;
+                u32     supportCacheBypassModes:1;
+                u32     supportSecurityonJBOD:1;
+                u32     discardCacheDuringLDDelete:1;
+                u32     reserved:12;
 #endif
         } adapterOperations3;
 
@@ -1022,6 +1048,13 @@ enum MR_MFI_MPT_PTHR_FLAGS {
         MFI_MPT_ATTACHED = 2,
 };
 
+enum MR_SCSI_CMD_TYPE {
+        READ_WRITE_LDIO = 0,
+        NON_READ_WRITE_LDIO = 1,
+        READ_WRITE_SYSPDIO = 2,
+        NON_READ_WRITE_SYSPDIO = 3,
+};
+
 /* Frame Type */
 #define IO_FRAME                                0
 #define PTHRU_FRAME                             1
@@ -1049,6 +1082,8 @@ enum MR_MFI_MPT_PTHR_FLAGS {
  */
 #define MEGASAS_INT_CMDS                        32
 #define MEGASAS_SKINNY_INT_CMDS                 5
+#define MEGASAS_FUSION_INTERNAL_CMDS            5
+#define MEGASAS_FUSION_IOCTL_CMDS               3
 
 #define MEGASAS_MAX_MSIX_QUEUES                 128
 /*
@@ -1194,19 +1229,23 @@ union megasas_sgl_frame {
 typedef union _MFI_CAPABILITIES {
         struct {
 #if   defined(__BIG_ENDIAN_BITFIELD)
-                u32     reserved:27;
+                u32     reserved:25;
+                u32     security_protocol_cmds_fw:1;
+                u32     support_core_affinity:1;
                 u32     support_ndrive_r1_lb:1;
                 u32     support_max_255lds:1;
-                u32     reserved1:1;
+                u32     support_fastpath_wb:1;
                 u32     support_additional_msix:1;
                 u32     support_fp_remote_lun:1;
 #else
                 u32     support_fp_remote_lun:1;
                 u32     support_additional_msix:1;
-                u32     reserved1:1;
+                u32     support_fastpath_wb:1;
                 u32     support_max_255lds:1;
                 u32     support_ndrive_r1_lb:1;
-                u32     reserved:27;
+                u32     support_core_affinity:1;
+                u32     security_protocol_cmds_fw:1;
+                u32     reserved:25;
 #endif
         } mfi_capabilities;
         u32     reg;
@@ -1638,20 +1677,20 @@ struct megasas_instance {
         u32 crash_dump_fw_support;
         u32 crash_dump_drv_support;
         u32 crash_dump_app_support;
+        u32 secure_jbod_support;
         spinlock_t crashdump_lock;
 
         struct megasas_register_set __iomem *reg_set;
         u32 *reply_post_host_index_addr[MR_MAX_MSIX_REG_ARRAY];
         struct megasas_pd_list          pd_list[MEGASAS_MAX_PD];
         struct megasas_pd_list          local_pd_list[MEGASAS_MAX_PD];
-        u8     ld_ids[MEGASAS_MAX_LD_IDS];
+        u8 ld_ids[MEGASAS_MAX_LD_IDS];
         s8 init_id;
 
         u16 max_num_sge;
         u16 max_fw_cmds;
-        /* For Fusion its num IOCTL cmds, for others MFI based its
-           max_fw_cmds */
         u16 max_mfi_cmds;
+        u16 max_scsi_cmds;
         u32 max_sectors_per_req;
         struct megasas_aen_event *ev;
 
@@ -1727,7 +1766,7 @@ struct megasas_instance {
         u8 requestorId;
         char PlasmaFW111;
         char mpio;
-        int throttlequeuedepth;
+        u16 throttlequeuedepth;
         u8 mask_interrupts;
         u8 is_imr;
 };
@@ -1946,5 +1985,6 @@ void __megasas_return_cmd(struct megasas_instance *instance,
 
 void megasas_return_mfi_mpt_pthr(struct megasas_instance *instance,
         struct megasas_cmd *cmd_mfi, struct megasas_cmd_fusion *cmd_fusion);
+int megasas_cmd_type(struct scsi_cmnd *cmd);
 
 #endif                          /*LSI_MEGARAID_SAS_H */
diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index ff283d23788a..890637fdd61e 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -78,7 +78,7 @@ static int allow_vf_ioctls;
 module_param(allow_vf_ioctls, int, S_IRUGO);
 MODULE_PARM_DESC(allow_vf_ioctls, "Allow ioctls in SR-IOV VF mode. Default: 0");
 
-static int throttlequeuedepth = MEGASAS_THROTTLE_QUEUE_DEPTH;
+static unsigned int throttlequeuedepth = MEGASAS_THROTTLE_QUEUE_DEPTH;
 module_param(throttlequeuedepth, int, S_IRUGO);
 MODULE_PARM_DESC(throttlequeuedepth,
         "Adapter queue depth when throttled due to I/O timeout. Default: 16");
@@ -1417,16 +1417,15 @@ megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
 }
 
 /**
- * megasas_is_ldio -            Checks if the cmd is for logical drive
+ * megasas_cmd_type -           Checks if the cmd is for logical drive/sysPD
+ *                              and whether it's RW or non RW
  * @scmd:                       SCSI command
  *
- * Called by megasas_queue_command to find out if the command to be queued
- * is a logical drive command
  */
-inline int megasas_is_ldio(struct scsi_cmnd *cmd)
+inline int megasas_cmd_type(struct scsi_cmnd *cmd)
 {
-        if (!MEGASAS_IS_LOGICAL(cmd))
-                return 0;
+        int ret;
+
         switch (cmd->cmnd[0]) {
         case READ_10:
         case WRITE_10:
@@ -1436,10 +1435,14 @@ inline int megasas_is_ldio(struct scsi_cmnd *cmd)
         case WRITE_6:
         case READ_16:
         case WRITE_16:
-                return 1;
+                ret = (MEGASAS_IS_LOGICAL(cmd)) ?
+                        READ_WRITE_LDIO : READ_WRITE_SYSPDIO;
+                break;
         default:
-                return 0;
+                ret = (MEGASAS_IS_LOGICAL(cmd)) ?
+                        NON_READ_WRITE_LDIO : NON_READ_WRITE_SYSPDIO;
         }
+        return ret;
 }
 
  /**
@@ -1471,7 +1474,7 @@ megasas_dump_pending_frames(struct megasas_instance *instance)
                 if(!cmd->scmd)
                         continue;
                 printk(KERN_ERR "megasas[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr);
-                if (megasas_is_ldio(cmd->scmd)){
+                if (megasas_cmd_type(cmd->scmd) == READ_WRITE_LDIO) {
                         ldio = (struct megasas_io_frame *)cmd->frame;
                         mfi_sgl = &ldio->sgl;
                         sgcount = ldio->sge_count;
@@ -1531,7 +1534,7 @@ megasas_build_and_issue_cmd(struct megasas_instance *instance,
         /*
          * Logical drive command
          */
-        if (megasas_is_ldio(scmd))
+        if (megasas_cmd_type(scmd) == READ_WRITE_LDIO)
                 frame_count = megasas_build_ldio(instance, scmd, cmd);
         else
                 frame_count = megasas_build_dcdb(instance, scmd, cmd);
@@ -1689,22 +1692,66 @@ static int megasas_slave_alloc(struct scsi_device *sdev)
         return 0;
 }
 
+/*
+* megasas_complete_outstanding_ioctls - Complete outstanding ioctls after a
+*                                       kill adapter
+* @instance:                            Adapter soft state
+*
+*/
+void megasas_complete_outstanding_ioctls(struct megasas_instance *instance)
+{
+        int i;
+        struct megasas_cmd *cmd_mfi;
+        struct megasas_cmd_fusion *cmd_fusion;
+        struct fusion_context *fusion = instance->ctrl_context;
+
+        /* Find all outstanding ioctls */
+        if (fusion) {
+                for (i = 0; i < instance->max_fw_cmds; i++) {
+                        cmd_fusion = fusion->cmd_list[i];
+                        if (cmd_fusion->sync_cmd_idx != (u32)ULONG_MAX) {
+                                cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
+                                if (cmd_mfi->sync_cmd &&
+                                        cmd_mfi->frame->hdr.cmd != MFI_CMD_ABORT)
+                                        megasas_complete_cmd(instance,
+                                                             cmd_mfi, DID_OK);
+                        }
+                }
+        } else {
+                for (i = 0; i < instance->max_fw_cmds; i++) {
+                        cmd_mfi = instance->cmd_list[i];
+                        if (cmd_mfi->sync_cmd && cmd_mfi->frame->hdr.cmd !=
+                                MFI_CMD_ABORT)
+                                megasas_complete_cmd(instance, cmd_mfi, DID_OK);
+                }
+        }
+}
+
+
 void megaraid_sas_kill_hba(struct megasas_instance *instance)
 {
+        /* Set critical error to block I/O & ioctls in case caller didn't */
+        instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR;
+        /* Wait 1 second to ensure IO or ioctls in build have posted */
+        msleep(1000);
         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
-            (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
-            (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
-            (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) ||
-            (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
-            (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) {
-                writel(MFI_STOP_ADP, &instance->reg_set->doorbell);
+                (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
+                (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
+                (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) ||
+                (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
+                (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) {
+                writel(MFI_STOP_ADP,
+                        &instance->reg_set->doorbell);
                 /* Flush */
                 readl(&instance->reg_set->doorbell);
                 if (instance->mpio && instance->requestorId)
                         memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
         } else {
-                writel(MFI_STOP_ADP, &instance->reg_set->inbound_doorbell);
+                writel(MFI_STOP_ADP,
+                        &instance->reg_set->inbound_doorbell);
         }
+        /* Complete outstanding ioctls when adapter is killed */
+        megasas_complete_outstanding_ioctls(instance);
 }
 
  /**
@@ -1717,6 +1764,7 @@ void
 megasas_check_and_restore_queue_depth(struct megasas_instance *instance)
 {
         unsigned long flags;
+
         if (instance->flag & MEGASAS_FW_BUSY
             && time_after(jiffies, instance->last_time + 5 * HZ)
             && atomic_read(&instance->fw_outstanding) <
@@ -1724,13 +1772,8 @@ megasas_check_and_restore_queue_depth(struct megasas_instance *instance)
 
                 spin_lock_irqsave(instance->host->host_lock, flags);
                 instance->flag &= ~MEGASAS_FW_BUSY;
-                if (instance->is_imr) {
-                        instance->host->can_queue =
-                                instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;
-                } else
-                        instance->host->can_queue =
-                                instance->max_fw_cmds - MEGASAS_INT_CMDS;
 
+                instance->host->can_queue = instance->max_scsi_cmds;
                 spin_unlock_irqrestore(instance->host->host_lock, flags);
         }
 }
@@ -3028,10 +3071,9 @@ megasas_issue_pending_cmds_again(struct megasas_instance *instance)
                                         "was tried multiple times during reset."
                                         "Shutting down the HBA\n",
                                         cmd, cmd->scmd, cmd->sync_cmd);
+                                instance->instancet->disable_intr(instance);
+                                atomic_set(&instance->fw_reset_no_pci_access, 1);
                                 megaraid_sas_kill_hba(instance);
-
-                                instance->adprecovery =
-                                                MEGASAS_HW_CRITICAL_ERROR;
                                 return;
                         }
                 }
@@ -3165,8 +3207,8 @@ process_fw_state_change_wq(struct work_struct *work)
                 if (megasas_transition_to_ready(instance, 1)) {
                         printk(KERN_NOTICE "megaraid_sas:adapter not ready\n");
 
+                        atomic_set(&instance->fw_reset_no_pci_access, 1);
                         megaraid_sas_kill_hba(instance);
-                        instance->adprecovery   = MEGASAS_HW_CRITICAL_ERROR;
                         return ;
                 }
 
@@ -3547,7 +3589,6 @@ static int megasas_create_frame_pool(struct megasas_instance *instance)
         int i;
         u32 max_cmd;
         u32 sge_sz;
-        u32 sgl_sz;
         u32 total_sz;
         u32 frame_count;
         struct megasas_cmd *cmd;
@@ -3566,24 +3607,23 @@ static int megasas_create_frame_pool(struct megasas_instance *instance)
         }
 
         /*
-         * Calculated the number of 64byte frames required for SGL
-         */
-        sgl_sz = sge_sz * instance->max_num_sge;
-        frame_count = (sgl_sz + MEGAMFI_FRAME_SIZE - 1) / MEGAMFI_FRAME_SIZE;
-        frame_count = 15;
-
-        /*
-         * We need one extra frame for the MFI command
+         * For MFI controllers.
+         * max_num_sge = 60
+         * max_sge_sz  = 16 byte (sizeof megasas_sge_skinny)
+         * Total 960 byte (15 MFI frame of 64 byte)
+         *
+         * Fusion adapter require only 3 extra frame.
+         * max_num_sge = 16 (defined as MAX_IOCTL_SGE)
+         * max_sge_sz  = 12 byte (sizeof  megasas_sge64)
+         * Total 192 byte (3 MFI frame of 64 byte)
          */
-        frame_count++;
-
+        frame_count = instance->ctrl_context ? (3 + 1) : (15 + 1);
         total_sz = MEGAMFI_FRAME_SIZE * frame_count;
         /*
          * Use DMA pool facility provided by PCI layer
          */
         instance->frame_dma_pool = pci_pool_create("megasas frame pool",
-                                                   instance->pdev, total_sz, 64,
-                                                   0);
+                                        instance->pdev, total_sz, 256, 0);
 
         if (!instance->frame_dma_pool) {
                 printk(KERN_DEBUG "megasas: failed to setup frame pool\n");
@@ -4631,28 +4671,48 @@ static int megasas_init_fw(struct megasas_instance *instance)
                                 instance->crash_dump_h);
                 instance->crash_dump_buf = NULL;
         }
+
+        instance->secure_jbod_support =
+                ctrl_info->adapterOperations3.supportSecurityonJBOD;
+        if (instance->secure_jbod_support)
+                dev_info(&instance->pdev->dev, "Firmware supports Secure JBOD\n");
         instance->max_sectors_per_req = instance->max_num_sge *
                                                 PAGE_SIZE / 512;
         if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))
                 instance->max_sectors_per_req = tmp_sectors;
 
-        /* Check for valid throttlequeuedepth module parameter */
-        if (instance->is_imr) {
-                if (throttlequeuedepth > (instance->max_fw_cmds -
-                                          MEGASAS_SKINNY_INT_CMDS))
-                        instance->throttlequeuedepth =
-                                MEGASAS_THROTTLE_QUEUE_DEPTH;
-                else
-                        instance->throttlequeuedepth = throttlequeuedepth;
+        /*
+         * 1. For fusion adapters, 3 commands for IOCTL and 5 commands
+         *    for driver's internal DCMDs.
+         * 2. For MFI skinny adapters, 5 commands for IOCTL + driver's
+         *    internal DCMDs.
+         * 3. For rest of MFI adapters, 27 commands reserved for IOCTLs
+         *    and 5 commands for drivers's internal DCMD.
+         */
+        if (instance->ctrl_context) {
+                instance->max_scsi_cmds = instance->max_fw_cmds -
+                                        (MEGASAS_FUSION_INTERNAL_CMDS +
+                                        MEGASAS_FUSION_IOCTL_CMDS);
+                sema_init(&instance->ioctl_sem, MEGASAS_FUSION_IOCTL_CMDS);
+        } else if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
+                (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
+                instance->max_scsi_cmds = instance->max_fw_cmds -
+                                                MEGASAS_SKINNY_INT_CMDS;
+                sema_init(&instance->ioctl_sem, MEGASAS_SKINNY_INT_CMDS);
         } else {
-                if (throttlequeuedepth > (instance->max_fw_cmds -
-                                          MEGASAS_INT_CMDS))
-                        instance->throttlequeuedepth =
-                                MEGASAS_THROTTLE_QUEUE_DEPTH;
-                else
-                        instance->throttlequeuedepth = throttlequeuedepth;
+                instance->max_scsi_cmds = instance->max_fw_cmds -
+                                                MEGASAS_INT_CMDS;
+                sema_init(&instance->ioctl_sem, (MEGASAS_INT_CMDS - 5));
         }
 
+        /* Check for valid throttlequeuedepth module parameter */
+        if (throttlequeuedepth &&
+                        throttlequeuedepth <= instance->max_scsi_cmds)
+                instance->throttlequeuedepth = throttlequeuedepth;
+        else
+                instance->throttlequeuedepth =
+                                MEGASAS_THROTTLE_QUEUE_DEPTH;
+
         /*
         * Setup tasklet for cmd completion
         */
@@ -4947,12 +5007,7 @@ static int megasas_io_attach(struct megasas_instance *instance)
          */
         host->irq = instance->pdev->irq;
         host->unique_id = instance->unique_id;
-        if (instance->is_imr) {
-                host->can_queue =
-                        instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;
-        } else
-                host->can_queue =
-                        instance->max_fw_cmds - MEGASAS_INT_CMDS;
+        host->can_queue = instance->max_scsi_cmds;
         host->this_id = instance->init_id;
         host->sg_tablesize = instance->max_num_sge;
 
@@ -5130,8 +5185,6 @@ static int megasas_probe_one(struct pci_dev *pdev,
                         ((1 << PAGE_SHIFT) << instance->ctrl_context_pages));
                 INIT_LIST_HEAD(&fusion->cmd_pool);
                 spin_lock_init(&fusion->mpt_pool_lock);
-                memset(fusion->load_balance_info, 0,
-                        sizeof(struct LD_LOAD_BALANCE_INFO) * MAX_LOGICAL_DRIVES_EXT);
         }
         break;
         default: /* For all other supported controllers */
@@ -5215,12 +5268,10 @@ static int megasas_probe_one(struct pci_dev *pdev,
         instance->init_id = MEGASAS_DEFAULT_INIT_ID;
         instance->ctrl_info = NULL;
 
+
         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
-                (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
+                (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 - 5));
 
         megasas_dbg_lvl = 0;
         instance->flag = 0;
@@ -6215,9 +6266,6 @@ static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
                 goto out_kfree_ioc;
         }
 
-        /*
-         * We will allow only MEGASAS_INT_CMDS number of parallel ioctl cmds
-         */
         if (down_interruptible(&instance->ioctl_sem)) {
                 error = -ERESTARTSYS;
                 goto out_kfree_ioc;
diff --git a/drivers/scsi/megaraid/megaraid_sas_fp.c b/drivers/scsi/megaraid/megaraid_sas_fp.c
index 460c6a3d4ade..4f72287860ee 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fp.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fp.c
@@ -172,6 +172,7 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance)
         struct MR_FW_RAID_MAP_ALL     *fw_map_old    = NULL;
         struct MR_FW_RAID_MAP         *pFwRaidMap    = NULL;
         int i;
+        u16 ld_count;
 
 
         struct MR_DRV_RAID_MAP_ALL *drv_map =
@@ -191,9 +192,10 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance)
                 fw_map_old = (struct MR_FW_RAID_MAP_ALL *)
                         fusion->ld_map[(instance->map_id & 1)];
                 pFwRaidMap = &fw_map_old->raidMap;
+                ld_count = (u16)le32_to_cpu(pFwRaidMap->ldCount);
 
 #if VD_EXT_DEBUG
-                for (i = 0; i < le16_to_cpu(pFwRaidMap->ldCount); i++) {
+                for (i = 0; i < ld_count; i++) {
                         dev_dbg(&instance->pdev->dev, "(%d) :Index 0x%x "
                                 "Target Id 0x%x Seq Num 0x%x Size 0/%llx\n",
                                 instance->unique_id, i,
@@ -205,12 +207,15 @@ void MR_PopulateDrvRaidMap(struct megasas_instance *instance)
 
                 memset(drv_map, 0, fusion->drv_map_sz);
                 pDrvRaidMap->totalSize = pFwRaidMap->totalSize;
-                pDrvRaidMap->ldCount = (__le16)pFwRaidMap->ldCount;
+                pDrvRaidMap->ldCount = (__le16)cpu_to_le16(ld_count);
                 pDrvRaidMap->fpPdIoTimeoutSec = pFwRaidMap->fpPdIoTimeoutSec;
                 for (i = 0; i < MAX_RAIDMAP_LOGICAL_DRIVES + MAX_RAIDMAP_VIEWS; i++)
                         pDrvRaidMap->ldTgtIdToLd[i] =
                                 (u8)pFwRaidMap->ldTgtIdToLd[i];
-                for (i = 0; i < le16_to_cpu(pDrvRaidMap->ldCount); i++) {
+                for (i = (MAX_RAIDMAP_LOGICAL_DRIVES + MAX_RAIDMAP_VIEWS);
+                        i < MAX_LOGICAL_DRIVES_EXT; i++)
+                        pDrvRaidMap->ldTgtIdToLd[i] = 0xff;
+                for (i = 0; i < ld_count; i++) {
                         pDrvRaidMap->ldSpanMap[i] = pFwRaidMap->ldSpanMap[i];
 #if VD_EXT_DEBUG
                         dev_dbg(&instance->pdev->dev,
@@ -252,7 +257,7 @@ u8 MR_ValidateMapInfo(struct megasas_instance *instance)
         struct LD_LOAD_BALANCE_INFO *lbInfo;
         PLD_SPAN_INFO ldSpanInfo;
         struct MR_LD_RAID         *raid;
-        int ldCount, num_lds;
+        u16 ldCount, num_lds;
         u16 ld;
         u32 expected_size;
 
@@ -356,7 +361,7 @@ static int getSpanInfo(struct MR_DRV_RAID_MAP_ALL *map,
 
         for (ldCount = 0; ldCount < MAX_LOGICAL_DRIVES_EXT; ldCount++) {
                 ld = MR_TargetIdToLdGet(ldCount, map);
-                        if (ld >= MAX_LOGICAL_DRIVES_EXT)
+                        if (ld >= (MAX_LOGICAL_DRIVES_EXT - 1))
                                 continue;
                 raid = MR_LdRaidGet(ld, map);
                 dev_dbg(&instance->pdev->dev, "LD %x: span_depth=%x\n",
@@ -1157,7 +1162,7 @@ void mr_update_span_set(struct MR_DRV_RAID_MAP_ALL *map,
 
         for (ldCount = 0; ldCount < MAX_LOGICAL_DRIVES_EXT; ldCount++) {
                 ld = MR_TargetIdToLdGet(ldCount, map);
-                if (ld >= MAX_LOGICAL_DRIVES_EXT)
+                if (ld >= (MAX_LOGICAL_DRIVES_EXT - 1))
                         continue;
                 raid = MR_LdRaidGet(ld, map);
                 for (element = 0; element < MAX_QUAD_DEPTH; element++) {
diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c b/drivers/scsi/megaraid/megaraid_sas_fusion.c
index 71557f64bb5e..675b5e7aba94 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fusion.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c
@@ -63,7 +63,6 @@ extern struct megasas_cmd *megasas_get_cmd(struct megasas_instance
 extern void
 megasas_complete_cmd(struct megasas_instance *instance,
                      struct megasas_cmd *cmd, u8 alt_status);
-int megasas_is_ldio(struct scsi_cmnd *cmd);
 int
 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
               int seconds);
@@ -103,6 +102,8 @@ megasas_enable_intr_fusion(struct megasas_instance *instance)
 {
         struct megasas_register_set __iomem *regs;
         regs = instance->reg_set;
+
+        instance->mask_interrupts = 0;
         /* For Thunderbolt/Invader also clear intr on enable */
         writel(~0, &regs->outbound_intr_status);
         readl(&regs->outbound_intr_status);
@@ -111,7 +112,6 @@ megasas_enable_intr_fusion(struct megasas_instance *instance)
 
         /* Dummy readl to force pci flush */
         readl(&regs->outbound_intr_mask);
-        instance->mask_interrupts = 0;
 }
 
 /**
@@ -196,6 +196,7 @@ inline void megasas_return_cmd_fusion(struct megasas_instance *instance,
 
         cmd->scmd = NULL;
         cmd->sync_cmd_idx = (u32)ULONG_MAX;
+        memset(cmd->io_request, 0, sizeof(struct MPI2_RAID_SCSI_IO_REQUEST));
         list_add(&cmd->list, (&fusion->cmd_pool)->next);
 
         spin_unlock_irqrestore(&fusion->mpt_pool_lock, flags);
@@ -689,6 +690,8 @@ megasas_ioc_init_fusion(struct megasas_instance *instance)
                 = 1;
         init_frame->driver_operations.mfi_capabilities.support_ndrive_r1_lb
                 = 1;
+        init_frame->driver_operations.mfi_capabilities.security_protocol_cmds_fw
+                = 1;
         /* Convert capability to LE32 */
         cpu_to_le32s((u32 *)&init_frame->driver_operations.mfi_capabilities);
 
@@ -698,12 +701,11 @@ megasas_ioc_init_fusion(struct megasas_instance *instance)
                 cpu_to_le32(lower_32_bits(ioc_init_handle));
         init_frame->data_xfer_len = cpu_to_le32(sizeof(struct MPI2_IOC_INIT_REQUEST));
 
-        req_desc.Words = 0;
+        req_desc.u.low = cpu_to_le32(lower_32_bits(cmd->frame_phys_addr));
+        req_desc.u.high = cpu_to_le32(upper_32_bits(cmd->frame_phys_addr));
         req_desc.MFAIo.RequestFlags =
                 (MEGASAS_REQ_DESCRIPT_FLAGS_MFA <<
-                 MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
-        cpu_to_le32s((u32 *)&req_desc.MFAIo);
-        req_desc.Words |= cpu_to_le64(cmd->frame_phys_addr);
+                MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
 
         /*
          * disable the intr before firing the init frame
@@ -1017,8 +1019,12 @@ megasas_init_adapter_fusion(struct megasas_instance *instance)
          * does not exceed max cmds that the FW can support
          */
         instance->max_fw_cmds = instance->max_fw_cmds-1;
-        /* Only internal cmds (DCMD) need to have MFI frames */
-        instance->max_mfi_cmds = MEGASAS_INT_CMDS;
+
+        /*
+         * Only Driver's internal DCMDs and IOCTL DCMDs needs to have MFI frames
+         */
+        instance->max_mfi_cmds =
+                MEGASAS_FUSION_INTERNAL_CMDS + MEGASAS_FUSION_IOCTL_CMDS;
 
         max_cmd = instance->max_fw_cmds;
 
@@ -1285,6 +1291,7 @@ megasas_make_sgl_fusion(struct megasas_instance *instance,
 
                         sgl_ptr =
                           (struct MPI25_IEEE_SGE_CHAIN64 *)cmd->sg_frame;
+                        memset(sgl_ptr, 0, MEGASAS_MAX_SZ_CHAIN_FRAME);
                 }
         }
 
@@ -1658,6 +1665,8 @@ megasas_build_dcdb_fusion(struct megasas_instance *instance,
         u32 device_id;
         struct MPI2_RAID_SCSI_IO_REQUEST *io_request;
         u16 pd_index = 0;
+        u16 os_timeout_value;
+        u16 timeout_limit;
         struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
         struct fusion_context *fusion = instance->ctrl_context;
         u8                          span, physArm;
@@ -1674,52 +1683,66 @@ megasas_build_dcdb_fusion(struct megasas_instance *instance,
 
         io_request->DataLength = cpu_to_le32(scsi_bufflen(scmd));
 
-
-        /* Check if this is a system PD I/O */
         if (scmd->device->channel < MEGASAS_MAX_PD_CHANNELS &&
             instance->pd_list[pd_index].driveState == MR_PD_STATE_SYSTEM) {
-                io_request->Function = 0;
                 if (fusion->fast_path_io)
                         io_request->DevHandle =
                         local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;
-                io_request->RaidContext.timeoutValue =
-                        local_map_ptr->raidMap.fpPdIoTimeoutSec;
-                io_request->RaidContext.regLockFlags = 0;
-                io_request->RaidContext.regLockRowLBA = 0;
-                io_request->RaidContext.regLockLength = 0;
                 io_request->RaidContext.RAIDFlags =
-                        MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD <<
-                        MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT;
-                if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
-                        (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY))
-                        io_request->IoFlags |= cpu_to_le16(
-                                MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
-                cmd->request_desc->SCSIIO.RequestFlags =
-                        (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY <<
-                         MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
-                cmd->request_desc->SCSIIO.DevHandle =
-                        local_map_ptr->raidMap.devHndlInfo[device_id].curDevHdl;
+                        MR_RAID_FLAGS_IO_SUB_TYPE_SYSTEM_PD
+                        << MR_RAID_CTX_RAID_FLAGS_IO_SUB_TYPE_SHIFT;
+                cmd->request_desc->SCSIIO.DevHandle = io_request->DevHandle;
                 cmd->request_desc->SCSIIO.MSIxIndex =
                         instance->msix_vectors ? smp_processor_id() % instance->msix_vectors : 0;
-                /*
-                 * If the command is for the tape device, set the
-                 * FP timeout to the os layer timeout value.
-                 */
-                if (scmd->device->type == TYPE_TAPE) {
-                        if ((scmd->request->timeout / HZ) > 0xFFFF)
-                                io_request->RaidContext.timeoutValue =
-                                        0xFFFF;
-                        else
-                                io_request->RaidContext.timeoutValue =
-                                        scmd->request->timeout / HZ;
+                os_timeout_value = scmd->request->timeout / HZ;
+
+                if (instance->secure_jbod_support &&
+                        (megasas_cmd_type(scmd) == NON_READ_WRITE_SYSPDIO)) {
+                        /* system pd firmware path */
+                        io_request->Function  =
+                                MEGASAS_MPI2_FUNCTION_LD_IO_REQUEST;
+                        cmd->request_desc->SCSIIO.RequestFlags =
+                                (MPI2_REQ_DESCRIPT_FLAGS_SCSI_IO <<
+                                MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
+                        io_request->RaidContext.timeoutValue =
+                                cpu_to_le16(os_timeout_value);
+                } else {
+                        /* system pd Fast Path */
+                        io_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST;
+                        io_request->RaidContext.regLockFlags = 0;
+                        io_request->RaidContext.regLockRowLBA = 0;
+                        io_request->RaidContext.regLockLength = 0;
+                        timeout_limit = (scmd->device->type == TYPE_DISK) ?
+                                        255 : 0xFFFF;
+                        io_request->RaidContext.timeoutValue =
+                                cpu_to_le16((os_timeout_value > timeout_limit) ?
+                                timeout_limit : os_timeout_value);
+                if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
+                        (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY))
+                        io_request->IoFlags |=
+                        cpu_to_le16(MPI25_SAS_DEVICE0_FLAGS_ENABLED_FAST_PATH);
+
+                        cmd->request_desc->SCSIIO.RequestFlags =
+                                (MPI2_REQ_DESCRIPT_FLAGS_HIGH_PRIORITY <<
+                                MEGASAS_REQ_DESCRIPT_FLAGS_TYPE_SHIFT);
                 }
         } else {
                 if (scmd->device->channel < MEGASAS_MAX_PD_CHANNELS)
                         goto NonFastPath;
 
+                /*
+                 * For older firmware, Driver should not access ldTgtIdToLd
+                 * beyond index 127 and for Extended VD firmware, ldTgtIdToLd
+                 * should not go beyond 255.
+                 */
+
+                if ((!fusion->fast_path_io) ||
+                        (device_id >= instance->fw_supported_vd_count))
+                        goto NonFastPath;
+
                 ld = MR_TargetIdToLdGet(device_id, local_map_ptr);
-                if ((ld >= instance->fw_supported_vd_count) ||
-                        (!fusion->fast_path_io))
+
+                if (ld >= instance->fw_supported_vd_count)
                         goto NonFastPath;
 
                 raid = MR_LdRaidGet(ld, local_map_ptr);
@@ -1811,7 +1834,7 @@ megasas_build_io_fusion(struct megasas_instance *instance,
          */
         io_request->IoFlags = cpu_to_le16(scp->cmd_len);
 
-        if (megasas_is_ldio(scp))
+        if (megasas_cmd_type(scp) == READ_WRITE_LDIO)
                 megasas_build_ldio_fusion(instance, scp, cmd);
         else
                 megasas_build_dcdb_fusion(instance, scp, cmd);
@@ -2612,7 +2635,6 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int iotimeout)
                                 instance->host->host_no);
                         megaraid_sas_kill_hba(instance);
                         instance->skip_heartbeat_timer_del = 1;
-                        instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR;
                         retval = FAILED;
                         goto out;
                 }
@@ -2808,8 +2830,6 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int iotimeout)
                                 dev_info(&instance->pdev->dev,
                                         "Failed from %s %d\n",
                                         __func__, __LINE__);
-                                instance->adprecovery =
-                                        MEGASAS_HW_CRITICAL_ERROR;
                                 megaraid_sas_kill_hba(instance);
                                 retval = FAILED;
                         }
@@ -2858,7 +2878,6 @@ int megasas_reset_fusion(struct Scsi_Host *shost, int iotimeout)
                        "adapter scsi%d.\n", instance->host->host_no);
                 megaraid_sas_kill_hba(instance);
                 instance->skip_heartbeat_timer_del = 1;
-                instance->adprecovery = MEGASAS_HW_CRITICAL_ERROR;
                 retval = FAILED;
         } else {
                 /* For VF: Restart HB timer if we didn't OCR */
diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.h b/drivers/scsi/megaraid/megaraid_sas_fusion.h
index 5ab7daee11be..56e6db2d5874 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fusion.h
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.h
@@ -306,14 +306,9 @@ struct MPI2_RAID_SCSI_IO_REQUEST {
  * MPT RAID MFA IO Descriptor.
  */
 struct MEGASAS_RAID_MFA_IO_REQUEST_DESCRIPTOR {
-#if   defined(__BIG_ENDIAN_BITFIELD)
-        u32     MessageAddress1:24; /* bits 31:8*/
-        u32     RequestFlags:8;
-#else
         u32     RequestFlags:8;
-        u32     MessageAddress1:24; /* bits 31:8*/
-#endif
-        u32     MessageAddress2;      /* bits 61:32 */
+        u32     MessageAddress1:24;
+        u32     MessageAddress2;
 };
 
 /* Default Request Descriptor */
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2.h b/drivers/scsi/mpt2sas/mpi/mpi2.h
index 088eefa67da8..7fc6f23bd9dc 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.32
+ *  mpi2.h Version:  02.00.35
  *
  *  Version History
  *  ---------------
@@ -83,6 +83,9 @@
  *  04-09-13  02.00.30  Bumped MPI2_HEADER_VERSION_UNIT.
  *  04-17-13  02.00.31  Bumped MPI2_HEADER_VERSION_UNIT.
  *  08-19-13  02.00.32  Bumped MPI2_HEADER_VERSION_UNIT.
+ *  12-05-13  02.00.33  Bumped MPI2_HEADER_VERSION_UNIT.
+ *  01-08-14  02.00.34  Bumped MPI2_HEADER_VERSION_UNIT.
+ *  06-13-14  02.00.35  Bumped MPI2_HEADER_VERSION_UNIT.
  *  --------------------------------------------------------------------------
  */
 
@@ -108,7 +111,7 @@
 #define MPI2_VERSION_02_00                  (0x0200)
 
 /* versioning for this MPI header set */
-#define MPI2_HEADER_VERSION_UNIT            (0x20)
+#define MPI2_HEADER_VERSION_UNIT            (0x23)
 #define MPI2_HEADER_VERSION_DEV             (0x00)
 #define MPI2_HEADER_VERSION_UNIT_MASK       (0xFF00)
 #define MPI2_HEADER_VERSION_UNIT_SHIFT      (8)
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h b/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h
index 510ef0dc8d7b..ee8d2d695d55 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.26
+ *    mpi2_cnfg.h Version:  02.00.29
  *
  *  Version History
  *  ---------------
@@ -157,6 +157,20 @@
  *  04-09-13  02.00.25  Added MPI2_IOUNITPAGE1_ATA_SECURITY_FREEZE_LOCK.
  *                      Fixed MPI2_IOUNITPAGE5_DMA_CAP_MASK_MAX_REQUESTS to
  *                      match the specification.
+ *  12-05-13  02.00.27  Added MPI2_MANPAGE7_FLAG_BASE_ENCLOSURE_LEVEL for
+ *                      MPI2_CONFIG_PAGE_MAN_7.
+ *                      Added EnclosureLevel and ConnectorName fields to
+ *                      MPI2_CONFIG_PAGE_SAS_DEV_0.
+ *                      Added MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID for
+ *                      MPI2_CONFIG_PAGE_SAS_DEV_0.
+ *                      Added EnclosureLevel field to
+ *                      MPI2_CONFIG_PAGE_SAS_ENCLOSURE_0.
+ *                      Added MPI2_SAS_ENCLS0_FLAGS_ENCL_LEVEL_VALID for
+ *                      MPI2_CONFIG_PAGE_SAS_ENCLOSURE_0.
+ *  01-08-14  02.00.28  Added more defines for the BiosOptions field of
+ *                      MPI2_CONFIG_PAGE_BIOS_1.
+ *  06-13-14  02.00.29  Added SSUTimeout field to MPI2_CONFIG_PAGE_BIOS_1, and
+ *                      more defines for the BiosOptions field.
  *  --------------------------------------------------------------------------
  */
 
@@ -706,6 +720,7 @@ typedef struct _MPI2_CONFIG_PAGE_MAN_7
 #define MPI2_MANUFACTURING7_PAGEVERSION                 (0x01)
 
 /* defines for the Flags field */
+#define MPI2_MANPAGE7_FLAG_BASE_ENCLOSURE_LEVEL         (0x00000008)
 #define MPI2_MANPAGE7_FLAG_EVENTREPLAY_SLOT_ORDER       (0x00000002)
 #define MPI2_MANPAGE7_FLAG_USE_SLOT_INFO                (0x00000001)
 
@@ -1224,7 +1239,9 @@ typedef struct _MPI2_CONFIG_PAGE_BIOS_1
         MPI2_CONFIG_PAGE_HEADER Header;                     /* 0x00 */
         U32                     BiosOptions;                /* 0x04 */
         U32                     IOCSettings;                /* 0x08 */
-        U32                     Reserved1;                  /* 0x0C */
+        U8                      SSUTimeout;                 /* 0x0C */
+        U8                      Reserved1;                  /* 0x0D */
+        U16                     Reserved2;                  /* 0x0E */
         U32                     DeviceSettings;             /* 0x10 */
         U16                     NumberOfDevices;            /* 0x14 */
         U16                     UEFIVersion;                /* 0x16 */
@@ -1235,9 +1252,24 @@ typedef struct _MPI2_CONFIG_PAGE_BIOS_1
 } MPI2_CONFIG_PAGE_BIOS_1, MPI2_POINTER PTR_MPI2_CONFIG_PAGE_BIOS_1,
   Mpi2BiosPage1_t, MPI2_POINTER pMpi2BiosPage1_t;
 
-#define MPI2_BIOSPAGE1_PAGEVERSION                      (0x05)
+#define MPI2_BIOSPAGE1_PAGEVERSION                      (0x07)
 
 /* values for BIOS Page 1 BiosOptions field */
+#define MPI2_BIOSPAGE1_OPTIONS_PNS_MASK                 (0x00003800)
+#define MPI2_BIOSPAGE1_OPTIONS_PNS_PBDHL                        (0x00000000)
+#define MPI2_BIOSPAGE1_OPTIONS_PNS_ENCSLOSURE                   (0x00000800)
+#define MPI2_BIOSPAGE1_OPTIONS_PNS_LWWID                        (0x00001000)
+#define MPI2_BIOSPAGE1_OPTIONS_PNS_PSENS                        (0x00001800)
+#define MPI2_BIOSPAGE1_OPTIONS_PNS_ESPHY                        (0x00002000)
+
+#define MPI2_BIOSPAGE1_OPTIONS_X86_DISABLE_BIOS                 (0x00000400)
+
+#define MPI2_BIOSPAGE1_OPTIONS_MASK_REGISTRATION_UEFI_BSD       (0x00000300)
+#define MPI2_BIOSPAGE1_OPTIONS_USE_BIT0_REGISTRATION_UEFI_BSD   (0x00000000)
+#define MPI2_BIOSPAGE1_OPTIONS_FULL_REGISTRATION_UEFI_BSD       (0x00000100)
+#define MPI2_BIOSPAGE1_OPTIONS_ADAPTER_REGISTRATION_UEFI_BSD    (0x00000200)
+#define MPI2_BIOSPAGE1_OPTIONS_DISABLE_REGISTRATION_UEFI_BSD    (0x00000300)
+
 #define MPI2_BIOSPAGE1_OPTIONS_MASK_OEM_ID                  (0x000000F0)
 #define MPI2_BIOSPAGE1_OPTIONS_LSI_OEM_ID                   (0x00000000)
 
@@ -2420,13 +2452,13 @@ typedef struct _MPI2_CONFIG_PAGE_SAS_DEV_0
     U8                                  PortGroups;             /* 0x2C */
     U8                                  DmaGroup;               /* 0x2D */
     U8                                  ControlGroup;           /* 0x2E */
-    U8                                  Reserved1;              /* 0x2F */
-    U32                                 Reserved2;              /* 0x30 */
+        U8                               EnclosureLevel;         /* 0x2F */
+        U8                               ConnectorName[4];       /* 0x30 */
     U32                                 Reserved3;              /* 0x34 */
 } MPI2_CONFIG_PAGE_SAS_DEV_0, MPI2_POINTER PTR_MPI2_CONFIG_PAGE_SAS_DEV_0,
   Mpi2SasDevicePage0_t, MPI2_POINTER pMpi2SasDevicePage0_t;
 
-#define MPI2_SASDEVICE0_PAGEVERSION         (0x08)
+#define MPI2_SASDEVICE0_PAGEVERSION         (0x09)
 
 /* values for SAS Device Page 0 AccessStatus field */
 #define MPI2_SAS_DEVICE0_ASTATUS_NO_ERRORS                  (0x00)
@@ -2464,6 +2496,7 @@ typedef struct _MPI2_CONFIG_PAGE_SAS_DEV_0
 #define MPI2_SAS_DEVICE0_FLAGS_SATA_NCQ_SUPPORTED           (0x0020)
 #define MPI2_SAS_DEVICE0_FLAGS_SATA_FUA_SUPPORTED           (0x0010)
 #define MPI2_SAS_DEVICE0_FLAGS_PORT_SELECTOR_ATTACH         (0x0008)
+#define MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID             (0x0002)
 #define MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT               (0x0001)
 
 
@@ -2732,7 +2765,8 @@ typedef struct _MPI2_CONFIG_PAGE_SAS_ENCLOSURE_0
     U16                                 EnclosureHandle;            /* 0x16 */
     U16                                 NumSlots;                   /* 0x18 */
     U16                                 StartSlot;                  /* 0x1A */
-    U16                                 Reserved2;                  /* 0x1C */
+        U8                               Reserved2;                  /* 0x1C */
+        U8                               EnclosureLevel;             /* 0x1D */
     U16                                 SEPDevHandle;               /* 0x1E */
     U32                                 Reserved3;                  /* 0x20 */
     U32                                 Reserved4;                  /* 0x24 */
@@ -2740,9 +2774,10 @@ typedef struct _MPI2_CONFIG_PAGE_SAS_ENCLOSURE_0
   MPI2_POINTER PTR_MPI2_CONFIG_PAGE_SAS_ENCLOSURE_0,
   Mpi2SasEnclosurePage0_t, MPI2_POINTER pMpi2SasEnclosurePage0_t;
 
-#define MPI2_SASENCLOSURE0_PAGEVERSION      (0x03)
+#define MPI2_SASENCLOSURE0_PAGEVERSION      (0x04)
 
 /* values for SAS Enclosure Page 0 Flags field */
+#define MPI2_SAS_ENCLS0_FLAGS_ENCL_LEVEL_VALID      (0x0010)
 #define MPI2_SAS_ENCLS0_FLAGS_MNG_MASK              (0x000F)
 #define MPI2_SAS_ENCLS0_FLAGS_MNG_UNKNOWN           (0x0000)
 #define MPI2_SAS_ENCLS0_FLAGS_MNG_IOC_SES           (0x0001)
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_ioc.h b/drivers/scsi/mpt2sas/mpi/mpi2_ioc.h
index 2c3b0f28576b..b02de48be204 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.23
+ *  mpi2_ioc.h Version:  02.00.24
  *
  *  Version History
  *  ---------------
@@ -126,6 +126,7 @@
  *                      Added MPI2_IOCFACTS_CAPABILITY_RDPQ_ARRAY_CAPABLE.
  *                      Added MPI2_FW_DOWNLOAD_ITYPE_PUBLIC_KEY.
  *                      Added Encrypted Hash Extended Image.
+ *  12-05-13  02.00.24  Added MPI25_HASH_IMAGE_TYPE_BIOS.
  *  --------------------------------------------------------------------------
  */
 
@@ -1589,6 +1590,7 @@ Mpi25EncryptedHashEntry_t, MPI2_POINTER pMpi25EncryptedHashEntry_t;
 /* values for HashImageType */
 #define MPI25_HASH_IMAGE_TYPE_UNUSED            (0x00)
 #define MPI25_HASH_IMAGE_TYPE_FIRMWARE          (0x01)
+#define MPI25_HASH_IMAGE_TYPE_BIOS              (0x02)
 
 /* values for HashAlgorithm */
 #define MPI25_HASH_ALGORITHM_UNUSED             (0x00)
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_tool.h b/drivers/scsi/mpt2sas/mpi/mpi2_tool.h
index 9be03ed46180..659b8ac83ceb 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.11
+ *    mpi2_tool.h Version:  02.00.12
  *
  *  Version History
  *  ---------------
@@ -29,7 +29,8 @@
  *                      MPI2_TOOLBOX_ISTWI_READ_WRITE_REQUEST.
  *  07-26-12  02.00.10  Modified MPI2_TOOLBOX_DIAGNOSTIC_CLI_REQUEST so that
  *                      it uses MPI Chain SGE as well as MPI Simple SGE.
- * 08-19-13  02.00.11  Added MPI2_TOOLBOX_TEXT_DISPLAY_TOOL and related info.
+ *  08-19-13  02.00.11  Added MPI2_TOOLBOX_TEXT_DISPLAY_TOOL and related info.
+ *  01-08-14  02.00.12  Added MPI2_TOOLBOX_CLEAN_BIT26_PRODUCT_SPECIFIC.
  *  --------------------------------------------------------------------------
  */
 
@@ -101,6 +102,7 @@ typedef struct _MPI2_TOOLBOX_CLEAN_REQUEST
 #define MPI2_TOOLBOX_CLEAN_OTHER_PERSIST_PAGES      (0x20000000)
 #define MPI2_TOOLBOX_CLEAN_FW_CURRENT               (0x10000000)
 #define MPI2_TOOLBOX_CLEAN_FW_BACKUP                (0x08000000)
+#define MPI2_TOOLBOX_CLEAN_BIT26_PRODUCT_SPECIFIC   (0x04000000)
 #define MPI2_TOOLBOX_CLEAN_MEGARAID                 (0x02000000)
 #define MPI2_TOOLBOX_CLEAN_INITIALIZATION           (0x01000000)
 #define MPI2_TOOLBOX_CLEAN_FLASH                    (0x00000004)
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.c b/drivers/scsi/mpt2sas/mpt2sas_base.c
index 58e45216d1ec..11248de92b3b 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.c
@@ -4,7 +4,8 @@
  *
  * This code is based on drivers/scsi/mpt2sas/mpt2_base.c
  * Copyright (C) 2007-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 20013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -639,6 +640,9 @@ _base_display_event_data(struct MPT2SAS_ADAPTER *ioc,
                 if (!ioc->hide_ir_msg)
                         desc = "Log Entry Added";
                 break;
+        case MPI2_EVENT_TEMP_THRESHOLD:
+                desc = "Temperature Threshold";
+                break;
         }
 
         if (!desc)
@@ -1296,6 +1300,8 @@ _base_free_irq(struct MPT2SAS_ADAPTER *ioc)
 
         list_for_each_entry_safe(reply_q, next, &ioc->reply_queue_list, list) {
                 list_del(&reply_q->list);
+                irq_set_affinity_hint(reply_q->vector, NULL);
+                free_cpumask_var(reply_q->affinity_hint);
                 synchronize_irq(reply_q->vector);
                 free_irq(reply_q->vector, reply_q);
                 kfree(reply_q);
@@ -1325,6 +1331,11 @@ _base_request_irq(struct MPT2SAS_ADAPTER *ioc, u8 index, u32 vector)
         reply_q->ioc = ioc;
         reply_q->msix_index = index;
         reply_q->vector = vector;
+
+        if (!alloc_cpumask_var(&reply_q->affinity_hint, GFP_KERNEL))
+                return -ENOMEM;
+        cpumask_clear(reply_q->affinity_hint);
+
         atomic_set(&reply_q->busy, 0);
         if (ioc->msix_enable)
                 snprintf(reply_q->name, MPT_NAME_LENGTH, "%s%d-msix%d",
@@ -1359,6 +1370,7 @@ static void
 _base_assign_reply_queues(struct MPT2SAS_ADAPTER *ioc)
 {
         unsigned int cpu, nr_cpus, nr_msix, index = 0;
+        struct adapter_reply_queue *reply_q;
 
         if (!_base_is_controller_msix_enabled(ioc))
                 return;
@@ -1373,20 +1385,30 @@ _base_assign_reply_queues(struct MPT2SAS_ADAPTER *ioc)
 
         cpu = cpumask_first(cpu_online_mask);
 
-        do {
+        list_for_each_entry(reply_q, &ioc->reply_queue_list, list) {
+
                 unsigned int i, group = nr_cpus / nr_msix;
 
+                if (cpu >= nr_cpus)
+                        break;
+
                 if (index < nr_cpus % nr_msix)
                         group++;
 
                 for (i = 0 ; i < group ; i++) {
                         ioc->cpu_msix_table[cpu] = index;
+                        cpumask_or(reply_q->affinity_hint,
+                                   reply_q->affinity_hint, get_cpu_mask(cpu));
                         cpu = cpumask_next(cpu, cpu_online_mask);
                 }
 
+                if (irq_set_affinity_hint(reply_q->vector,
+                                           reply_q->affinity_hint))
+                        dinitprintk(ioc, pr_info(MPT2SAS_FMT
+                            "error setting affinity hint for irq vector %d\n",
+                            ioc->name, reply_q->vector));
                 index++;
-
-        } while (cpu < nr_cpus);
+        }
 }
 
 /**
@@ -2338,6 +2360,7 @@ _base_static_config_pages(struct MPT2SAS_ADAPTER *ioc)
         mpt2sas_config_get_ioc_pg8(ioc, &mpi_reply, &ioc->ioc_pg8);
         mpt2sas_config_get_iounit_pg0(ioc, &mpi_reply, &ioc->iounit_pg0);
         mpt2sas_config_get_iounit_pg1(ioc, &mpi_reply, &ioc->iounit_pg1);
+        mpt2sas_config_get_iounit_pg8(ioc, &mpi_reply, &ioc->iounit_pg8);
         _base_display_ioc_capabilities(ioc);
 
         /*
@@ -2355,6 +2378,8 @@ _base_static_config_pages(struct MPT2SAS_ADAPTER *ioc)
         ioc->iounit_pg1.Flags = cpu_to_le32(iounit_pg1_flags);
         mpt2sas_config_set_iounit_pg1(ioc, &mpi_reply, &ioc->iounit_pg1);
 
+        if (ioc->iounit_pg8.NumSensors)
+                ioc->temp_sensors_count = ioc->iounit_pg8.NumSensors;
 }
 
 /**
@@ -2486,9 +2511,13 @@ _base_allocate_memory_pools(struct MPT2SAS_ADAPTER *ioc,  int sleep_flag)
 
         /* command line tunables  for max sgl entries */
         if (max_sgl_entries != -1) {
-                ioc->shost->sg_tablesize = (max_sgl_entries <
-                    MPT2SAS_SG_DEPTH) ? max_sgl_entries :
-                    MPT2SAS_SG_DEPTH;
+                ioc->shost->sg_tablesize =  min_t(unsigned short,
+                             max_sgl_entries, SCSI_MAX_SG_CHAIN_SEGMENTS);
+                if (ioc->shost->sg_tablesize > MPT2SAS_SG_DEPTH)
+                        printk(MPT2SAS_WARN_FMT
+                         "sg_tablesize(%u) is bigger than kernel defined"
+                         " SCSI_MAX_SG_SEGMENTS(%u)\n", ioc->name,
+                          ioc->shost->sg_tablesize, MPT2SAS_SG_DEPTH);
         } else {
                 ioc->shost->sg_tablesize = MPT2SAS_SG_DEPTH;
         }
@@ -3236,7 +3265,7 @@ mpt2sas_base_sas_iounit_control(struct MPT2SAS_ADAPTER *ioc,
         u16 smid;
         u32 ioc_state;
         unsigned long timeleft;
-        u8 issue_reset;
+        bool issue_reset = false;
         int rc;
         void *request;
         u16 wait_state_count;
@@ -3300,7 +3329,7 @@ mpt2sas_base_sas_iounit_control(struct MPT2SAS_ADAPTER *ioc,
                 _debug_dump_mf(mpi_request,
                     sizeof(Mpi2SasIoUnitControlRequest_t)/4);
                 if (!(ioc->base_cmds.status & MPT2_CMD_RESET))
-                        issue_reset = 1;
+                        issue_reset = true;
                 goto issue_host_reset;
         }
         if (ioc->base_cmds.status & MPT2_CMD_REPLY_VALID)
@@ -3341,7 +3370,7 @@ mpt2sas_base_scsi_enclosure_processor(struct MPT2SAS_ADAPTER *ioc,
         u16 smid;
         u32 ioc_state;
         unsigned long timeleft;
-        u8 issue_reset;
+        bool issue_reset = false;
         int rc;
         void *request;
         u16 wait_state_count;
@@ -3398,7 +3427,7 @@ mpt2sas_base_scsi_enclosure_processor(struct MPT2SAS_ADAPTER *ioc,
                 _debug_dump_mf(mpi_request,
                     sizeof(Mpi2SepRequest_t)/4);
                 if (!(ioc->base_cmds.status & MPT2_CMD_RESET))
-                        issue_reset = 1;
+                        issue_reset = true;
                 goto issue_host_reset;
         }
         if (ioc->base_cmds.status & MPT2_CMD_REPLY_VALID)
@@ -4594,6 +4623,7 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
         _base_unmask_events(ioc, MPI2_EVENT_IR_PHYSICAL_DISK);
         _base_unmask_events(ioc, MPI2_EVENT_IR_OPERATION_STATUS);
         _base_unmask_events(ioc, MPI2_EVENT_LOG_ENTRY_ADDED);
+        _base_unmask_events(ioc, MPI2_EVENT_TEMP_THRESHOLD);
         r = _base_make_ioc_operational(ioc, CAN_SLEEP);
         if (r)
                 goto out_free_resources;
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.h b/drivers/scsi/mpt2sas/mpt2sas_base.h
index 239f169b0673..caff8d10cca4 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.h
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.h
@@ -4,7 +4,8 @@
  *
  * This code is based on drivers/scsi/mpt2sas/mpt2_base.h
  * Copyright (C) 2007-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 20013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -67,10 +68,10 @@
 
 /* driver versioning info */
 #define MPT2SAS_DRIVER_NAME             "mpt2sas"
-#define MPT2SAS_AUTHOR  "LSI Corporation <DL-MPTFusionLinux@lsi.com>"
+#define MPT2SAS_AUTHOR "Avago Technologies <MPT-FusionLinux.pdl@avagotech.com>"
 #define MPT2SAS_DESCRIPTION     "LSI MPT Fusion SAS 2.0 Device Driver"
-#define MPT2SAS_DRIVER_VERSION          "18.100.00.00"
-#define MPT2SAS_MAJOR_VERSION           18
+#define MPT2SAS_DRIVER_VERSION          "20.100.00.00"
+#define MPT2SAS_MAJOR_VERSION           20
 #define MPT2SAS_MINOR_VERSION           100
 #define MPT2SAS_BUILD_VERSION           00
 #define MPT2SAS_RELEASE_VERSION         00
@@ -586,6 +587,7 @@ struct adapter_reply_queue {
         Mpi2ReplyDescriptorsUnion_t *reply_post_free;
         char                    name[MPT_NAME_LENGTH];
         atomic_t                busy;
+        cpumask_var_t           affinity_hint;
         struct list_head        list;
 };
 
@@ -725,6 +727,7 @@ typedef void (*MPT2SAS_FLUSH_RUNNING_CMDS)(struct MPT2SAS_ADAPTER *ioc);
  * @ioc_pg8: static ioc page 8
  * @iounit_pg0: static iounit page 0
  * @iounit_pg1: static iounit page 1
+ * @iounit_pg8: static iounit page 8
  * @sas_hba: sas host object
  * @sas_expander_list: expander object list
  * @sas_node_lock:
@@ -795,6 +798,7 @@ typedef void (*MPT2SAS_FLUSH_RUNNING_CMDS)(struct MPT2SAS_ADAPTER *ioc);
  * @reply_post_host_index: head index in the pool where FW completes IO
  * @delayed_tr_list: target reset link list
  * @delayed_tr_volume_list: volume target reset link list
+ * @@temp_sensors_count: flag to carry the number of temperature sensors
  */
 struct MPT2SAS_ADAPTER {
         struct list_head list;
@@ -892,6 +896,7 @@ struct MPT2SAS_ADAPTER {
         Mpi2IOCPage8_t ioc_pg8;
         Mpi2IOUnitPage0_t iounit_pg0;
         Mpi2IOUnitPage1_t iounit_pg1;
+        Mpi2IOUnitPage8_t iounit_pg8;
 
         struct _boot_device req_boot_device;
         struct _boot_device req_alt_boot_device;
@@ -992,6 +997,7 @@ struct MPT2SAS_ADAPTER {
 
         struct list_head delayed_tr_list;
         struct list_head delayed_tr_volume_list;
+        u8              temp_sensors_count;
 
         /* diag buffer support */
         u8              *diag_buffer[MPI2_DIAG_BUF_TYPE_COUNT];
@@ -1120,6 +1126,8 @@ int mpt2sas_config_get_iounit_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
     *mpi_reply, Mpi2IOUnitPage1_t *config_page);
 int mpt2sas_config_set_iounit_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
     *mpi_reply, Mpi2IOUnitPage1_t *config_page);
+int mpt2sas_config_get_iounit_pg8(struct MPT2SAS_ADAPTER *ioc,
+        Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage8_t *config_page);
 int mpt2sas_config_get_iounit_pg3(struct MPT2SAS_ADAPTER *ioc,
         Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage3_t *config_page, u16 sz);
 int mpt2sas_config_get_sas_iounit_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
diff --git a/drivers/scsi/mpt2sas/mpt2sas_config.c b/drivers/scsi/mpt2sas/mpt2sas_config.c
index c72a2fff5dbb..c43815b1a485 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_config.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_config.c
@@ -3,7 +3,8 @@
  *
  * This code is based on drivers/scsi/mpt2sas/mpt2_base.c
  * Copyright (C) 2007-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 20013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -719,6 +720,42 @@ mpt2sas_config_get_iounit_pg3(struct MPT2SAS_ADAPTER *ioc,
 }
 
 /**
+ * mpt2sas_config_get_iounit_pg8 - obtain iounit page 8
+ * @ioc: per adapter object
+ * @mpi_reply: reply mf payload returned from firmware
+ * @config_page: contents of the config page
+ * Context: sleep.
+ *
+ * Returns 0 for success, non-zero for failure.
+ */
+int
+mpt2sas_config_get_iounit_pg8(struct MPT2SAS_ADAPTER *ioc,
+        Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage8_t *config_page)
+{
+        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_IO_UNIT;
+        mpi_request.Header.PageNumber = 8;
+        mpi_request.Header.PageVersion = MPI2_IOUNITPAGE8_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_READ_CURRENT;
+        r = _config_request(ioc, &mpi_request, mpi_reply,
+            MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
+            sizeof(*config_page));
+ out:
+        return r;
+}
+
+/**
  * mpt2sas_config_get_ioc_pg8 - obtain ioc page 8
  * @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 ca4e563c01dd..4e509604b571 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_ctl.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
@@ -4,7 +4,8 @@
  *
  * This code is based on drivers/scsi/mpt2sas/mpt2_ctl.c
  * Copyright (C) 2007-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 20013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/drivers/scsi/mpt2sas/mpt2sas_ctl.h b/drivers/scsi/mpt2sas/mpt2sas_ctl.h
index 7f842c88abd2..46b2fc5b74af 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_ctl.h
+++ b/drivers/scsi/mpt2sas/mpt2sas_ctl.h
@@ -4,7 +4,8 @@
  *
  * This code is based on drivers/scsi/mpt2sas/mpt2_ctl.h
  * Copyright (C) 2007-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 20013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/drivers/scsi/mpt2sas/mpt2sas_debug.h b/drivers/scsi/mpt2sas/mpt2sas_debug.h
index cc57ef31d0fe..277120d45648 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_debug.h
+++ b/drivers/scsi/mpt2sas/mpt2sas_debug.h
@@ -3,7 +3,8 @@
  *
  * This code is based on drivers/scsi/mpt2sas/mpt2_debug.c
  * Copyright (C) 2007-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 20013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/drivers/scsi/mpt2sas/mpt2sas_scsih.c b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
index 6a1c036a6f3f..3f26147bbc64 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_scsih.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
@@ -3,7 +3,8 @@
  *
  * This code is based on drivers/scsi/mpt2sas/mpt2_scsih.c
  * Copyright (C) 2007-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 20013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -2729,9 +2730,18 @@ _scsih_host_reset(struct scsi_cmnd *scmd)
             ioc->name, scmd);
         scsi_print_command(scmd);
 
+        if (ioc->is_driver_loading) {
+                printk(MPT2SAS_INFO_FMT "Blocking the host reset\n",
+                                                          ioc->name);
+                r = FAILED;
+                goto out;
+        }
+
         retval = mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
             FORCE_BIG_HAMMER);
         r = (retval < 0) ? FAILED : SUCCESS;
+
+ out:
         printk(MPT2SAS_INFO_FMT "host reset: %s scmd(%p)\n",
             ioc->name, ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
 
@@ -3647,6 +3657,31 @@ _scsih_check_volume_delete_events(struct MPT2SAS_ADAPTER *ioc,
 }
 
 /**
+ * _scsih_temp_threshold_events - display temperature threshold exceeded events
+ * @ioc: per adapter object
+ * @event_data: the temp threshold event data
+ * Context: interrupt time.
+ *
+ * Return nothing.
+ */
+static void
+_scsih_temp_threshold_events(struct MPT2SAS_ADAPTER *ioc,
+        Mpi2EventDataTemperature_t *event_data)
+{
+        if (ioc->temp_sensors_count >= event_data->SensorNum) {
+                printk(MPT2SAS_ERR_FMT "Temperature Threshold flags %s%s%s%s"
+                  " exceeded for Sensor: %d !!!\n", ioc->name,
+                  ((le16_to_cpu(event_data->Status) & 0x1) == 1) ? "0 " : " ",
+                  ((le16_to_cpu(event_data->Status) & 0x2) == 2) ? "1 " : " ",
+                  ((le16_to_cpu(event_data->Status) & 0x4) == 4) ? "2 " : " ",
+                  ((le16_to_cpu(event_data->Status) & 0x8) == 8) ? "3 " : " ",
+                  event_data->SensorNum);
+                printk(MPT2SAS_ERR_FMT "Current Temp In Celsius: %d\n",
+                        ioc->name, event_data->CurrentTemperature);
+        }
+}
+
+/**
  * _scsih_flush_running_cmds - completing outstanding commands.
  * @ioc: per adapter object
  *
@@ -4509,6 +4544,10 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
                         scmd->result = DID_TRANSPORT_DISRUPTED << 16;
                         goto out;
                 }
+                if (log_info == 0x32010081) {
+                        scmd->result = DID_RESET << 16;
+                        break;
+                }
                 scmd->result = DID_SOFT_ERROR << 16;
                 break;
         case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED:
@@ -7557,6 +7596,12 @@ mpt2sas_scsih_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index,
         case MPI2_EVENT_IR_PHYSICAL_DISK:
                 break;
 
+        case MPI2_EVENT_TEMP_THRESHOLD:
+                _scsih_temp_threshold_events(ioc,
+                        (Mpi2EventDataTemperature_t *)
+                        mpi_reply->EventData);
+                break;
+
         default: /* ignore the rest */
                 return;
         }
diff --git a/drivers/scsi/mpt2sas/mpt2sas_transport.c b/drivers/scsi/mpt2sas/mpt2sas_transport.c
index e689bf20a3ea..ff2500ab9ba4 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_transport.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_transport.c
@@ -3,7 +3,8 @@
  *
  * This code is based on drivers/scsi/mpt2sas/mpt2_transport.c
  * Copyright (C) 2007-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 20013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/drivers/scsi/mpt3sas/mpt3sas_base.c b/drivers/scsi/mpt3sas/mpt3sas_base.c
index 1560115079c7..14a781b6b88d 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_base.c
+++ b/drivers/scsi/mpt3sas/mpt3sas_base.c
@@ -4,7 +4,8 @@
  *
  * This code is based on drivers/scsi/mpt3sas/mpt3sas_base.c
  * Copyright (C) 2012-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 2013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -619,6 +620,9 @@ _base_display_event_data(struct MPT3SAS_ADAPTER *ioc,
         case MPI2_EVENT_LOG_ENTRY_ADDED:
                 desc = "Log Entry Added";
                 break;
+        case MPI2_EVENT_TEMP_THRESHOLD:
+                desc = "Temperature Threshold";
+                break;
         }
 
         if (!desc)
@@ -1580,6 +1584,8 @@ _base_free_irq(struct MPT3SAS_ADAPTER *ioc)
 
         list_for_each_entry_safe(reply_q, next, &ioc->reply_queue_list, list) {
                 list_del(&reply_q->list);
+                irq_set_affinity_hint(reply_q->vector, NULL);
+                free_cpumask_var(reply_q->affinity_hint);
                 synchronize_irq(reply_q->vector);
                 free_irq(reply_q->vector, reply_q);
                 kfree(reply_q);
@@ -1609,6 +1615,11 @@ _base_request_irq(struct MPT3SAS_ADAPTER *ioc, u8 index, u32 vector)
         reply_q->ioc = ioc;
         reply_q->msix_index = index;
         reply_q->vector = vector;
+
+        if (!alloc_cpumask_var(&reply_q->affinity_hint, GFP_KERNEL))
+                return -ENOMEM;
+        cpumask_clear(reply_q->affinity_hint);
+
         atomic_set(&reply_q->busy, 0);
         if (ioc->msix_enable)
                 snprintf(reply_q->name, MPT_NAME_LENGTH, "%s%d-msix%d",
@@ -1643,6 +1654,7 @@ static void
 _base_assign_reply_queues(struct MPT3SAS_ADAPTER *ioc)
 {
         unsigned int cpu, nr_cpus, nr_msix, index = 0;
+        struct adapter_reply_queue *reply_q;
 
         if (!_base_is_controller_msix_enabled(ioc))
                 return;
@@ -1657,20 +1669,30 @@ _base_assign_reply_queues(struct MPT3SAS_ADAPTER *ioc)
 
         cpu = cpumask_first(cpu_online_mask);
 
-        do {
+        list_for_each_entry(reply_q, &ioc->reply_queue_list, list) {
+
                 unsigned int i, group = nr_cpus / nr_msix;
 
+                if (cpu >= nr_cpus)
+                        break;
+
                 if (index < nr_cpus % nr_msix)
                         group++;
 
                 for (i = 0 ; i < group ; i++) {
                         ioc->cpu_msix_table[cpu] = index;
+                        cpumask_or(reply_q->affinity_hint,
+                                   reply_q->affinity_hint, get_cpu_mask(cpu));
                         cpu = cpumask_next(cpu, cpu_online_mask);
                 }
 
+                if (irq_set_affinity_hint(reply_q->vector,
+                                           reply_q->affinity_hint))
+                        dinitprintk(ioc, pr_info(MPT3SAS_FMT
+                            "error setting affinity hint for irq vector %d\n",
+                            ioc->name, reply_q->vector));
                 index++;
-
-        } while (cpu < nr_cpus);
+        }
 }
 
 /**
@@ -2500,6 +2522,7 @@ _base_static_config_pages(struct MPT3SAS_ADAPTER *ioc)
         mpt3sas_config_get_ioc_pg8(ioc, &mpi_reply, &ioc->ioc_pg8);
         mpt3sas_config_get_iounit_pg0(ioc, &mpi_reply, &ioc->iounit_pg0);
         mpt3sas_config_get_iounit_pg1(ioc, &mpi_reply, &ioc->iounit_pg1);
+        mpt3sas_config_get_iounit_pg8(ioc, &mpi_reply, &ioc->iounit_pg8);
         _base_display_ioc_capabilities(ioc);
 
         /*
@@ -2516,6 +2539,9 @@ _base_static_config_pages(struct MPT3SAS_ADAPTER *ioc)
                     MPI2_IOUNITPAGE1_DISABLE_TASK_SET_FULL_HANDLING;
         ioc->iounit_pg1.Flags = cpu_to_le32(iounit_pg1_flags);
         mpt3sas_config_set_iounit_pg1(ioc, &mpi_reply, &ioc->iounit_pg1);
+
+        if (ioc->iounit_pg8.NumSensors)
+                ioc->temp_sensors_count = ioc->iounit_pg8.NumSensors;
 }
 
 /**
@@ -2659,8 +2685,14 @@ _base_allocate_memory_pools(struct MPT3SAS_ADAPTER *ioc,  int sleep_flag)
 
         if (sg_tablesize < MPT3SAS_MIN_PHYS_SEGMENTS)
                 sg_tablesize = MPT3SAS_MIN_PHYS_SEGMENTS;
-        else if (sg_tablesize > MPT3SAS_MAX_PHYS_SEGMENTS)
-                sg_tablesize = MPT3SAS_MAX_PHYS_SEGMENTS;
+        else if (sg_tablesize > MPT3SAS_MAX_PHYS_SEGMENTS) {
+                sg_tablesize = min_t(unsigned short, sg_tablesize,
+                                      SCSI_MAX_SG_CHAIN_SEGMENTS);
+                pr_warn(MPT3SAS_FMT
+                 "sg_tablesize(%u) is bigger than kernel"
+                 " defined SCSI_MAX_SG_SEGMENTS(%u)\n", ioc->name,
+                 sg_tablesize, MPT3SAS_MAX_PHYS_SEGMENTS);
+        }
         ioc->shost->sg_tablesize = sg_tablesize;
 
         ioc->hi_priority_depth = facts->HighPriorityCredit;
@@ -3419,7 +3451,7 @@ mpt3sas_base_sas_iounit_control(struct MPT3SAS_ADAPTER *ioc,
         u16 smid;
         u32 ioc_state;
         unsigned long timeleft;
-        u8 issue_reset;
+        bool issue_reset = false;
         int rc;
         void *request;
         u16 wait_state_count;
@@ -3483,7 +3515,7 @@ mpt3sas_base_sas_iounit_control(struct MPT3SAS_ADAPTER *ioc,
                 _debug_dump_mf(mpi_request,
                     sizeof(Mpi2SasIoUnitControlRequest_t)/4);
                 if (!(ioc->base_cmds.status & MPT3_CMD_RESET))
-                        issue_reset = 1;
+                        issue_reset = true;
                 goto issue_host_reset;
         }
         if (ioc->base_cmds.status & MPT3_CMD_REPLY_VALID)
@@ -3523,7 +3555,7 @@ mpt3sas_base_scsi_enclosure_processor(struct MPT3SAS_ADAPTER *ioc,
         u16 smid;
         u32 ioc_state;
         unsigned long timeleft;
-        u8 issue_reset;
+        bool issue_reset = false;
         int rc;
         void *request;
         u16 wait_state_count;
@@ -3581,7 +3613,7 @@ mpt3sas_base_scsi_enclosure_processor(struct MPT3SAS_ADAPTER *ioc,
                 _debug_dump_mf(mpi_request,
                     sizeof(Mpi2SepRequest_t)/4);
                 if (!(ioc->base_cmds.status & MPT3_CMD_RESET))
-                        issue_reset = 1;
+                        issue_reset = false;
                 goto issue_host_reset;
         }
         if (ioc->base_cmds.status & MPT3_CMD_REPLY_VALID)
@@ -4720,6 +4752,7 @@ mpt3sas_base_attach(struct MPT3SAS_ADAPTER *ioc)
         _base_unmask_events(ioc, MPI2_EVENT_IR_PHYSICAL_DISK);
         _base_unmask_events(ioc, MPI2_EVENT_IR_OPERATION_STATUS);
         _base_unmask_events(ioc, MPI2_EVENT_LOG_ENTRY_ADDED);
+        _base_unmask_events(ioc, MPI2_EVENT_TEMP_THRESHOLD);
 
         r = _base_make_ioc_operational(ioc, CAN_SLEEP);
         if (r)
diff --git a/drivers/scsi/mpt3sas/mpt3sas_base.h b/drivers/scsi/mpt3sas/mpt3sas_base.h
index 40926aa9b24d..afa881682bef 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_base.h
+++ b/drivers/scsi/mpt3sas/mpt3sas_base.h
@@ -4,7 +4,8 @@
  *
  * This code is based on drivers/scsi/mpt3sas/mpt3sas_base.h
  * Copyright (C) 2012-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 2013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -68,7 +69,7 @@
 
 /* driver versioning info */
 #define MPT3SAS_DRIVER_NAME             "mpt3sas"
-#define MPT3SAS_AUTHOR  "LSI Corporation <DL-MPTFusionLinux@lsi.com>"
+#define MPT3SAS_AUTHOR "Avago Technologies <MPT-FusionLinux.pdl@avagotech.com>"
 #define MPT3SAS_DESCRIPTION     "LSI MPT Fusion SAS 3.0 Device Driver"
 #define MPT3SAS_DRIVER_VERSION          "04.100.00.00"
 #define MPT3SAS_MAJOR_VERSION           4
@@ -506,6 +507,7 @@ struct adapter_reply_queue {
         Mpi2ReplyDescriptorsUnion_t *reply_post_free;
         char                    name[MPT_NAME_LENGTH];
         atomic_t                busy;
+        cpumask_var_t           affinity_hint;
         struct list_head        list;
 };
 
@@ -659,6 +661,7 @@ typedef void (*MPT3SAS_FLUSH_RUNNING_CMDS)(struct MPT3SAS_ADAPTER *ioc);
  * @ioc_pg8: static ioc page 8
  * @iounit_pg0: static iounit page 0
  * @iounit_pg1: static iounit page 1
+ * @iounit_pg8: static iounit page 8
  * @sas_hba: sas host object
  * @sas_expander_list: expander object list
  * @sas_node_lock:
@@ -728,6 +731,7 @@ typedef void (*MPT3SAS_FLUSH_RUNNING_CMDS)(struct MPT3SAS_ADAPTER *ioc);
  * @reply_post_host_index: head index in the pool where FW completes IO
  * @delayed_tr_list: target reset link list
  * @delayed_tr_volume_list: volume target reset link list
+ * @@temp_sensors_count: flag to carry the number of temperature sensors
  */
 struct MPT3SAS_ADAPTER {
         struct list_head list;
@@ -834,6 +838,7 @@ struct MPT3SAS_ADAPTER {
         Mpi2IOCPage8_t ioc_pg8;
         Mpi2IOUnitPage0_t iounit_pg0;
         Mpi2IOUnitPage1_t iounit_pg1;
+        Mpi2IOUnitPage8_t iounit_pg8;
 
         struct _boot_device req_boot_device;
         struct _boot_device req_alt_boot_device;
@@ -934,6 +939,7 @@ struct MPT3SAS_ADAPTER {
 
         struct list_head delayed_tr_list;
         struct list_head delayed_tr_volume_list;
+        u8              temp_sensors_count;
 
         /* diag buffer support */
         u8              *diag_buffer[MPI2_DIAG_BUF_TYPE_COUNT];
@@ -1082,6 +1088,8 @@ int mpt3sas_config_get_iounit_pg1(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
         *mpi_reply, Mpi2IOUnitPage1_t *config_page);
 int mpt3sas_config_set_iounit_pg1(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
         *mpi_reply, Mpi2IOUnitPage1_t *config_page);
+int mpt3sas_config_get_iounit_pg8(struct MPT3SAS_ADAPTER *ioc, Mpi2ConfigReply_t
+        *mpi_reply, Mpi2IOUnitPage8_t *config_page);
 int mpt3sas_config_get_sas_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
         Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage1_t *config_page,
         u16 sz);
diff --git a/drivers/scsi/mpt3sas/mpt3sas_config.c b/drivers/scsi/mpt3sas/mpt3sas_config.c
index 4472c2af9255..e45c4613ef0c 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_config.c
+++ b/drivers/scsi/mpt3sas/mpt3sas_config.c
@@ -3,7 +3,8 @@
  *
  * This code is based on drivers/scsi/mpt3sas/mpt3sas_base.c
  * Copyright (C) 2012-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 2013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -871,6 +872,42 @@ mpt3sas_config_set_iounit_pg1(struct MPT3SAS_ADAPTER *ioc,
 }
 
 /**
+ * mpt3sas_config_get_iounit_pg8 - obtain iounit page 8
+ * @ioc: per adapter object
+ * @mpi_reply: reply mf payload returned from firmware
+ * @config_page: contents of the config page
+ * Context: sleep.
+ *
+ * Returns 0 for success, non-zero for failure.
+ */
+int
+mpt3sas_config_get_iounit_pg8(struct MPT3SAS_ADAPTER *ioc,
+        Mpi2ConfigReply_t *mpi_reply, Mpi2IOUnitPage8_t *config_page)
+{
+        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_IO_UNIT;
+        mpi_request.Header.PageNumber = 8;
+        mpi_request.Header.PageVersion = MPI2_IOUNITPAGE8_PAGEVERSION;
+        ioc->build_zero_len_sge_mpi(ioc, &mpi_request.PageBufferSGE);
+        r = _config_request(ioc, &mpi_request, mpi_reply,
+            MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
+        if (r)
+                goto out;
+
+        mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_READ_CURRENT;
+        r = _config_request(ioc, &mpi_request, mpi_reply,
+            MPT3_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page,
+            sizeof(*config_page));
+ out:
+        return r;
+}
+
+/**
  * mpt3sas_config_get_ioc_pg8 - obtain ioc page 8
  * @ioc: per adapter object
  * @mpi_reply: reply mf payload returned from firmware
diff --git a/drivers/scsi/mpt3sas/mpt3sas_ctl.c b/drivers/scsi/mpt3sas/mpt3sas_ctl.c
index dca14877d5ab..080c8a76d23d 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_ctl.c
+++ b/drivers/scsi/mpt3sas/mpt3sas_ctl.c
@@ -4,7 +4,8 @@
  *
  * This code is based on drivers/scsi/mpt3sas/mpt3sas_ctl.c
  * Copyright (C) 2012-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 2013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/drivers/scsi/mpt3sas/mpt3sas_ctl.h b/drivers/scsi/mpt3sas/mpt3sas_ctl.h
index 5f3d7fd7c2f8..aee99ce67e54 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_ctl.h
+++ b/drivers/scsi/mpt3sas/mpt3sas_ctl.h
@@ -4,7 +4,8 @@
  *
  * This code is based on drivers/scsi/mpt3sas/mpt3sas_ctl.h
  * Copyright (C) 2012-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 2013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/drivers/scsi/mpt3sas/mpt3sas_debug.h b/drivers/scsi/mpt3sas/mpt3sas_debug.h
index 4778e7dd98bd..4e8a63fdb304 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_debug.h
+++ b/drivers/scsi/mpt3sas/mpt3sas_debug.h
@@ -3,7 +3,8 @@
  *
  * This code is based on drivers/scsi/mpt3sas/mpt3sas_debug.c
  * Copyright (C) 2012-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 2013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/drivers/scsi/mpt3sas/mpt3sas_scsih.c b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
index 94261ee9e72d..5a97e3286719 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_scsih.c
+++ b/drivers/scsi/mpt3sas/mpt3sas_scsih.c
@@ -3,7 +3,8 @@
  *
  * This code is based on drivers/scsi/mpt3sas/mpt3sas_scsih.c
  * Copyright (C) 2012-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 2013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -2392,9 +2393,17 @@ _scsih_host_reset(struct scsi_cmnd *scmd)
             ioc->name, scmd);
         scsi_print_command(scmd);
 
+        if (ioc->is_driver_loading) {
+                pr_info(MPT3SAS_FMT "Blocking the host reset\n",
+                    ioc->name);
+                r = FAILED;
+                goto out;
+        }
+
         retval = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP,
             FORCE_BIG_HAMMER);
         r = (retval < 0) ? FAILED : SUCCESS;
+out:
         pr_info(MPT3SAS_FMT "host reset: %s scmd(%p)\n",
             ioc->name, ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd);
 
@@ -3342,6 +3351,31 @@ _scsih_check_volume_delete_events(struct MPT3SAS_ADAPTER *ioc,
 }
 
 /**
+ * _scsih_temp_threshold_events - display temperature threshold exceeded events
+ * @ioc: per adapter object
+ * @event_data: the temp threshold event data
+ * Context: interrupt time.
+ *
+ * Return nothing.
+ */
+static void
+_scsih_temp_threshold_events(struct MPT3SAS_ADAPTER *ioc,
+        Mpi2EventDataTemperature_t *event_data)
+{
+        if (ioc->temp_sensors_count >= event_data->SensorNum) {
+                pr_err(MPT3SAS_FMT "Temperature Threshold flags %s%s%s%s"
+                  " exceeded for Sensor: %d !!!\n", ioc->name,
+                  ((le16_to_cpu(event_data->Status) & 0x1) == 1) ? "0 " : " ",
+                  ((le16_to_cpu(event_data->Status) & 0x2) == 2) ? "1 " : " ",
+                  ((le16_to_cpu(event_data->Status) & 0x4) == 4) ? "2 " : " ",
+                  ((le16_to_cpu(event_data->Status) & 0x8) == 8) ? "3 " : " ",
+                  event_data->SensorNum);
+                pr_err(MPT3SAS_FMT "Current Temp In Celsius: %d\n",
+                        ioc->name, event_data->CurrentTemperature);
+        }
+}
+
+/**
  * _scsih_flush_running_cmds - completing outstanding commands.
  * @ioc: per adapter object
  *
@@ -7194,6 +7228,12 @@ mpt3sas_scsih_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index,
         case MPI2_EVENT_IR_PHYSICAL_DISK:
                 break;
 
+        case MPI2_EVENT_TEMP_THRESHOLD:
+                _scsih_temp_threshold_events(ioc,
+                        (Mpi2EventDataTemperature_t *)
+                        mpi_reply->EventData);
+                break;
+
         default: /* ignore the rest */
                 return 1;
         }
diff --git a/drivers/scsi/mpt3sas/mpt3sas_transport.c b/drivers/scsi/mpt3sas/mpt3sas_transport.c
index 3637ae6c0171..efb98afc46e0 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_transport.c
+++ b/drivers/scsi/mpt3sas/mpt3sas_transport.c
@@ -3,7 +3,8 @@
  *
  * This code is based on drivers/scsi/mpt3sas/mpt3sas_transport.c
  * Copyright (C) 2012-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 2013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/drivers/scsi/mpt3sas/mpt3sas_trigger_diag.c b/drivers/scsi/mpt3sas/mpt3sas_trigger_diag.c
index 8a2dd113f401..b60fd7a3b571 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_trigger_diag.c
+++ b/drivers/scsi/mpt3sas/mpt3sas_trigger_diag.c
@@ -4,7 +4,8 @@
  *
  * This code is based on drivers/scsi/mpt3sas/mpt3sas_trigger_diag.c
  * Copyright (C) 2012-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 2013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/drivers/scsi/mpt3sas/mpt3sas_trigger_diag.h b/drivers/scsi/mpt3sas/mpt3sas_trigger_diag.h
index f681db56c53b..6586a463bea9 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_trigger_diag.h
+++ b/drivers/scsi/mpt3sas/mpt3sas_trigger_diag.h
@@ -5,7 +5,8 @@
  *
  * This code is based on drivers/scsi/mpt3sas/mpt3sas_base.h
  * Copyright (C) 2012-2014  LSI Corporation
- *  (mailto:DL-MPTFusionLinux@lsi.com)
+ * Copyright (C) 2013-2014 Avago Technologies
+ *  (mailto: MPT-FusionLinux.pdl@avagotech.com)
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
diff --git a/drivers/scsi/nsp32.c b/drivers/scsi/nsp32.c
index 90abb03c9074..c6077cefbeca 100644
--- a/drivers/scsi/nsp32.c
+++ b/drivers/scsi/nsp32.c
@@ -1441,8 +1441,6 @@ static irqreturn_t do_nsp32_isr(int irq, void *dev_id)
         return IRQ_RETVAL(handled);
 }
 
-#undef SPRINTF
-#define SPRINTF(args...) seq_printf(m, ##args)
 
 static int nsp32_show_info(struct seq_file *m, struct Scsi_Host *host)
 {
@@ -1458,64 +1456,63 @@ static int nsp32_show_info(struct seq_file *m, struct Scsi_Host *host)
         data = (nsp32_hw_data *)host->hostdata;
         base = host->io_port;
 
-        SPRINTF("NinjaSCSI-32 status\n\n");
-        SPRINTF("Driver version:        %s, $Revision: 1.33 $\n", nsp32_release_version);
-        SPRINTF("SCSI host No.:         %d\n",          hostno);
-        SPRINTF("IRQ:                   %d\n",          host->irq);
-        SPRINTF("IO:                    0x%lx-0x%lx\n", host->io_port, host->io_port + host->n_io_port - 1);
-        SPRINTF("MMIO(virtual address): 0x%lx-0x%lx\n", host->base, host->base + data->MmioLength - 1);
-        SPRINTF("sg_tablesize:          %d\n",          host->sg_tablesize);
-        SPRINTF("Chip revision:         0x%x\n",        (nsp32_read2(base, INDEX_REG) >> 8) & 0xff);
+        seq_puts(m, "NinjaSCSI-32 status\n\n");
+        seq_printf(m, "Driver version:        %s, $Revision: 1.33 $\n", nsp32_release_version);
+        seq_printf(m, "SCSI host No.:         %d\n",            hostno);
+        seq_printf(m, "IRQ:                   %d\n",            host->irq);
+        seq_printf(m, "IO:                    0x%lx-0x%lx\n", host->io_port, host->io_port + host->n_io_port - 1);
+        seq_printf(m, "MMIO(virtual address): 0x%lx-0x%lx\n",   host->base, host->base + data->MmioLength - 1);
+        seq_printf(m, "sg_tablesize:          %d\n",            host->sg_tablesize);
+        seq_printf(m, "Chip revision:         0x%x\n",          (nsp32_read2(base, INDEX_REG) >> 8) & 0xff);
 
         mode_reg = nsp32_index_read1(base, CHIP_MODE);
         model    = data->pci_devid->driver_data;
 
 #ifdef CONFIG_PM
-        SPRINTF("Power Management:      %s\n",          (mode_reg & OPTF) ? "yes" : "no");
+        seq_printf(m, "Power Management:      %s\n",          (mode_reg & OPTF) ? "yes" : "no");
 #endif
-        SPRINTF("OEM:                   %ld, %s\n",     (mode_reg & (OEM0|OEM1)), nsp32_model[model]);
+        seq_printf(m, "OEM:                   %ld, %s\n",     (mode_reg & (OEM0|OEM1)), nsp32_model[model]);
 
         spin_lock_irqsave(&(data->Lock), flags);
-        SPRINTF("CurrentSC:             0x%p\n\n",      data->CurrentSC);
+        seq_printf(m, "CurrentSC:             0x%p\n\n",      data->CurrentSC);
         spin_unlock_irqrestore(&(data->Lock), flags);
 
 
-        SPRINTF("SDTR status\n");
+        seq_puts(m, "SDTR status\n");
         for (id = 0; id < ARRAY_SIZE(data->target); id++) {
 
-                SPRINTF("id %d: ", id);
+                seq_printf(m, "id %d: ", id);
 
                 if (id == host->this_id) {
-                        SPRINTF("----- NinjaSCSI-32 host adapter\n");
+                        seq_puts(m, "----- NinjaSCSI-32 host adapter\n");
                         continue;
                 }
 
                 if (data->target[id].sync_flag == SDTR_DONE) {
                         if (data->target[id].period == 0            &&
                             data->target[id].offset == ASYNC_OFFSET ) {
-                                SPRINTF("async");
+                                seq_puts(m, "async");
                         } else {
-                                SPRINTF(" sync");
+                                seq_puts(m, " sync");
                         }
                 } else {
-                        SPRINTF(" none");
+                        seq_puts(m, " none");
                 }
 
                 if (data->target[id].period != 0) {
 
                         speed = 1000000 / (data->target[id].period * 4);
 
-                        SPRINTF(" transfer %d.%dMB/s, offset %d",
+                        seq_printf(m, " transfer %d.%dMB/s, offset %d",
                                 speed / 1000,
                                 speed % 1000,
                                 data->target[id].offset
                                 );
                 }
-                SPRINTF("\n");
+                seq_putc(m, '\n');
         }
         return 0;
 }
-#undef SPRINTF
 
 
 
diff --git a/drivers/scsi/pcmcia/nsp_cs.c b/drivers/scsi/pcmcia/nsp_cs.c
index 34aad32829f5..1b6c8833a304 100644
--- a/drivers/scsi/pcmcia/nsp_cs.c
+++ b/drivers/scsi/pcmcia/nsp_cs.c
@@ -1364,9 +1364,6 @@ static const char *nsp_info(struct Scsi_Host *shpnt)
         return data->nspinfo;
 }
 
-#undef SPRINTF
-#define SPRINTF(args...) seq_printf(m, ##args)
-
 static int nsp_show_info(struct seq_file *m, struct Scsi_Host *host)
 {
         int id;
@@ -1378,75 +1375,74 @@ static int nsp_show_info(struct seq_file *m, struct Scsi_Host *host)
         hostno = host->host_no;
         data = (nsp_hw_data *)host->hostdata;
 
-        SPRINTF("NinjaSCSI status\n\n");
-        SPRINTF("Driver version:        $Revision: 1.23 $\n");
-        SPRINTF("SCSI host No.:         %d\n",          hostno);
-        SPRINTF("IRQ:                   %d\n",          host->irq);
-        SPRINTF("IO:                    0x%lx-0x%lx\n", host->io_port, host->io_port + host->n_io_port - 1);
-        SPRINTF("MMIO(virtual address): 0x%lx-0x%lx\n", host->base, host->base + data->MmioLength - 1);
-        SPRINTF("sg_tablesize:          %d\n",          host->sg_tablesize);
+        seq_puts(m, "NinjaSCSI status\n\n"
+                "Driver version:        $Revision: 1.23 $\n");
+        seq_printf(m, "SCSI host No.:         %d\n",          hostno);
+        seq_printf(m, "IRQ:                   %d\n",          host->irq);
+        seq_printf(m, "IO:                    0x%lx-0x%lx\n", host->io_port, host->io_port + host->n_io_port - 1);
+        seq_printf(m, "MMIO(virtual address): 0x%lx-0x%lx\n", host->base, host->base + data->MmioLength - 1);
+        seq_printf(m, "sg_tablesize:          %d\n",          host->sg_tablesize);
 
-        SPRINTF("burst transfer mode:   ");
+        seq_puts(m, "burst transfer mode:   ");
         switch (nsp_burst_mode) {
         case BURST_IO8:
-                SPRINTF("io8");
+                seq_puts(m, "io8");
                 break;
         case BURST_IO32:
-                SPRINTF("io32");
+                seq_puts(m, "io32");
                 break;
         case BURST_MEM32:
-                SPRINTF("mem32");
+                seq_puts(m, "mem32");
                 break;
         default:
-                SPRINTF("???");
+                seq_puts(m, "???");
                 break;
         }
-        SPRINTF("\n");
+        seq_putc(m, '\n');
 
 
         spin_lock_irqsave(&(data->Lock), flags);
-        SPRINTF("CurrentSC:             0x%p\n\n",      data->CurrentSC);
+        seq_printf(m, "CurrentSC:             0x%p\n\n",      data->CurrentSC);
         spin_unlock_irqrestore(&(data->Lock), flags);
 
-        SPRINTF("SDTR status\n");
+        seq_puts(m, "SDTR status\n");
         for(id = 0; id < ARRAY_SIZE(data->Sync); id++) {
 
-                SPRINTF("id %d: ", id);
+                seq_printf(m, "id %d: ", id);
 
                 if (id == host->this_id) {
-                        SPRINTF("----- NinjaSCSI-3 host adapter\n");
+                        seq_puts(m, "----- NinjaSCSI-3 host adapter\n");
                         continue;
                 }
 
                 switch(data->Sync[id].SyncNegotiation) {
                 case SYNC_OK:
-                        SPRINTF(" sync");
+                        seq_puts(m, " sync");
                         break;
                 case SYNC_NG:
-                        SPRINTF("async");
+                        seq_puts(m, "async");
                         break;
                 case SYNC_NOT_YET:
-                        SPRINTF(" none");
+                        seq_puts(m, " none");
                         break;
                 default:
-                        SPRINTF("?????");
+                        seq_puts(m, "?????");
                         break;
                 }
 
                 if (data->Sync[id].SyncPeriod != 0) {
                         speed = 1000000 / (data->Sync[id].SyncPeriod * 4);
 
-                        SPRINTF(" transfer %d.%dMB/s, offset %d",
+                        seq_printf(m, " transfer %d.%dMB/s, offset %d",
                                 speed / 1000,
                                 speed % 1000,
                                 data->Sync[id].SyncOffset
                                 );
                 }
-                SPRINTF("\n");
+                seq_putc(m, '\n');
         }
         return 0;
 }
-#undef SPRINTF
 
 /*---------------------------------------------------------------*/
 /* error handler                                                 */
diff --git a/drivers/scsi/pmcraid.c b/drivers/scsi/pmcraid.c
index 8c27b6a77ec4..ed31d8cc6266 100644
--- a/drivers/scsi/pmcraid.c
+++ b/drivers/scsi/pmcraid.c
@@ -1473,13 +1473,7 @@ static int pmcraid_notify_aen(
         }
 
         /* send genetlink multicast message to notify appplications */
-        result = genlmsg_end(skb, msg_header);
-
-        if (result < 0) {
-                pmcraid_err("genlmsg_end failed\n");
-                nlmsg_free(skb);
-                return result;
-        }
+        genlmsg_end(skb, msg_header);
 
         result = genlmsg_multicast(&pmcraid_event_family, skb,
                                    0, 0, GFP_ATOMIC);
@@ -4223,7 +4217,7 @@ static ssize_t pmcraid_show_adapter_id(
 static struct device_attribute pmcraid_adapter_id_attr = {
         .attr = {
                  .name = "adapter_id",
-                 .mode = S_IRUGO | S_IWUSR,
+                 .mode = S_IRUGO,
                  },
         .show = pmcraid_show_adapter_id,
 };
diff --git a/drivers/scsi/qla2xxx/qla_dfs.c b/drivers/scsi/qla2xxx/qla_dfs.c
index 2ca39b8e7166..15cf074ffa3c 100644
--- a/drivers/scsi/qla2xxx/qla_dfs.c
+++ b/drivers/scsi/qla2xxx/qla_dfs.c
@@ -23,10 +23,10 @@ qla2x00_dfs_fce_show(struct seq_file *s, void *unused)
 
         mutex_lock(&ha->fce_mutex);
 
-        seq_printf(s, "FCE Trace Buffer\n");
+        seq_puts(s, "FCE Trace Buffer\n");
         seq_printf(s, "In Pointer = %llx\n\n", (unsigned long long)ha->fce_wr);
         seq_printf(s, "Base = %llx\n\n", (unsigned long long) ha->fce_dma);
-        seq_printf(s, "FCE Enable Registers\n");
+        seq_puts(s, "FCE Enable Registers\n");
         seq_printf(s, "%08x %08x %08x %08x %08x %08x\n",
             ha->fce_mb[0], ha->fce_mb[2], ha->fce_mb[3], ha->fce_mb[4],
             ha->fce_mb[5], ha->fce_mb[6]);
@@ -38,11 +38,11 @@ qla2x00_dfs_fce_show(struct seq_file *s, void *unused)
                         seq_printf(s, "\n%llx: ",
                             (unsigned long long)((cnt * 4) + fce_start));
                 else
-                        seq_printf(s, " ");
+                        seq_putc(s, ' ');
                 seq_printf(s, "%08x", *fce++);
         }
 
-        seq_printf(s, "\nEnd\n");
+        seq_puts(s, "\nEnd\n");
 
         mutex_unlock(&ha->fce_mutex);
 
diff --git a/drivers/scsi/qla2xxx/tcm_qla2xxx.c b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
index 73f9feecda72..ab4879e12ea7 100644
--- a/drivers/scsi/qla2xxx/tcm_qla2xxx.c
+++ b/drivers/scsi/qla2xxx/tcm_qla2xxx.c
@@ -1570,9 +1570,7 @@ static int tcm_qla2xxx_check_initiator_node_acl(
          * match the format by tcm_qla2xxx explict ConfigFS NodeACLs.
          */
         memset(&port_name, 0, 36);
-        snprintf(port_name, 36, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
-                fc_wwpn[0], fc_wwpn[1], fc_wwpn[2], fc_wwpn[3], fc_wwpn[4],
-                fc_wwpn[5], fc_wwpn[6], fc_wwpn[7]);
+        snprintf(port_name, sizeof(port_name), "%8phC", fc_wwpn);
         /*
          * Locate our struct se_node_acl either from an explict NodeACL created
          * via ConfigFS, or via running in TPG demo mode.
@@ -1598,7 +1596,7 @@ static int tcm_qla2xxx_check_initiator_node_acl(
         /*
          * Finally register the new FC Nexus with TCM
          */
-        __transport_register_session(se_nacl->se_tpg, se_nacl, se_sess, sess);
+        transport_register_session(se_nacl->se_tpg, se_nacl, se_sess, sess);
 
         return 0;
 }
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index 9b3829931f40..c9c3b579eece 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -531,7 +531,7 @@ void scsi_log_send(struct scsi_cmnd *cmd)
          *
          * 3: same as 2
          *
-         * 4: same as 3 plus dump extra junk
+         * 4: same as 3
          */
         if (unlikely(scsi_logging_level)) {
                 level = SCSI_LOG_LEVEL(SCSI_LOG_MLQUEUE_SHIFT,
@@ -540,13 +540,6 @@ void scsi_log_send(struct scsi_cmnd *cmd)
                         scmd_printk(KERN_INFO, cmd,
                                     "Send: scmd 0x%p\n", cmd);
                         scsi_print_command(cmd);
-                        if (level > 3) {
-                                printk(KERN_INFO "buffer = 0x%p, bufflen = %d,"
-                                       " queuecommand 0x%p\n",
-                                        scsi_sglist(cmd), scsi_bufflen(cmd),
-                                        cmd->device->host->hostt->queuecommand);
-
-                        }
                 }
         }
 }
@@ -572,7 +565,7 @@ void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
                                        SCSI_LOG_MLCOMPLETE_BITS);
                 if (((level > 0) && (cmd->result || disposition != SUCCESS)) ||
                     (level > 1)) {
-                        scsi_print_result(cmd, "Done: ", disposition);
+                        scsi_print_result(cmd, "Done", disposition);
                         scsi_print_command(cmd);
                         if (status_byte(cmd->result) & CHECK_CONDITION)
                                 scsi_print_sense(cmd);
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 4aca1b0378c2..1f8e2dc9c616 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -80,6 +80,8 @@ static const char *scsi_debug_version_date = "20141022";
 #define INVALID_FIELD_IN_PARAM_LIST 0x26
 #define UA_RESET_ASC 0x29
 #define UA_CHANGED_ASC 0x2a
+#define TARGET_CHANGED_ASC 0x3f
+#define LUNS_CHANGED_ASCQ 0x0e
 #define INSUFF_RES_ASC 0x55
 #define INSUFF_RES_ASCQ 0x3
 #define POWER_ON_RESET_ASCQ 0x0
@@ -91,6 +93,8 @@ static const char *scsi_debug_version_date = "20141022";
 #define THRESHOLD_EXCEEDED 0x5d
 #define LOW_POWER_COND_ON 0x5e
 #define MISCOMPARE_VERIFY_ASC 0x1d
+#define MICROCODE_CHANGED_ASCQ 0x1      /* with TARGET_CHANGED_ASC */
+#define MICROCODE_CHANGED_WO_RESET_ASCQ 0x16
 
 /* Additional Sense Code Qualifier (ASCQ) */
 #define ACK_NAK_TO 0x3
@@ -180,7 +184,10 @@ static const char *scsi_debug_version_date = "20141022";
 #define SDEBUG_UA_BUS_RESET 1
 #define SDEBUG_UA_MODE_CHANGED 2
 #define SDEBUG_UA_CAPACITY_CHANGED 3
-#define SDEBUG_NUM_UAS 4
+#define SDEBUG_UA_LUNS_CHANGED 4
+#define SDEBUG_UA_MICROCODE_CHANGED 5   /* simulate firmware change */
+#define SDEBUG_UA_MICROCODE_CHANGED_WO_RESET 6
+#define SDEBUG_NUM_UAS 7
 
 /* for check_readiness() */
 #define UAS_ONLY 1      /* check for UAs only */
@@ -326,6 +333,7 @@ static int resp_write_same_10(struct scsi_cmnd *, struct sdebug_dev_info *);
 static int resp_write_same_16(struct scsi_cmnd *, struct sdebug_dev_info *);
 static int resp_xdwriteread_10(struct scsi_cmnd *, struct sdebug_dev_info *);
 static int resp_comp_write(struct scsi_cmnd *, struct sdebug_dev_info *);
+static int resp_write_buffer(struct scsi_cmnd *, struct sdebug_dev_info *);
 
 struct opcode_info_t {
         u8 num_attached;        /* 0 if this is it (i.e. a leaf); use 0xff
@@ -480,8 +488,9 @@ static const struct opcode_info_t opcode_info_arr[SDEB_I_LAST_ELEMENT + 1] = {
         {0, 0x53, 0, F_D_IN | F_D_OUT | FF_DIRECT_IO, resp_xdwriteread_10,
             NULL, {10,  0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff, 0xff, 0xc7,
                    0, 0, 0, 0, 0, 0} },
-        {0, 0, 0, F_INV_OP | FF_RESPOND, NULL, NULL, /* WRITE_BUFFER */
-            {0,  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} },
+        {0, 0x3b, 0, F_D_OUT_MAYBE, resp_write_buffer, NULL,
+            {10,  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc7, 0, 0,
+             0, 0, 0, 0} },                     /* WRITE_BUFFER */
         {1, 0x41, 0, F_D_OUT_MAYBE | FF_DIRECT_IO, resp_write_same_10,
             write_same_iarr, {10,  0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xff,
                               0xff, 0xc7, 0, 0, 0, 0, 0, 0} },
@@ -782,6 +791,22 @@ static int scsi_debug_ioctl(struct scsi_device *dev, int cmd, void __user *arg)
         /* return -ENOTTY; // correct return but upsets fdisk */
 }
 
+static void clear_luns_changed_on_target(struct sdebug_dev_info *devip)
+{
+        struct sdebug_host_info *sdhp;
+        struct sdebug_dev_info *dp;
+
+        spin_lock(&sdebug_host_list_lock);
+        list_for_each_entry(sdhp, &sdebug_host_list, host_list) {
+                list_for_each_entry(dp, &sdhp->dev_info_list, dev_list) {
+                        if ((devip->sdbg_host == dp->sdbg_host) &&
+                            (devip->target == dp->target))
+                                clear_bit(SDEBUG_UA_LUNS_CHANGED, dp->uas_bm);
+                }
+        }
+        spin_unlock(&sdebug_host_list_lock);
+}
+
 static int check_readiness(struct scsi_cmnd *SCpnt, int uas_only,
                            struct sdebug_dev_info * devip)
 {
@@ -817,6 +842,36 @@ static int check_readiness(struct scsi_cmnd *SCpnt, int uas_only,
                         if (debug)
                                 cp = "capacity data changed";
                         break;
+                case SDEBUG_UA_MICROCODE_CHANGED:
+                        mk_sense_buffer(SCpnt, UNIT_ATTENTION,
+                                 TARGET_CHANGED_ASC, MICROCODE_CHANGED_ASCQ);
+                        if (debug)
+                                cp = "microcode has been changed";
+                        break;
+                case SDEBUG_UA_MICROCODE_CHANGED_WO_RESET:
+                        mk_sense_buffer(SCpnt, UNIT_ATTENTION,
+                                        TARGET_CHANGED_ASC,
+                                        MICROCODE_CHANGED_WO_RESET_ASCQ);
+                        if (debug)
+                                cp = "microcode has been changed without reset";
+                        break;
+                case SDEBUG_UA_LUNS_CHANGED:
+                        /*
+                         * SPC-3 behavior is to report a UNIT ATTENTION with
+                         * ASC/ASCQ REPORTED LUNS DATA HAS CHANGED on every LUN
+                         * on the target, until a REPORT LUNS command is
+                         * received.  SPC-4 behavior is to report it only once.
+                         * NOTE:  scsi_debug_scsi_level does not use the same
+                         * values as struct scsi_device->scsi_level.
+                         */
+                        if (scsi_debug_scsi_level >= 6) /* SPC-4 and above */
+                                clear_luns_changed_on_target(devip);
+                        mk_sense_buffer(SCpnt, UNIT_ATTENTION,
+                                        TARGET_CHANGED_ASC,
+                                        LUNS_CHANGED_ASCQ);
+                        if (debug)
+                                cp = "reported luns data has changed";
+                        break;
                 default:
                         pr_warn("%s: unexpected unit attention code=%d\n",
                                 __func__, k);
@@ -3033,6 +3088,55 @@ resp_write_same_16(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
         return resp_write_same(scp, lba, num, ei_lba, unmap, ndob);
 }
 
+/* Note the mode field is in the same position as the (lower) service action
+ * field. For the Report supported operation codes command, SPC-4 suggests
+ * each mode of this command should be reported separately; for future. */
+static int
+resp_write_buffer(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
+{
+        u8 *cmd = scp->cmnd;
+        struct scsi_device *sdp = scp->device;
+        struct sdebug_dev_info *dp;
+        u8 mode;
+
+        mode = cmd[1] & 0x1f;
+        switch (mode) {
+        case 0x4:       /* download microcode (MC) and activate (ACT) */
+                /* set UAs on this device only */
+                set_bit(SDEBUG_UA_BUS_RESET, devip->uas_bm);
+                set_bit(SDEBUG_UA_MICROCODE_CHANGED, devip->uas_bm);
+                break;
+        case 0x5:       /* download MC, save and ACT */
+                set_bit(SDEBUG_UA_MICROCODE_CHANGED_WO_RESET, devip->uas_bm);
+                break;
+        case 0x6:       /* download MC with offsets and ACT */
+                /* set UAs on most devices (LUs) in this target */
+                list_for_each_entry(dp,
+                                    &devip->sdbg_host->dev_info_list,
+                                    dev_list)
+                        if (dp->target == sdp->id) {
+                                set_bit(SDEBUG_UA_BUS_RESET, dp->uas_bm);
+                                if (devip != dp)
+                                        set_bit(SDEBUG_UA_MICROCODE_CHANGED,
+                                                dp->uas_bm);
+                        }
+                break;
+        case 0x7:       /* download MC with offsets, save, and ACT */
+                /* set UA on all devices (LUs) in this target */
+                list_for_each_entry(dp,
+                                    &devip->sdbg_host->dev_info_list,
+                                    dev_list)
+                        if (dp->target == sdp->id)
+                                set_bit(SDEBUG_UA_MICROCODE_CHANGED_WO_RESET,
+                                        dp->uas_bm);
+                break;
+        default:
+                /* do nothing for this command for other mode values */
+                break;
+        }
+        return 0;
+}
+
 static int
 resp_comp_write(struct scsi_cmnd *scp, struct sdebug_dev_info *devip)
 {
@@ -3229,6 +3333,7 @@ static int resp_report_luns(struct scsi_cmnd * scp,
         unsigned char arr[SDEBUG_RLUN_ARR_SZ];
         unsigned char * max_addr;
 
+        clear_luns_changed_on_target(devip);
         alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
         shortish = (alloc_len < 4);
         if (shortish || (select_report > 2)) {
@@ -4369,10 +4474,27 @@ static ssize_t max_luns_store(struct device_driver *ddp, const char *buf,
                               size_t count)
 {
         int n;
+        bool changed;
 
         if ((count > 0) && (1 == sscanf(buf, "%d", &n)) && (n >= 0)) {
+                changed = (scsi_debug_max_luns != n);
                 scsi_debug_max_luns = n;
                 sdebug_max_tgts_luns();
+                if (changed && (scsi_debug_scsi_level >= 5)) {  /* >= SPC-3 */
+                        struct sdebug_host_info *sdhp;
+                        struct sdebug_dev_info *dp;
+
+                        spin_lock(&sdebug_host_list_lock);
+                        list_for_each_entry(sdhp, &sdebug_host_list,
+                                            host_list) {
+                                list_for_each_entry(dp, &sdhp->dev_info_list,
+                                                    dev_list) {
+                                        set_bit(SDEBUG_UA_LUNS_CHANGED,
+                                                dp->uas_bm);
+                                }
+                        }
+                        spin_unlock(&sdebug_host_list_lock);
+                }
                 return count;
         }
         return -EINVAL;
@@ -4536,10 +4658,10 @@ static ssize_t map_show(struct device_driver *ddp, char *buf)
                 return scnprintf(buf, PAGE_SIZE, "0-%u\n",
                                  sdebug_store_sectors);
 
-        count = bitmap_scnlistprintf(buf, PAGE_SIZE, map_storep, map_size);
-
+        count = scnprintf(buf, PAGE_SIZE - 1, "%*pbl",
+                          (int)map_size, map_storep);
         buf[count++] = '\n';
-        buf[count++] = 0;
+        buf[count] = '\0';
 
         return count;
 }
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 8afb01604d51..4cdaffca17fc 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -124,41 +124,37 @@ scmd_eh_abort_handler(struct work_struct *work)
         if (scsi_host_eh_past_deadline(sdev->host)) {
                 SCSI_LOG_ERROR_RECOVERY(3,
                         scmd_printk(KERN_INFO, scmd,
-                                    "scmd %p eh timeout, not aborting\n",
-                                    scmd));
+                                    "eh timeout, not aborting\n"));
         } else {
                 SCSI_LOG_ERROR_RECOVERY(3,
                         scmd_printk(KERN_INFO, scmd,
-                                    "aborting command %p\n", scmd));
+                                    "aborting command\n"));
                 rtn = scsi_try_to_abort_cmd(sdev->host->hostt, scmd);
                 if (rtn == SUCCESS) {
                         set_host_byte(scmd, DID_TIME_OUT);
                         if (scsi_host_eh_past_deadline(sdev->host)) {
                                 SCSI_LOG_ERROR_RECOVERY(3,
                                         scmd_printk(KERN_INFO, scmd,
-                                                    "scmd %p eh timeout, "
-                                                    "not retrying aborted "
-                                                    "command\n", scmd));
+                                                    "eh timeout, not retrying "
+                                                    "aborted command\n"));
                         } else if (!scsi_noretry_cmd(scmd) &&
                             (++scmd->retries <= scmd->allowed)) {
                                 SCSI_LOG_ERROR_RECOVERY(3,
                                         scmd_printk(KERN_WARNING, scmd,
-                                                    "scmd %p retry "
-                                                    "aborted command\n", scmd));
+                                                    "retry aborted command\n"));
                                 scsi_queue_insert(scmd, SCSI_MLQUEUE_EH_RETRY);
                                 return;
                         } else {
                                 SCSI_LOG_ERROR_RECOVERY(3,
                                         scmd_printk(KERN_WARNING, scmd,
-                                                    "scmd %p finish "
-                                                    "aborted command\n", scmd));
+                                                    "finish aborted command\n"));
                                 scsi_finish_command(scmd);
                                 return;
                         }
                 } else {
                         SCSI_LOG_ERROR_RECOVERY(3,
                                 scmd_printk(KERN_INFO, scmd,
-                                            "scmd %p abort %s\n", scmd,
+                                            "cmd abort %s\n",
                                             (rtn == FAST_IO_FAIL) ?
                                             "not send" : "failed"));
                 }
@@ -167,8 +163,7 @@ scmd_eh_abort_handler(struct work_struct *work)
         if (!scsi_eh_scmd_add(scmd, 0)) {
                 SCSI_LOG_ERROR_RECOVERY(3,
                         scmd_printk(KERN_WARNING, scmd,
-                                    "scmd %p terminate "
-                                    "aborted command\n", scmd));
+                                    "terminate aborted command\n"));
                 set_host_byte(scmd, DID_TIME_OUT);
                 scsi_finish_command(scmd);
         }
@@ -194,7 +189,7 @@ scsi_abort_command(struct scsi_cmnd *scmd)
                 scmd->eh_eflags &= ~SCSI_EH_ABORT_SCHEDULED;
                 SCSI_LOG_ERROR_RECOVERY(3,
                         scmd_printk(KERN_INFO, scmd,
-                                    "scmd %p previous abort failed\n", scmd));
+                                    "previous abort failed\n"));
                 BUG_ON(delayed_work_pending(&scmd->abort_work));
                 return FAILED;
         }
@@ -208,8 +203,7 @@ scsi_abort_command(struct scsi_cmnd *scmd)
                 spin_unlock_irqrestore(shost->host_lock, flags);
                 SCSI_LOG_ERROR_RECOVERY(3,
                         scmd_printk(KERN_INFO, scmd,
-                                    "scmd %p not aborting, host in recovery\n",
-                                    scmd));
+                                    "not aborting, host in recovery\n"));
                 return FAILED;
         }
 
@@ -219,8 +213,7 @@ scsi_abort_command(struct scsi_cmnd *scmd)
 
         scmd->eh_eflags |= SCSI_EH_ABORT_SCHEDULED;
         SCSI_LOG_ERROR_RECOVERY(3,
-                scmd_printk(KERN_INFO, scmd,
-                            "scmd %p abort scheduled\n", scmd));
+                scmd_printk(KERN_INFO, scmd, "abort scheduled\n"));
         queue_delayed_work(shost->tmf_work_q, &scmd->abort_work, HZ / 100);
         return SUCCESS;
 }
@@ -737,8 +730,7 @@ static void scsi_eh_done(struct scsi_cmnd *scmd)
         struct completion *eh_action;
 
         SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
-                        "%s scmd: %p result: %x\n",
-                        __func__, scmd, scmd->result));
+                        "%s result: %x\n", __func__, scmd->result));
 
         eh_action = scmd->device->host->eh_action;
         if (eh_action)
@@ -868,6 +860,7 @@ static int scsi_try_bus_device_reset(struct scsi_cmnd *scmd)
 
 /**
  * scsi_try_to_abort_cmd - Ask host to abort a SCSI command
+ * @hostt:      SCSI driver host template
  * @scmd:       SCSI cmd used to send a target reset
  *
  * Return value:
@@ -1052,8 +1045,8 @@ retry:
         scsi_log_completion(scmd, rtn);
 
         SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
-                        "%s: scmd: %p, timeleft: %ld\n",
-                        __func__, scmd, timeleft));
+                        "%s timeleft: %ld\n",
+                        __func__, timeleft));
 
         /*
          * If there is time left scsi_eh_done got called, and we will examine
@@ -1192,8 +1185,7 @@ int scsi_eh_get_sense(struct list_head *work_q,
                         continue;
 
                 SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
-                        "sense requested for %p result %x\n",
-                        scmd, scmd->result));
+                        "sense requested, result %x\n", scmd->result));
                 SCSI_LOG_ERROR_RECOVERY(3, scsi_print_sense(scmd));
 
                 rtn = scsi_decide_disposition(scmd);
@@ -1235,7 +1227,7 @@ retry_tur:
                                 scmd->device->eh_timeout, 0);
 
         SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd,
-                "%s: scmd %p rtn %x\n", __func__, scmd, rtn));
+                "%s return: %x\n", __func__, rtn));
 
         switch (rtn) {
         case NEEDS_RETRY:
@@ -2092,8 +2084,8 @@ void scsi_eh_flush_done_q(struct list_head *done_q)
                     (++scmd->retries <= scmd->allowed)) {
                         SCSI_LOG_ERROR_RECOVERY(3,
                                 scmd_printk(KERN_INFO, scmd,
-                                             "%s: flush retry cmd: %p\n",
-                                             current->comm, scmd));
+                                             "%s: flush retry cmd\n",
+                                             current->comm));
                                 scsi_queue_insert(scmd, SCSI_MLQUEUE_EH_RETRY);
                 } else {
                         /*
@@ -2105,8 +2097,8 @@ void scsi_eh_flush_done_q(struct list_head *done_q)
                                 scmd->result |= (DRIVER_TIMEOUT << 24);
                         SCSI_LOG_ERROR_RECOVERY(3,
                                 scmd_printk(KERN_INFO, scmd,
-                                             "%s: flush finish cmd: %p\n",
-                                             current->comm, scmd));
+                                             "%s: flush finish cmd\n",
+                                             current->comm));
                         scsi_finish_command(scmd);
                 }
         }
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 17bb541f7cc2..54d7a6cbb98a 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -2197,6 +2197,8 @@ int scsi_mq_setup_tags(struct Scsi_Host *shost)
         shost->tag_set.cmd_size = cmd_size;
         shost->tag_set.numa_node = NUMA_NO_NODE;
         shost->tag_set.flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_SG_MERGE;
+        shost->tag_set.flags |=
+                BLK_ALLOC_POLICY_TO_MQ_FLAG(shost->hostt->tag_alloc_policy);
         shost->tag_set.driver_data = shost;
 
         return blk_mq_alloc_tag_set(&shost->tag_set);
diff --git a/drivers/scsi/scsi_logging.c b/drivers/scsi/scsi_logging.c
new file mode 100644
index 000000000000..bd70339c1242
--- /dev/null
+++ b/drivers/scsi/scsi_logging.c
@@ -0,0 +1,485 @@
+/*
+ * scsi_logging.c
+ *
+ * Copyright (C) 2014 SUSE Linux Products GmbH
+ * Copyright (C) 2014 Hannes Reinecke <hare@suse.de>
+ *
+ * This file is released under the GPLv2
+ */
+
+#include <linux/kernel.h>
+#include <linux/atomic.h>
+
+#include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_eh.h>
+#include <scsi/scsi_dbg.h>
+
+#define SCSI_LOG_SPOOLSIZE 4096
+
+#if (SCSI_LOG_SPOOLSIZE / SCSI_LOG_BUFSIZE) > BITS_PER_LONG
+#warning SCSI logging bitmask too large
+#endif
+
+struct scsi_log_buf {
+        char buffer[SCSI_LOG_SPOOLSIZE];
+        unsigned long map;
+};
+
+static DEFINE_PER_CPU(struct scsi_log_buf, scsi_format_log);
+
+static char *scsi_log_reserve_buffer(size_t *len)
+{
+        struct scsi_log_buf *buf;
+        unsigned long map_bits = sizeof(buf->buffer) / SCSI_LOG_BUFSIZE;
+        unsigned long idx = 0;
+
+        preempt_disable();
+        buf = this_cpu_ptr(&scsi_format_log);
+        idx = find_first_zero_bit(&buf->map, map_bits);
+        if (likely(idx < map_bits)) {
+                while (test_and_set_bit(idx, &buf->map)) {
+                        idx = find_next_zero_bit(&buf->map, map_bits, idx);
+                        if (idx >= map_bits)
+                                break;
+                }
+        }
+        if (WARN_ON(idx >= map_bits)) {
+                preempt_enable();
+                return NULL;
+        }
+        *len = SCSI_LOG_BUFSIZE;
+        return buf->buffer + idx * SCSI_LOG_BUFSIZE;
+}
+
+static void scsi_log_release_buffer(char *bufptr)
+{
+        struct scsi_log_buf *buf;
+        unsigned long idx;
+        int ret;
+
+        buf = this_cpu_ptr(&scsi_format_log);
+        if (bufptr >= buf->buffer &&
+            bufptr < buf->buffer + SCSI_LOG_SPOOLSIZE) {
+                idx = (bufptr - buf->buffer) / SCSI_LOG_BUFSIZE;
+                ret = test_and_clear_bit(idx, &buf->map);
+                WARN_ON(!ret);
+        }
+        preempt_enable();
+}
+
+static inline const char *scmd_name(const struct scsi_cmnd *scmd)
+{
+        return scmd->request->rq_disk ?
+                scmd->request->rq_disk->disk_name : NULL;
+}
+
+static size_t sdev_format_header(char *logbuf, size_t logbuf_len,
+                                 const char *name, int tag)
+{
+        size_t off = 0;
+
+        if (name)
+                off += scnprintf(logbuf + off, logbuf_len - off,
+                                 "[%s] ", name);
+
+        if (WARN_ON(off >= logbuf_len))
+                return off;
+
+        if (tag >= 0)
+                off += scnprintf(logbuf + off, logbuf_len - off,
+                                 "tag#%d ", tag);
+        return off;
+}
+
+void sdev_prefix_printk(const char *level, const struct scsi_device *sdev,
+                        const char *name, const char *fmt, ...)
+{
+        va_list args;
+        char *logbuf;
+        size_t off = 0, logbuf_len;
+
+        if (!sdev)
+                return;
+
+        logbuf = scsi_log_reserve_buffer(&logbuf_len);
+        if (!logbuf)
+                return;
+
+        if (name)
+                off += scnprintf(logbuf + off, logbuf_len - off,
+                                 "[%s] ", name);
+        if (!WARN_ON(off >= logbuf_len)) {
+                va_start(args, fmt);
+                off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args);
+                va_end(args);
+        }
+        dev_printk(level, &sdev->sdev_gendev, "%s", logbuf);
+        scsi_log_release_buffer(logbuf);
+}
+EXPORT_SYMBOL(sdev_prefix_printk);
+
+void scmd_printk(const char *level, const struct scsi_cmnd *scmd,
+                const char *fmt, ...)
+{
+        va_list args;
+        char *logbuf;
+        size_t off = 0, logbuf_len;
+
+        if (!scmd || !scmd->cmnd)
+                return;
+
+        logbuf = scsi_log_reserve_buffer(&logbuf_len);
+        if (!logbuf)
+                return;
+        off = sdev_format_header(logbuf, logbuf_len, scmd_name(scmd),
+                                 scmd->request->tag);
+        if (off < logbuf_len) {
+                va_start(args, fmt);
+                off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args);
+                va_end(args);
+        }
+        dev_printk(level, &scmd->device->sdev_gendev, "%s", logbuf);
+        scsi_log_release_buffer(logbuf);
+}
+EXPORT_SYMBOL(scmd_printk);
+
+static size_t scsi_format_opcode_name(char *buffer, size_t buf_len,
+                                      const unsigned char *cdbp)
+{
+        int sa, cdb0;
+        const char *cdb_name = NULL, *sa_name = NULL;
+        size_t off;
+
+        cdb0 = cdbp[0];
+        if (cdb0 == VARIABLE_LENGTH_CMD) {
+                int len = scsi_varlen_cdb_length(cdbp);
+
+                if (len < 10) {
+                        off = scnprintf(buffer, buf_len,
+                                        "short variable length command, len=%d",
+                                        len);
+                        return off;
+                }
+                sa = (cdbp[8] << 8) + cdbp[9];
+        } else
+                sa = cdbp[1] & 0x1f;
+
+        if (!scsi_opcode_sa_name(cdb0, sa, &cdb_name, &sa_name)) {
+                if (cdb_name)
+                        off = scnprintf(buffer, buf_len, "%s", cdb_name);
+                else {
+                        off = scnprintf(buffer, buf_len, "opcode=0x%x", cdb0);
+                        if (WARN_ON(off >= buf_len))
+                                return off;
+                        if (cdb0 >= VENDOR_SPECIFIC_CDB)
+                                off += scnprintf(buffer + off, buf_len - off,
+                                                 " (vendor)");
+                        else if (cdb0 >= 0x60 && cdb0 < 0x7e)
+                                off += scnprintf(buffer + off, buf_len - off,
+                                                 " (reserved)");
+                }
+        } else {
+                if (sa_name)
+                        off = scnprintf(buffer, buf_len, "%s", sa_name);
+                else if (cdb_name)
+                        off = scnprintf(buffer, buf_len, "%s, sa=0x%x",
+                                        cdb_name, sa);
+                else
+                        off = scnprintf(buffer, buf_len,
+                                        "opcode=0x%x, sa=0x%x", cdb0, sa);
+        }
+        WARN_ON(off >= buf_len);
+        return off;
+}
+
+size_t __scsi_format_command(char *logbuf, size_t logbuf_len,
+                             const unsigned char *cdb, size_t cdb_len)
+{
+        int len, k;
+        size_t off;
+
+        off = scsi_format_opcode_name(logbuf, logbuf_len, cdb);
+        if (off >= logbuf_len)
+                return off;
+        len = scsi_command_size(cdb);
+        if (cdb_len < len)
+                len = cdb_len;
+        /* print out all bytes in cdb */
+        for (k = 0; k < len; ++k) {
+                if (off > logbuf_len - 3)
+                        break;
+                off += scnprintf(logbuf + off, logbuf_len - off,
+                                 " %02x", cdb[k]);
+        }
+        return off;
+}
+EXPORT_SYMBOL(__scsi_format_command);
+
+void scsi_print_command(struct scsi_cmnd *cmd)
+{
+        int k;
+        char *logbuf;
+        size_t off, logbuf_len;
+
+        if (!cmd->cmnd)
+                return;
+
+        logbuf = scsi_log_reserve_buffer(&logbuf_len);
+        if (!logbuf)
+                return;
+
+        off = sdev_format_header(logbuf, logbuf_len,
+                                 scmd_name(cmd), cmd->request->tag);
+        if (off >= logbuf_len)
+                goto out_printk;
+        off += scnprintf(logbuf + off, logbuf_len - off, "CDB: ");
+        if (WARN_ON(off >= logbuf_len))
+                goto out_printk;
+
+        off += scsi_format_opcode_name(logbuf + off, logbuf_len - off,
+                                       cmd->cmnd);
+        if (off >= logbuf_len)
+                goto out_printk;
+
+        /* print out all bytes in cdb */
+        if (cmd->cmd_len > 16) {
+                /* Print opcode in one line and use separate lines for CDB */
+                off += scnprintf(logbuf + off, logbuf_len - off, "\n");
+                dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s", logbuf);
+                scsi_log_release_buffer(logbuf);
+                for (k = 0; k < cmd->cmd_len; k += 16) {
+                        size_t linelen = min(cmd->cmd_len - k, 16);
+
+                        logbuf = scsi_log_reserve_buffer(&logbuf_len);
+                        if (!logbuf)
+                                break;
+                        off = sdev_format_header(logbuf, logbuf_len,
+                                                 scmd_name(cmd),
+                                                 cmd->request->tag);
+                        if (!WARN_ON(off > logbuf_len - 58)) {
+                                off += scnprintf(logbuf + off, logbuf_len - off,
+                                                 "CDB[%02x]: ", k);
+                                hex_dump_to_buffer(&cmd->cmnd[k], linelen,
+                                                   16, 1, logbuf + off,
+                                                   logbuf_len - off, false);
+                        }
+                        dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s",
+                                   logbuf);
+                        scsi_log_release_buffer(logbuf);
+                }
+                return;
+        }
+        if (!WARN_ON(off > logbuf_len - 49)) {
+                off += scnprintf(logbuf + off, logbuf_len - off, " ");
+                hex_dump_to_buffer(cmd->cmnd, cmd->cmd_len, 16, 1,
+                                   logbuf + off, logbuf_len - off,
+                                   false);
+        }
+out_printk:
+        dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s", logbuf);
+        scsi_log_release_buffer(logbuf);
+}
+EXPORT_SYMBOL(scsi_print_command);
+
+static size_t
+scsi_format_extd_sense(char *buffer, size_t buf_len,
+                       unsigned char asc, unsigned char ascq)
+{
+        size_t off = 0;
+        const char *extd_sense_fmt = NULL;
+        const char *extd_sense_str = scsi_extd_sense_format(asc, ascq,
+                                                            &extd_sense_fmt);
+
+        if (extd_sense_str) {
+                off = scnprintf(buffer, buf_len, "Add. Sense: %s",
+                                extd_sense_str);
+                if (extd_sense_fmt)
+                        off += scnprintf(buffer + off, buf_len - off,
+                                         "(%s%x)", extd_sense_fmt, ascq);
+        } else {
+                if (asc >= 0x80)
+                        off = scnprintf(buffer, buf_len, "<<vendor>>");
+                off += scnprintf(buffer + off, buf_len - off,
+                                 "ASC=0x%x ", asc);
+                if (ascq >= 0x80)
+                        off += scnprintf(buffer + off, buf_len - off,
+                                         "<<vendor>>");
+                off += scnprintf(buffer + off, buf_len - off,
+                                 "ASCQ=0x%x ", ascq);
+        }
+        return off;
+}
+
+static size_t
+scsi_format_sense_hdr(char *buffer, size_t buf_len,
+                      const struct scsi_sense_hdr *sshdr)
+{
+        const char *sense_txt;
+        size_t off;
+
+        off = scnprintf(buffer, buf_len, "Sense Key : ");
+        sense_txt = scsi_sense_key_string(sshdr->sense_key);
+        if (sense_txt)
+                off += scnprintf(buffer + off, buf_len - off,
+                                 "%s ", sense_txt);
+        else
+                off += scnprintf(buffer + off, buf_len - off,
+                                 "0x%x ", sshdr->sense_key);
+        off += scnprintf(buffer + off, buf_len - off,
+                scsi_sense_is_deferred(sshdr) ? "[deferred] " : "[current] ");
+
+        if (sshdr->response_code >= 0x72)
+                off += scnprintf(buffer + off, buf_len - off, "[descriptor] ");
+        return off;
+}
+
+static void
+scsi_log_dump_sense(const struct scsi_device *sdev, const char *name, int tag,
+                    const unsigned char *sense_buffer, int sense_len)
+{
+        char *logbuf;
+        size_t logbuf_len;
+        int i;
+
+        logbuf = scsi_log_reserve_buffer(&logbuf_len);
+        if (!logbuf)
+                return;
+
+        for (i = 0; i < sense_len; i += 16) {
+                int len = min(sense_len - i, 16);
+                size_t off;
+
+                off = sdev_format_header(logbuf, logbuf_len,
+                                         name, tag);
+                hex_dump_to_buffer(&sense_buffer[i], len, 16, 1,
+                                   logbuf + off, logbuf_len - off,
+                                   false);
+                dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf);
+        }
+        scsi_log_release_buffer(logbuf);
+}
+
+static void
+scsi_log_print_sense_hdr(const struct scsi_device *sdev, const char *name,
+                         int tag, const struct scsi_sense_hdr *sshdr)
+{
+        char *logbuf;
+        size_t off, logbuf_len;
+
+        logbuf = scsi_log_reserve_buffer(&logbuf_len);
+        if (!logbuf)
+                return;
+        off = sdev_format_header(logbuf, logbuf_len, name, tag);
+        off += scsi_format_sense_hdr(logbuf + off, logbuf_len - off, sshdr);
+        dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf);
+        scsi_log_release_buffer(logbuf);
+
+        logbuf = scsi_log_reserve_buffer(&logbuf_len);
+        if (!logbuf)
+                return;
+        off = sdev_format_header(logbuf, logbuf_len, name, tag);
+        off += scsi_format_extd_sense(logbuf + off, logbuf_len - off,
+                                      sshdr->asc, sshdr->ascq);
+        dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf);
+        scsi_log_release_buffer(logbuf);
+}
+
+static void
+scsi_log_print_sense(const struct scsi_device *sdev, const char *name, int tag,
+                     const unsigned char *sense_buffer, int sense_len)
+{
+        struct scsi_sense_hdr sshdr;
+
+        if (scsi_normalize_sense(sense_buffer, sense_len, &sshdr))
+                scsi_log_print_sense_hdr(sdev, name, tag, &sshdr);
+        else
+                scsi_log_dump_sense(sdev, name, tag, sense_buffer, sense_len);
+}
+
+/*
+ * Print normalized SCSI sense header with a prefix.
+ */
+void
+scsi_print_sense_hdr(const struct scsi_device *sdev, const char *name,
+                     const struct scsi_sense_hdr *sshdr)
+{
+        scsi_log_print_sense_hdr(sdev, name, -1, sshdr);
+}
+EXPORT_SYMBOL(scsi_print_sense_hdr);
+
+/* Normalize and print sense buffer with name prefix */
+void __scsi_print_sense(const struct scsi_device *sdev, const char *name,
+                        const unsigned char *sense_buffer, int sense_len)
+{
+        scsi_log_print_sense(sdev, name, -1, sense_buffer, sense_len);
+}
+EXPORT_SYMBOL(__scsi_print_sense);
+
+/* Normalize and print sense buffer in SCSI command */
+void scsi_print_sense(const struct scsi_cmnd *cmd)
+{
+        scsi_log_print_sense(cmd->device, scmd_name(cmd), cmd->request->tag,
+                             cmd->sense_buffer, SCSI_SENSE_BUFFERSIZE);
+}
+EXPORT_SYMBOL(scsi_print_sense);
+
+void scsi_print_result(const struct scsi_cmnd *cmd, const char *msg,
+                       int disposition)
+{
+        char *logbuf;
+        size_t off, logbuf_len;
+        const char *mlret_string = scsi_mlreturn_string(disposition);
+        const char *hb_string = scsi_hostbyte_string(cmd->result);
+        const char *db_string = scsi_driverbyte_string(cmd->result);
+
+        logbuf = scsi_log_reserve_buffer(&logbuf_len);
+        if (!logbuf)
+                return;
+
+        off = sdev_format_header(logbuf, logbuf_len,
+                                 scmd_name(cmd), cmd->request->tag);
+
+        if (off >= logbuf_len)
+                goto out_printk;
+
+        if (msg) {
+                off += scnprintf(logbuf + off, logbuf_len - off,
+                                 "%s: ", msg);
+                if (WARN_ON(off >= logbuf_len))
+                        goto out_printk;
+        }
+        if (mlret_string)
+                off += scnprintf(logbuf + off, logbuf_len - off,
+                                 "%s ", mlret_string);
+        else
+                off += scnprintf(logbuf + off, logbuf_len - off,
+                                 "UNKNOWN(0x%02x) ", disposition);
+        if (WARN_ON(off >= logbuf_len))
+                goto out_printk;
+
+        off += scnprintf(logbuf + off, logbuf_len - off, "Result: ");
+        if (WARN_ON(off >= logbuf_len))
+                goto out_printk;
+
+        if (hb_string)
+                off += scnprintf(logbuf + off, logbuf_len - off,
+                                 "hostbyte=%s ", hb_string);
+        else
+                off += scnprintf(logbuf + off, logbuf_len - off,
+                                 "hostbyte=0x%02x ", host_byte(cmd->result));
+        if (WARN_ON(off >= logbuf_len))
+                goto out_printk;
+
+        if (db_string)
+                off += scnprintf(logbuf + off, logbuf_len - off,
+                                 "driverbyte=%s", db_string);
+        else
+                off += scnprintf(logbuf + off, logbuf_len - off,
+                                 "driverbyte=0x%02x", driver_byte(cmd->result));
+out_printk:
+        dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s", logbuf);
+        scsi_log_release_buffer(logbuf);
+}
+EXPORT_SYMBOL(scsi_print_result);
diff --git a/drivers/scsi/scsi_proc.c b/drivers/scsi/scsi_proc.c
index 6fcefa2da503..251598eb3547 100644
--- a/drivers/scsi/scsi_proc.c
+++ b/drivers/scsi/scsi_proc.c
@@ -189,36 +189,36 @@ static int proc_print_scsidevice(struct device *dev, void *data)
                 sdev->host->host_no, sdev->channel, sdev->id, sdev->lun);
         for (i = 0; i < 8; i++) {
                 if (sdev->vendor[i] >= 0x20)
-                        seq_printf(s, "%c", sdev->vendor[i]);
+                        seq_putc(s, sdev->vendor[i]);
                 else
-                        seq_printf(s, " ");
+                        seq_putc(s, ' ');
         }
 
-        seq_printf(s, " Model: ");
+        seq_puts(s, " Model: ");
         for (i = 0; i < 16; i++) {
                 if (sdev->model[i] >= 0x20)
-                        seq_printf(s, "%c", sdev->model[i]);
+                        seq_putc(s, sdev->model[i]);
                 else
-                        seq_printf(s, " ");
+                        seq_putc(s, ' ');
         }
 
-        seq_printf(s, " Rev: ");
+        seq_puts(s, " Rev: ");
         for (i = 0; i < 4; i++) {
                 if (sdev->rev[i] >= 0x20)
-                        seq_printf(s, "%c", sdev->rev[i]);
+                        seq_putc(s, sdev->rev[i]);
                 else
-                        seq_printf(s, " ");
+                        seq_putc(s, ' ');
         }
 
-        seq_printf(s, "\n");
+        seq_putc(s, '\n');
 
         seq_printf(s, "  Type:   %s ", scsi_device_type(sdev->type));
         seq_printf(s, "               ANSI  SCSI revision: %02x",
                         sdev->scsi_level - (sdev->scsi_level > 1));
         if (sdev->scsi_level == 2)
-                seq_printf(s, " CCS\n");
+                seq_puts(s, " CCS\n");
         else
-                seq_printf(s, "\n");
+                seq_putc(s, '\n');
 
 out:
         return 0;
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 983aed10ff2f..9c0a520d933c 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -34,6 +34,7 @@
 #include <linux/spinlock.h>
 #include <linux/async.h>
 #include <linux/slab.h>
+#include <asm/unaligned.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -98,20 +99,6 @@ char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;
 module_param_string(scan, scsi_scan_type, sizeof(scsi_scan_type), S_IRUGO);
 MODULE_PARM_DESC(scan, "sync, async or none");
 
-/*
- * max_scsi_report_luns: the maximum number of LUNS that will be
- * returned from the REPORT LUNS command. 8 times this value must
- * be allocated. In theory this could be up to an 8 byte value, but
- * in practice, the maximum number of LUNs suppored by any device
- * is about 16k.
- */
-static unsigned int max_scsi_report_luns = 511;
-
-module_param_named(max_report_luns, max_scsi_report_luns, uint, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(max_report_luns,
-                 "REPORT LUNS maximum number of LUNS received (should be"
-                 " between 1 and 16384)");
-
 static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ + 18;
 
 module_param_named(inq_timeout, scsi_inq_timeout, uint, S_IRUGO|S_IWUSR);
@@ -290,7 +277,8 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
         if (!shost_use_blk_mq(sdev->host) &&
             (shost->bqt || shost->hostt->use_blk_tags)) {
                 blk_queue_init_tags(sdev->request_queue,
-                                    sdev->host->cmd_per_lun, shost->bqt);
+                                    sdev->host->cmd_per_lun, shost->bqt,
+                                    shost->hostt->tag_alloc_policy);
         }
         scsi_change_queue_depth(sdev, sdev->host->cmd_per_lun);
 
@@ -1367,7 +1355,6 @@ static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
         unsigned int retries;
         int result;
         struct scsi_lun *lunp, *lun_data;
-        u8 *data;
         struct scsi_sense_hdr sshdr;
         struct scsi_device *sdev;
         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
@@ -1407,16 +1394,12 @@ static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
 
         /*
          * Allocate enough to hold the header (the same size as one scsi_lun)
-         * plus the max number of luns we are requesting.
-         *
-         * Reallocating and trying again (with the exact amount we need)
-         * would be nice, but then we need to somehow limit the size
-         * allocated based on the available memory and the limits of
-         * kmalloc - we don't want a kmalloc() failure of a huge value to
-         * prevent us from finding any LUNs on this target.
+         * plus the number of luns we are requesting.  511 was the default
+         * value of the now removed max_report_luns parameter.
          */
-        length = (max_scsi_report_luns + 1) * sizeof(struct scsi_lun);
-        lun_data = kmalloc(length, GFP_ATOMIC |
+        length = (511 + 1) * sizeof(struct scsi_lun);
+retry:
+        lun_data = kmalloc(length, GFP_KERNEL |
                            (sdev->host->unchecked_isa_dma ? __GFP_DMA : 0));
         if (!lun_data) {
                 printk(ALLOC_FAILURE_MSG, __func__);
@@ -1433,10 +1416,7 @@ static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
         /*
          * bytes 6 - 9: length of the command.
          */
-        scsi_cmd[6] = (unsigned char) (length >> 24) & 0xff;
-        scsi_cmd[7] = (unsigned char) (length >> 16) & 0xff;
-        scsi_cmd[8] = (unsigned char) (length >> 8) & 0xff;
-        scsi_cmd[9] = (unsigned char) length & 0xff;
+        put_unaligned_be32(length, &scsi_cmd[6]);
 
         scsi_cmd[10] = 0;       /* reserved */
         scsi_cmd[11] = 0;       /* control */
@@ -1484,19 +1464,16 @@ static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
         /*
          * Get the length from the first four bytes of lun_data.
          */
-        data = (u8 *) lun_data->scsi_lun;
-        length = ((data[0] << 24) | (data[1] << 16) |
-                  (data[2] << 8) | (data[3] << 0));
+        if (get_unaligned_be32(lun_data->scsi_lun) +
+            sizeof(struct scsi_lun) > length) {
+                length = get_unaligned_be32(lun_data->scsi_lun) +
+                         sizeof(struct scsi_lun);
+                kfree(lun_data);
+                goto retry;
+        }
+        length = get_unaligned_be32(lun_data->scsi_lun);
 
         num_luns = (length / sizeof(struct scsi_lun));
-        if (num_luns > max_scsi_report_luns) {
-                sdev_printk(KERN_WARNING, sdev,
-                            "Only %d (max_scsi_report_luns)"
-                            " of %d luns reported, try increasing"
-                            " max_scsi_report_luns.\n",
-                            max_scsi_report_luns, num_luns);
-                num_luns = max_scsi_report_luns;
-        }
 
         SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
                 "scsi scan: REPORT LUN scan\n"));
diff --git a/drivers/scsi/scsi_trace.c b/drivers/scsi/scsi_trace.c
index 82af28b90294..08bb47b53bc3 100644
--- a/drivers/scsi/scsi_trace.c
+++ b/drivers/scsi/scsi_trace.c
@@ -143,7 +143,7 @@ scsi_trace_rw32(struct trace_seq *p, unsigned char *cdb, int len)
                 cmd = "WRITE_SAME";
                 break;
         default:
-                trace_seq_printf(p, "UNKNOWN");
+                trace_seq_puts(p, "UNKNOWN");
                 goto out;
         }
 
@@ -204,7 +204,7 @@ scsi_trace_service_action_in(struct trace_seq *p, unsigned char *cdb, int len)
                 cmd = "GET_LBA_STATUS";
                 break;
         default:
-                trace_seq_printf(p, "UNKNOWN");
+                trace_seq_puts(p, "UNKNOWN");
                 goto out;
         }
 
@@ -249,7 +249,7 @@ scsi_trace_misc(struct trace_seq *p, unsigned char *cdb, int len)
 {
         const char *ret = trace_seq_buffer_ptr(p);
 
-        trace_seq_printf(p, "-");
+        trace_seq_putc(p, '-');
         trace_seq_putc(p, 0);
 
         return ret;
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 05ea0d49a3a3..6b78476d04bb 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -3320,11 +3320,8 @@ module_exit(exit_sd);
 static void sd_print_sense_hdr(struct scsi_disk *sdkp,
                                struct scsi_sense_hdr *sshdr)
 {
-        scsi_show_sense_hdr(sdkp->device,
-                            sdkp->disk ? sdkp->disk->disk_name : NULL, sshdr);
-        scsi_show_extd_sense(sdkp->device,
-                             sdkp->disk ? sdkp->disk->disk_name : NULL,
-                             sshdr->asc, sshdr->ascq);
+        scsi_print_sense_hdr(sdkp->device,
+                             sdkp->disk ? sdkp->disk->disk_name : NULL, sshdr);
 }
 
 static void sd_print_result(const struct scsi_disk *sdkp, const char *msg,
diff --git a/drivers/scsi/ses.c b/drivers/scsi/ses.c
index b7e79e7646ad..dcb0d76d7312 100644
--- a/drivers/scsi/ses.c
+++ b/drivers/scsi/ses.c
@@ -47,7 +47,6 @@ struct ses_device {
 
 struct ses_component {
         u64 addr;
-        unsigned char *desc;
 };
 
 static int ses_probe(struct device *dev)
@@ -68,6 +67,20 @@ static int ses_probe(struct device *dev)
 #define SES_TIMEOUT (30 * HZ)
 #define SES_RETRIES 3
 
+static void init_device_slot_control(unsigned char *dest_desc,
+                                     struct enclosure_component *ecomp,
+                                     unsigned char *status)
+{
+        memcpy(dest_desc, status, 4);
+        dest_desc[0] = 0;
+        /* only clear byte 1 for ENCLOSURE_COMPONENT_DEVICE */
+        if (ecomp->type == ENCLOSURE_COMPONENT_DEVICE)
+                dest_desc[1] = 0;
+        dest_desc[2] &= 0xde;
+        dest_desc[3] &= 0x3c;
+}
+
+
 static int ses_recv_diag(struct scsi_device *sdev, int page_code,
                          void *buf, int bufflen)
 {
@@ -179,14 +192,22 @@ static int ses_set_fault(struct enclosure_device *edev,
                           struct enclosure_component *ecomp,
                          enum enclosure_component_setting val)
 {
-        unsigned char desc[4] = {0 };
+        unsigned char desc[4];
+        unsigned char *desc_ptr;
+
+        desc_ptr = ses_get_page2_descriptor(edev, ecomp);
+
+        if (!desc_ptr)
+                return -EIO;
+
+        init_device_slot_control(desc, ecomp, desc_ptr);
 
         switch (val) {
         case ENCLOSURE_SETTING_DISABLED:
-                /* zero is disabled */
+                desc[3] &= 0xdf;
                 break;
         case ENCLOSURE_SETTING_ENABLED:
-                desc[3] = 0x20;
+                desc[3] |= 0x20;
                 break;
         default:
                 /* SES doesn't do the SGPIO blink settings */
@@ -220,14 +241,22 @@ static int ses_set_locate(struct enclosure_device *edev,
                           struct enclosure_component *ecomp,
                           enum enclosure_component_setting val)
 {
-        unsigned char desc[4] = {0 };
+        unsigned char desc[4];
+        unsigned char *desc_ptr;
+
+        desc_ptr = ses_get_page2_descriptor(edev, ecomp);
+
+        if (!desc_ptr)
+                return -EIO;
+
+        init_device_slot_control(desc, ecomp, desc_ptr);
 
         switch (val) {
         case ENCLOSURE_SETTING_DISABLED:
-                /* zero is disabled */
+                desc[2] &= 0xfd;
                 break;
         case ENCLOSURE_SETTING_ENABLED:
-                desc[2] = 0x02;
+                desc[2] |= 0x02;
                 break;
         default:
                 /* SES doesn't do the SGPIO blink settings */
@@ -240,15 +269,23 @@ static int ses_set_active(struct enclosure_device *edev,
                           struct enclosure_component *ecomp,
                           enum enclosure_component_setting val)
 {
-        unsigned char desc[4] = {0 };
+        unsigned char desc[4];
+        unsigned char *desc_ptr;
+
+        desc_ptr = ses_get_page2_descriptor(edev, ecomp);
+
+        if (!desc_ptr)
+                return -EIO;
+
+        init_device_slot_control(desc, ecomp, desc_ptr);
 
         switch (val) {
         case ENCLOSURE_SETTING_DISABLED:
-                /* zero is disabled */
+                desc[2] &= 0x7f;
                 ecomp->active = 0;
                 break;
         case ENCLOSURE_SETTING_ENABLED:
-                desc[2] = 0x80;
+                desc[2] |= 0x80;
                 ecomp->active = 1;
                 break;
         default:
@@ -258,13 +295,63 @@ static int ses_set_active(struct enclosure_device *edev,
         return ses_set_page2_descriptor(edev, ecomp, desc);
 }
 
+static int ses_show_id(struct enclosure_device *edev, char *buf)
+{
+        struct ses_device *ses_dev = edev->scratch;
+        unsigned long long id = get_unaligned_be64(ses_dev->page1+8+4);
+
+        return sprintf(buf, "%#llx\n", id);
+}
+
+static void ses_get_power_status(struct enclosure_device *edev,
+                                 struct enclosure_component *ecomp)
+{
+        unsigned char *desc;
+
+        desc = ses_get_page2_descriptor(edev, ecomp);
+        if (desc)
+                ecomp->power_status = (desc[3] & 0x10) ? 0 : 1;
+}
+
+static int ses_set_power_status(struct enclosure_device *edev,
+                                struct enclosure_component *ecomp,
+                                int val)
+{
+        unsigned char desc[4];
+        unsigned char *desc_ptr;
+
+        desc_ptr = ses_get_page2_descriptor(edev, ecomp);
+
+        if (!desc_ptr)
+                return -EIO;
+
+        init_device_slot_control(desc, ecomp, desc_ptr);
+
+        switch (val) {
+        /* power = 1 is device_off = 0 and vice versa */
+        case 0:
+                desc[3] |= 0x10;
+                break;
+        case 1:
+                desc[3] &= 0xef;
+                break;
+        default:
+                return -EINVAL;
+        }
+        ecomp->power_status = val;
+        return ses_set_page2_descriptor(edev, ecomp, desc);
+}
+
 static struct enclosure_component_callbacks ses_enclosure_callbacks = {
         .get_fault              = ses_get_fault,
         .set_fault              = ses_set_fault,
         .get_status             = ses_get_status,
         .get_locate             = ses_get_locate,
         .set_locate             = ses_set_locate,
+        .get_power_status       = ses_get_power_status,
+        .set_power_status       = ses_set_power_status,
         .set_active             = ses_set_active,
+        .show_id                = ses_show_id,
 };
 
 struct ses_host_edev {
@@ -298,19 +385,26 @@ static void ses_process_descriptor(struct enclosure_component *ecomp,
         int invalid = desc[0] & 0x80;
         enum scsi_protocol proto = desc[0] & 0x0f;
         u64 addr = 0;
+        int slot = -1;
         struct ses_component *scomp = ecomp->scratch;
         unsigned char *d;
 
-        scomp->desc = desc;
-
         if (invalid)
                 return;
 
         switch (proto) {
+        case SCSI_PROTOCOL_FCP:
+                if (eip) {
+                        d = desc + 4;
+                        slot = d[3];
+                }
+                break;
         case SCSI_PROTOCOL_SAS:
-                if (eip)
+                if (eip) {
+                        d = desc + 4;
+                        slot = d[3];
                         d = desc + 8;
-                else
+                } else
                         d = desc + 4;
                 /* only take the phy0 addr */
                 addr = (u64)d[12] << 56 |
@@ -326,6 +420,7 @@ static void ses_process_descriptor(struct enclosure_component *ecomp,
                 /* FIXME: Need to add more protocols than just SAS */
                 break;
         }
+        ecomp->slot = slot;
         scomp->addr = addr;
 }
 
@@ -349,7 +444,8 @@ static int ses_enclosure_find_by_addr(struct enclosure_device *edev,
                 if (scomp->addr != efd->addr)
                         continue;
 
-                enclosure_add_device(edev, i, efd->dev);
+                if (enclosure_add_device(edev, i, efd->dev) == 0)
+                        kobject_uevent(&efd->dev->kobj, KOBJ_CHANGE);
                 return 1;
         }
         return 0;
@@ -423,16 +519,24 @@ static void ses_enclosure_data_process(struct enclosure_device *edev,
                             type_ptr[0] == ENCLOSURE_COMPONENT_ARRAY_DEVICE) {
 
                                 if (create)
-                                        ecomp = enclosure_component_register(edev,
-                                                                             components++,
-                                                                             type_ptr[0],
-                                                                             name);
+                                        ecomp = enclosure_component_alloc(
+                                                edev,
+                                                components++,
+                                                type_ptr[0],
+                                                name);
                                 else
                                         ecomp = &edev->component[components++];
 
-                                if (!IS_ERR(ecomp) && addl_desc_ptr)
-                                        ses_process_descriptor(ecomp,
-                                                               addl_desc_ptr);
+                                if (!IS_ERR(ecomp)) {
+                                        ses_get_power_status(edev, ecomp);
+                                        if (addl_desc_ptr)
+                                                ses_process_descriptor(
+                                                        ecomp,
+                                                        addl_desc_ptr);
+                                        if (create)
+                                                enclosure_component_register(
+                                                        ecomp);
+                                }
                         }
                         if (desc_ptr)
                                 desc_ptr += len;
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index b14f64cb9724..2270bd51f9c2 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -546,7 +546,7 @@ static ssize_t
 sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp)
 {
         sg_io_hdr_t *hp = &srp->header;
-        int err = 0;
+        int err = 0, err2;
         int len;
 
         if (count < SZ_SG_IO_HDR) {
@@ -575,8 +575,8 @@ sg_new_read(Sg_fd * sfp, char __user *buf, size_t count, Sg_request * srp)
                 goto err_out;
         }
 err_out:
-        err = sg_finish_rem_req(srp);
-        return (0 == err) ? count : err;
+        err2 = sg_finish_rem_req(srp);
+        return err ? : err2 ? : count;
 }
 
 static ssize_t
@@ -763,7 +763,7 @@ static int
 sg_common_write(Sg_fd * sfp, Sg_request * srp,
                 unsigned char *cmnd, int timeout, int blocking)
 {
-        int k, data_dir, at_head;
+        int k, at_head;
         Sg_device *sdp = sfp->parentdp;
         sg_io_hdr_t *hp = &srp->header;
 
@@ -793,21 +793,6 @@ sg_common_write(Sg_fd * sfp, Sg_request * srp,
                 return -ENODEV;
         }
 
-        switch (hp->dxfer_direction) {
-        case SG_DXFER_TO_FROM_DEV:
-        case SG_DXFER_FROM_DEV:
-                data_dir = DMA_FROM_DEVICE;
-                break;
-        case SG_DXFER_TO_DEV:
-                data_dir = DMA_TO_DEVICE;
-                break;
-        case SG_DXFER_UNKNOWN:
-                data_dir = DMA_BIDIRECTIONAL;
-                break;
-        default:
-                data_dir = DMA_NONE;
-                break;
-        }
         hp->duration = jiffies_to_msecs(jiffies);
         if (hp->interface_id != '\0' && /* v3 (or later) interface */
             (SG_FLAG_Q_AT_TAIL & hp->flags))
@@ -1350,6 +1335,17 @@ sg_rq_end_io(struct request *rq, int uptodate)
         }
         /* Rely on write phase to clean out srp status values, so no "else" */
 
+        /*
+         * Free the request as soon as it is complete so that its resources
+         * can be reused without waiting for userspace to read() the
+         * result.  But keep the associated bio (if any) around until
+         * blk_rq_unmap_user() can be called from user context.
+         */
+        srp->rq = NULL;
+        if (rq->cmd != rq->__cmd)
+                kfree(rq->cmd);
+        __blk_put_request(rq->q, rq);
+
         write_lock_irqsave(&sfp->rq_list_lock, iflags);
         if (unlikely(srp->orphan)) {
                 if (sfp->keep_orphan)
@@ -1684,7 +1680,22 @@ sg_start_req(Sg_request *srp, unsigned char *cmd)
                         return -ENOMEM;
         }
 
-        rq = blk_get_request(q, rw, GFP_ATOMIC);
+        /*
+         * NOTE
+         *
+         * With scsi-mq enabled, there are a fixed number of preallocated
+         * requests equal in number to shost->can_queue.  If all of the
+         * preallocated requests are already in use, then using GFP_ATOMIC with
+         * blk_get_request() will return -EWOULDBLOCK, whereas using GFP_KERNEL
+         * will cause blk_get_request() to sleep until an active command
+         * completes, freeing up a request.  Neither option is ideal, but
+         * GFP_KERNEL is the better choice to prevent userspace from getting an
+         * unexpected EWOULDBLOCK.
+         *
+         * With scsi-mq disabled, blk_get_request() with GFP_KERNEL usually
+         * does not sleep except under memory pressure.
+         */
+        rq = blk_get_request(q, rw, GFP_KERNEL);
         if (IS_ERR(rq)) {
                 kfree(long_cmdp);
                 return PTR_ERR(rq);
@@ -1734,22 +1745,19 @@ sg_start_req(Sg_request *srp, unsigned char *cmd)
         }
 
         if (iov_count) {
-                int len, size = sizeof(struct sg_iovec) * iov_count;
+                int size = sizeof(struct iovec) * iov_count;
                 struct iovec *iov;
+                struct iov_iter i;
 
                 iov = memdup_user(hp->dxferp, size);
                 if (IS_ERR(iov))
                         return PTR_ERR(iov);
 
-                len = iov_length(iov, iov_count);
-                if (hp->dxfer_len < len) {
-                        iov_count = iov_shorten(iov, iov_count, hp->dxfer_len);
-                        len = hp->dxfer_len;
-                }
+                iov_iter_init(&i, rw, iov, iov_count,
+                              min_t(size_t, hp->dxfer_len,
+                                    iov_length(iov, iov_count)));
 
-                res = blk_rq_map_user_iov(q, rq, md, (struct sg_iovec *)iov,
-                                          iov_count,
-                                          len, GFP_ATOMIC);
+                res = blk_rq_map_user_iov(q, rq, md, &i, GFP_ATOMIC);
                 kfree(iov);
         } else
                 res = blk_rq_map_user(q, rq, md, hp->dxferp,
@@ -1777,10 +1785,10 @@ sg_finish_rem_req(Sg_request *srp)
         SCSI_LOG_TIMEOUT(4, sg_printk(KERN_INFO, sfp->parentdp,
                                       "sg_finish_rem_req: res_used=%d\n",
                                       (int) srp->res_used));
-        if (srp->rq) {
-                if (srp->bio)
-                        ret = blk_rq_unmap_user(srp->bio);
+        if (srp->bio)
+                ret = blk_rq_unmap_user(srp->bio);
 
+        if (srp->rq) {
                 if (srp->rq->cmd != srp->rq->__cmd)
                         kfree(srp->rq->cmd);
                 blk_put_request(srp->rq);
diff --git a/drivers/scsi/sr_ioctl.c b/drivers/scsi/sr_ioctl.c
index fb929fac22ba..03054c0e7689 100644
--- a/drivers/scsi/sr_ioctl.c
+++ b/drivers/scsi/sr_ioctl.c
@@ -245,9 +245,6 @@ int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc)
                                 sr_printk(KERN_INFO, cd,
                                           "CDROM not ready.  Make sure there "
                                           "is a disc in the drive.\n");
-#ifdef DEBUG
-                        scsi_print_sense_hdr(cd->device, cd->cdi.name, &sshdr);
-#endif
                         err = -ENOMEDIUM;
                         break;
                 case ILLEGAL_REQUEST:
@@ -256,16 +253,8 @@ int sr_do_ioctl(Scsi_CD *cd, struct packet_command *cgc)
                             sshdr.ascq == 0x00)
                                 /* sense: Invalid command operation code */
                                 err = -EDRIVE_CANT_DO_THIS;
-#ifdef DEBUG
-                        __scsi_print_command(cgc->cmd, CDROM_PACKET_SIZE);
-                        scsi_print_sense_hdr(cd->device, cd->cdi.name, &sshdr);
-#endif
                         break;
                 default:
-                        sr_printk(KERN_ERR, cd,
-                                  "CDROM (ioctl) error, command: ");
-                        __scsi_print_command(cgc->cmd, CDROM_PACKET_SIZE);
-                        scsi_print_sense_hdr(cd->device, cd->cdi.name, &sshdr);
                         err = -EIO;
                 }
         }
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 128d3b55bdd9..9a1c34205254 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -4551,18 +4551,15 @@ static int sgl_map_user_pages(struct st_buffer *STbp,
                 return -ENOMEM;
 
         /* Try to fault in all of the necessary pages */
-        down_read(&current->mm->mmap_sem);
         /* rw==READ means read from drive, write into memory area */
-        res = get_user_pages(
+        res = get_user_pages_unlocked(
                 current,
                 current->mm,
                 uaddr,
                 nr_pages,
                 rw == READ,
                 0, /* don't force */
-                pages,
-                NULL);
-        up_read(&current->mm->mmap_sem);
+                pages);
 
         /* Errors and no page mapped should return here */
         if (res < nr_pages)
diff --git a/drivers/scsi/storvsc_drv.c b/drivers/scsi/storvsc_drv.c
index 4cff0ddc2c25..efc6e446b6c8 100644
--- a/drivers/scsi/storvsc_drv.c
+++ b/drivers/scsi/storvsc_drv.c
@@ -32,7 +32,6 @@
 #include <linux/module.h>
 #include <linux/device.h>
 #include <linux/hyperv.h>
-#include <linux/mempool.h>
 #include <linux/blkdev.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -309,14 +308,6 @@ enum storvsc_request_type {
  * This is the end of Protocol specific defines.
  */
 
-
-/*
- * We setup a mempool to allocate request structures for this driver
- * on a per-lun basis. The following define specifies the number of
- * elements in the pool.
- */
-
-#define STORVSC_MIN_BUF_NR                              64
 static int storvsc_ringbuffer_size = (20 * PAGE_SIZE);
 
 module_param(storvsc_ringbuffer_size, int, S_IRUGO);
@@ -346,7 +337,6 @@ static void storvsc_on_channel_callback(void *context);
 #define STORVSC_IDE_MAX_CHANNELS                        1
 
 struct storvsc_cmd_request {
-        struct list_head entry;
         struct scsi_cmnd *cmd;
 
         unsigned int bounce_sgl_count;
@@ -357,7 +347,6 @@ struct storvsc_cmd_request {
         /* Synchronize the request/response if needed */
         struct completion wait_event;
 
-        unsigned char *sense_buffer;
         struct hv_multipage_buffer data_buffer;
         struct vstor_packet vstor_packet;
 };
@@ -389,11 +378,6 @@ struct storvsc_device {
         struct storvsc_cmd_request reset_request;
 };
 
-struct stor_mem_pools {
-        struct kmem_cache *request_pool;
-        mempool_t *request_mempool;
-};
-
 struct hv_host_device {
         struct hv_device *dev;
         unsigned int port;
@@ -426,21 +410,42 @@ done:
         kfree(wrk);
 }
 
-static void storvsc_bus_scan(struct work_struct *work)
+static void storvsc_host_scan(struct work_struct *work)
 {
         struct storvsc_scan_work *wrk;
-        int id, order_id;
+        struct Scsi_Host *host;
+        struct scsi_device *sdev;
+        unsigned long flags;
 
         wrk = container_of(work, struct storvsc_scan_work, work);
-        for (id = 0; id < wrk->host->max_id; ++id) {
-                if (wrk->host->reverse_ordering)
-                        order_id = wrk->host->max_id - id - 1;
-                else
-                        order_id = id;
-
-                scsi_scan_target(&wrk->host->shost_gendev, 0,
-                                order_id, SCAN_WILD_CARD, 1);
+        host = wrk->host;
+
+        /*
+         * Before scanning the host, first check to see if any of the
+         * currrently known devices have been hot removed. We issue a
+         * "unit ready" command against all currently known devices.
+         * This I/O will result in an error for devices that have been
+         * removed. As part of handling the I/O error, we remove the device.
+         *
+         * When a LUN is added or removed, the host sends us a signal to
+         * scan the host. Thus we are forced to discover the LUNs that
+         * may have been removed this way.
+         */
+        mutex_lock(&host->scan_mutex);
+        spin_lock_irqsave(host->host_lock, flags);
+        list_for_each_entry(sdev, &host->__devices, siblings) {
+                spin_unlock_irqrestore(host->host_lock, flags);
+                scsi_test_unit_ready(sdev, 1, 1, NULL);
+                spin_lock_irqsave(host->host_lock, flags);
+                continue;
         }
+        spin_unlock_irqrestore(host->host_lock, flags);
+        mutex_unlock(&host->scan_mutex);
+        /*
+         * Now scan the host to discover LUNs that may have been added.
+         */
+        scsi_scan_host(host);
+
         kfree(wrk);
 }
 
@@ -1070,10 +1075,8 @@ static void storvsc_command_completion(struct storvsc_cmd_request *cmd_request)
 {
         struct scsi_cmnd *scmnd = cmd_request->cmd;
         struct hv_host_device *host_dev = shost_priv(scmnd->device->host);
-        void (*scsi_done_fn)(struct scsi_cmnd *);
         struct scsi_sense_hdr sense_hdr;
         struct vmscsi_request *vm_srb;
-        struct stor_mem_pools *memp = scmnd->device->hostdata;
         struct Scsi_Host *host;
         struct storvsc_device *stor_dev;
         struct hv_device *dev = host_dev->dev;
@@ -1109,14 +1112,7 @@ static void storvsc_command_completion(struct storvsc_cmd_request *cmd_request)
                 cmd_request->data_buffer.len -
                 vm_srb->data_transfer_length);
 
-        scsi_done_fn = scmnd->scsi_done;
-
-        scmnd->host_scribble = NULL;
-        scmnd->scsi_done = NULL;
-
-        scsi_done_fn(scmnd);
-
-        mempool_free(cmd_request, memp->request_mempool);
+        scmnd->scsi_done(scmnd);
 }
 
 static void storvsc_on_io_completion(struct hv_device *device,
@@ -1160,7 +1156,7 @@ static void storvsc_on_io_completion(struct hv_device *device,
                         SRB_STATUS_AUTOSENSE_VALID) {
                         /* autosense data available */
 
-                        memcpy(request->sense_buffer,
+                        memcpy(request->cmd->sense_buffer,
                                vstor_packet->vm_srb.sense_data,
                                vstor_packet->vm_srb.sense_info_length);
 
@@ -1198,7 +1194,7 @@ static void storvsc_on_receive(struct hv_device *device,
                 if (!work)
                         return;
 
-                INIT_WORK(&work->work, storvsc_bus_scan);
+                INIT_WORK(&work->work, storvsc_host_scan);
                 work->host = stor_device->host;
                 schedule_work(&work->work);
                 break;
@@ -1378,55 +1374,6 @@ static int storvsc_do_io(struct hv_device *device,
         return ret;
 }
 
-static int storvsc_device_alloc(struct scsi_device *sdevice)
-{
-        struct stor_mem_pools *memp;
-        int number = STORVSC_MIN_BUF_NR;
-
-        memp = kzalloc(sizeof(struct stor_mem_pools), GFP_KERNEL);
-        if (!memp)
-                return -ENOMEM;
-
-        memp->request_pool =
-                kmem_cache_create(dev_name(&sdevice->sdev_dev),
-                                sizeof(struct storvsc_cmd_request), 0,
-                                SLAB_HWCACHE_ALIGN, NULL);
-
-        if (!memp->request_pool)
-                goto err0;
-
-        memp->request_mempool = mempool_create(number, mempool_alloc_slab,
-                                                mempool_free_slab,
-                                                memp->request_pool);
-
-        if (!memp->request_mempool)
-                goto err1;
-
-        sdevice->hostdata = memp;
-
-        return 0;
-
-err1:
-        kmem_cache_destroy(memp->request_pool);
-
-err0:
-        kfree(memp);
-        return -ENOMEM;
-}
-
-static void storvsc_device_destroy(struct scsi_device *sdevice)
-{
-        struct stor_mem_pools *memp = sdevice->hostdata;
-
-        if (!memp)
-                return;
-
-        mempool_destroy(memp->request_mempool);
-        kmem_cache_destroy(memp->request_pool);
-        kfree(memp);
-        sdevice->hostdata = NULL;
-}
-
 static int storvsc_device_configure(struct scsi_device *sdevice)
 {
         scsi_change_queue_depth(sdevice, STORVSC_MAX_IO_REQUESTS);
@@ -1447,6 +1394,19 @@ static int storvsc_device_configure(struct scsi_device *sdevice)
          */
         sdevice->sdev_bflags |= msft_blist_flags;
 
+        /*
+         * If the host is WIN8 or WIN8 R2, claim conformance to SPC-3
+         * if the device is a MSFT virtual device.
+         */
+        if (!strncmp(sdevice->vendor, "Msft", 4)) {
+                switch (vmbus_proto_version) {
+                case VERSION_WIN8:
+                case VERSION_WIN8_1:
+                        sdevice->scsi_level = SCSI_SPC_3;
+                        break;
+                }
+        }
+
         return 0;
 }
 
@@ -1561,13 +1521,11 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
         int ret;
         struct hv_host_device *host_dev = shost_priv(host);
         struct hv_device *dev = host_dev->dev;
-        struct storvsc_cmd_request *cmd_request;
-        unsigned int request_size = 0;
+        struct storvsc_cmd_request *cmd_request = scsi_cmd_priv(scmnd);
         int i;
         struct scatterlist *sgl;
         unsigned int sg_count = 0;
         struct vmscsi_request *vm_srb;
-        struct stor_mem_pools *memp = scmnd->device->hostdata;
 
         if (vmstor_current_major <= VMSTOR_WIN8_MAJOR) {
                 /*
@@ -1584,25 +1542,9 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
                 }
         }
 
-        request_size = sizeof(struct storvsc_cmd_request);
-
-        cmd_request = mempool_alloc(memp->request_mempool,
-                                       GFP_ATOMIC);
-
-        /*
-         * We might be invoked in an interrupt context; hence
-         * mempool_alloc() can fail.
-         */
-        if (!cmd_request)
-                return SCSI_MLQUEUE_DEVICE_BUSY;
-
-        memset(cmd_request, 0, sizeof(struct storvsc_cmd_request));
-
         /* Setup the cmd request */
         cmd_request->cmd = scmnd;
 
-        scmnd->host_scribble = (unsigned char *)cmd_request;
-
         vm_srb = &cmd_request->vstor_packet.vm_srb;
         vm_srb->win8_extension.time_out_value = 60;
 
@@ -1637,9 +1579,6 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
 
         memcpy(vm_srb->cdb, scmnd->cmnd, vm_srb->cdb_length);
 
-        cmd_request->sense_buffer = scmnd->sense_buffer;
-
-
         cmd_request->data_buffer.len = scsi_bufflen(scmnd);
         if (scsi_sg_count(scmnd)) {
                 sgl = (struct scatterlist *)scsi_sglist(scmnd);
@@ -1651,10 +1590,8 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
                                 create_bounce_buffer(sgl, scsi_sg_count(scmnd),
                                                      scsi_bufflen(scmnd),
                                                      vm_srb->data_in);
-                        if (!cmd_request->bounce_sgl) {
-                                ret = SCSI_MLQUEUE_HOST_BUSY;
-                                goto queue_error;
-                        }
+                        if (!cmd_request->bounce_sgl)
+                                return SCSI_MLQUEUE_HOST_BUSY;
 
                         cmd_request->bounce_sgl_count =
                                 ALIGN(scsi_bufflen(scmnd), PAGE_SIZE) >>
@@ -1692,27 +1629,21 @@ static int storvsc_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *scmnd)
                         destroy_bounce_buffer(cmd_request->bounce_sgl,
                                         cmd_request->bounce_sgl_count);
 
-                ret = SCSI_MLQUEUE_DEVICE_BUSY;
-                goto queue_error;
+                return SCSI_MLQUEUE_DEVICE_BUSY;
         }
 
         return 0;
-
-queue_error:
-        mempool_free(cmd_request, memp->request_mempool);
-        scmnd->host_scribble = NULL;
-        return ret;
 }
 
 static struct scsi_host_template scsi_driver = {
         .module =               THIS_MODULE,
         .name =                 "storvsc_host_t",
+        .cmd_size =             sizeof(struct storvsc_cmd_request),
         .bios_param =           storvsc_get_chs,
         .queuecommand =         storvsc_queuecommand,
         .eh_host_reset_handler =        storvsc_host_reset_handler,
+        .proc_name =            "storvsc_host",
         .eh_timed_out =         storvsc_eh_timed_out,
-        .slave_alloc =          storvsc_device_alloc,
-        .slave_destroy =        storvsc_device_destroy,
         .slave_configure =      storvsc_device_configure,
         .cmd_per_lun =          255,
         .can_queue =            STORVSC_MAX_IO_REQUESTS*STORVSC_MAX_TARGETS,
@@ -1760,6 +1691,9 @@ static int storvsc_probe(struct hv_device *device,
         bool dev_is_ide = ((dev_id->driver_data == IDE_GUID) ? true : false);
         int target = 0;
         struct storvsc_device *stor_device;
+        int max_luns_per_target;
+        int max_targets;
+        int max_channels;
 
         /*
          * Based on the windows host we are running on,
@@ -1773,12 +1707,18 @@ static int storvsc_probe(struct hv_device *device,
                 vmscsi_size_delta = sizeof(struct vmscsi_win8_extension);
                 vmstor_current_major = VMSTOR_WIN7_MAJOR;
                 vmstor_current_minor = VMSTOR_WIN7_MINOR;
+                max_luns_per_target = STORVSC_IDE_MAX_LUNS_PER_TARGET;
+                max_targets = STORVSC_IDE_MAX_TARGETS;
+                max_channels = STORVSC_IDE_MAX_CHANNELS;
                 break;
         default:
                 sense_buffer_size = POST_WIN7_STORVSC_SENSE_BUFFER_SIZE;
                 vmscsi_size_delta = 0;
                 vmstor_current_major = VMSTOR_WIN8_MAJOR;
                 vmstor_current_minor = VMSTOR_WIN8_MINOR;
+                max_luns_per_target = STORVSC_MAX_LUNS_PER_TARGET;
+                max_targets = STORVSC_MAX_TARGETS;
+                max_channels = STORVSC_MAX_CHANNELS;
                 break;
         }
 
@@ -1826,9 +1766,9 @@ static int storvsc_probe(struct hv_device *device,
                 break;
 
         case SCSI_GUID:
-                host->max_lun = STORVSC_MAX_LUNS_PER_TARGET;
-                host->max_id = STORVSC_MAX_TARGETS;
-                host->max_channel = STORVSC_MAX_CHANNELS - 1;
+                host->max_lun = max_luns_per_target;
+                host->max_id = max_targets;
+                host->max_channel = max_channels - 1;
                 break;
 
         default:
diff --git a/drivers/scsi/ufs/Kconfig b/drivers/scsi/ufs/Kconfig
index 6e07b2afddeb..8a1f4b355416 100644
--- a/drivers/scsi/ufs/Kconfig
+++ b/drivers/scsi/ufs/Kconfig
@@ -70,3 +70,16 @@ config SCSI_UFSHCD_PLATFORM
         If you have a controller with this interface, say Y or M here.
 
           If unsure, say N.
+
+config SCSI_UFS_QCOM
+        bool "QCOM specific hooks to UFS controller platform driver"
+        depends on SCSI_UFSHCD_PLATFORM && ARCH_MSM
+        select PHY_QCOM_UFS
+        help
+          This selects the QCOM specific additions to UFSHCD platform driver.
+          UFS host on QCOM needs some vendor specific configuration before
+          accessing the hardware which includes PHY configuration and vendor
+          specific registers.
+
+          Select this if you have UFS controller on QCOM chipset.
+          If unsure, say N.
diff --git a/drivers/scsi/ufs/Makefile b/drivers/scsi/ufs/Makefile
index 1e5bd48457d6..8303bcce7a23 100644
--- a/drivers/scsi/ufs/Makefile
+++ b/drivers/scsi/ufs/Makefile
@@ -1,4 +1,5 @@
 # UFSHCD makefile
+obj-$(CONFIG_SCSI_UFS_QCOM) += ufs-qcom.o
 obj-$(CONFIG_SCSI_UFSHCD) += ufshcd.o
 obj-$(CONFIG_SCSI_UFSHCD_PCI) += ufshcd-pci.o
 obj-$(CONFIG_SCSI_UFSHCD_PLATFORM) += ufshcd-pltfrm.o
diff --git a/drivers/scsi/ufs/ufs-qcom.c b/drivers/scsi/ufs/ufs-qcom.c
new file mode 100644
index 000000000000..9217af9bf734
--- /dev/null
+++ b/drivers/scsi/ufs/ufs-qcom.c
@@ -0,0 +1,1004 @@
+/*
+ * Copyright (c) 2013-2015, Linux Foundation. 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 version 2 and
+ * only 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 <linux/time.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/phy/phy.h>
+
+#include <linux/phy/phy-qcom-ufs.h>
+#include "ufshcd.h"
+#include "unipro.h"
+#include "ufs-qcom.h"
+#include "ufshci.h"
+
+static struct ufs_qcom_host *ufs_qcom_hosts[MAX_UFS_QCOM_HOSTS];
+
+static void ufs_qcom_get_speed_mode(struct ufs_pa_layer_attr *p, char *result);
+static int ufs_qcom_get_bus_vote(struct ufs_qcom_host *host,
+                const char *speed_mode);
+static int ufs_qcom_set_bus_vote(struct ufs_qcom_host *host, int vote);
+
+static int ufs_qcom_get_connected_tx_lanes(struct ufs_hba *hba, u32 *tx_lanes)
+{
+        int err = 0;
+
+        err = ufshcd_dme_get(hba,
+                        UIC_ARG_MIB(PA_CONNECTEDTXDATALANES), tx_lanes);
+        if (err)
+                dev_err(hba->dev, "%s: couldn't read PA_CONNECTEDTXDATALANES %d\n",
+                                __func__, err);
+
+        return err;
+}
+
+static int ufs_qcom_host_clk_get(struct device *dev,
+                const char *name, struct clk **clk_out)
+{
+        struct clk *clk;
+        int err = 0;
+
+        clk = devm_clk_get(dev, name);
+        if (IS_ERR(clk)) {
+                err = PTR_ERR(clk);
+                dev_err(dev, "%s: failed to get %s err %d",
+                                __func__, name, err);
+        } else {
+                *clk_out = clk;
+        }
+
+        return err;
+}
+
+static int ufs_qcom_host_clk_enable(struct device *dev,
+                const char *name, struct clk *clk)
+{
+        int err = 0;
+
+        err = clk_prepare_enable(clk);
+        if (err)
+                dev_err(dev, "%s: %s enable failed %d\n", __func__, name, err);
+
+        return err;
+}
+
+static void ufs_qcom_disable_lane_clks(struct ufs_qcom_host *host)
+{
+        if (!host->is_lane_clks_enabled)
+                return;
+
+        clk_disable_unprepare(host->tx_l1_sync_clk);
+        clk_disable_unprepare(host->tx_l0_sync_clk);
+        clk_disable_unprepare(host->rx_l1_sync_clk);
+        clk_disable_unprepare(host->rx_l0_sync_clk);
+
+        host->is_lane_clks_enabled = false;
+}
+
+static int ufs_qcom_enable_lane_clks(struct ufs_qcom_host *host)
+{
+        int err = 0;
+        struct device *dev = host->hba->dev;
+
+        if (host->is_lane_clks_enabled)
+                return 0;
+
+        err = ufs_qcom_host_clk_enable(dev, "rx_lane0_sync_clk",
+                host->rx_l0_sync_clk);
+        if (err)
+                goto out;
+
+        err = ufs_qcom_host_clk_enable(dev, "tx_lane0_sync_clk",
+                host->tx_l0_sync_clk);
+        if (err)
+                goto disable_rx_l0;
+
+        err = ufs_qcom_host_clk_enable(dev, "rx_lane1_sync_clk",
+                host->rx_l1_sync_clk);
+        if (err)
+                goto disable_tx_l0;
+
+        err = ufs_qcom_host_clk_enable(dev, "tx_lane1_sync_clk",
+                host->tx_l1_sync_clk);
+        if (err)
+                goto disable_rx_l1;
+
+        host->is_lane_clks_enabled = true;
+        goto out;
+
+disable_rx_l1:
+        clk_disable_unprepare(host->rx_l1_sync_clk);
+disable_tx_l0:
+        clk_disable_unprepare(host->tx_l0_sync_clk);
+disable_rx_l0:
+        clk_disable_unprepare(host->rx_l0_sync_clk);
+out:
+        return err;
+}
+
+static int ufs_qcom_init_lane_clks(struct ufs_qcom_host *host)
+{
+        int err = 0;
+        struct device *dev = host->hba->dev;
+
+        err = ufs_qcom_host_clk_get(dev,
+                        "rx_lane0_sync_clk", &host->rx_l0_sync_clk);
+        if (err)
+                goto out;
+
+        err = ufs_qcom_host_clk_get(dev,
+                        "tx_lane0_sync_clk", &host->tx_l0_sync_clk);
+        if (err)
+                goto out;
+
+        err = ufs_qcom_host_clk_get(dev, "rx_lane1_sync_clk",
+                &host->rx_l1_sync_clk);
+        if (err)
+                goto out;
+
+        err = ufs_qcom_host_clk_get(dev, "tx_lane1_sync_clk",
+                &host->tx_l1_sync_clk);
+out:
+        return err;
+}
+
+static int ufs_qcom_link_startup_post_change(struct ufs_hba *hba)
+{
+        struct ufs_qcom_host *host = hba->priv;
+        struct phy *phy = host->generic_phy;
+        u32 tx_lanes;
+        int err = 0;
+
+        err = ufs_qcom_get_connected_tx_lanes(hba, &tx_lanes);
+        if (err)
+                goto out;
+
+        err = ufs_qcom_phy_set_tx_lane_enable(phy, tx_lanes);
+        if (err)
+                dev_err(hba->dev, "%s: ufs_qcom_phy_set_tx_lane_enable failed\n",
+                        __func__);
+
+out:
+        return err;
+}
+
+static int ufs_qcom_check_hibern8(struct ufs_hba *hba)
+{
+        int err;
+        u32 tx_fsm_val = 0;
+        unsigned long timeout = jiffies + msecs_to_jiffies(HBRN8_POLL_TOUT_MS);
+
+        do {
+                err = ufshcd_dme_get(hba,
+                        UIC_ARG_MIB(MPHY_TX_FSM_STATE), &tx_fsm_val);
+                if (err || tx_fsm_val == TX_FSM_HIBERN8)
+                        break;
+
+                /* sleep for max. 200us */
+                usleep_range(100, 200);
+        } while (time_before(jiffies, timeout));
+
+        /*
+         * we might have scheduled out for long during polling so
+         * check the state again.
+         */
+        if (time_after(jiffies, timeout))
+                err = ufshcd_dme_get(hba,
+                                UIC_ARG_MIB(MPHY_TX_FSM_STATE), &tx_fsm_val);
+
+        if (err) {
+                dev_err(hba->dev, "%s: unable to get TX_FSM_STATE, err %d\n",
+                                __func__, err);
+        } else if (tx_fsm_val != TX_FSM_HIBERN8) {
+                err = tx_fsm_val;
+                dev_err(hba->dev, "%s: invalid TX_FSM_STATE = %d\n",
+                                __func__, err);
+        }
+
+        return err;
+}
+
+static int ufs_qcom_power_up_sequence(struct ufs_hba *hba)
+{
+        struct ufs_qcom_host *host = hba->priv;
+        struct phy *phy = host->generic_phy;
+        int ret = 0;
+        u8 major;
+        u16 minor, step;
+        bool is_rate_B = (UFS_QCOM_LIMIT_HS_RATE == PA_HS_MODE_B)
+                                                        ? true : false;
+
+        /* Assert PHY reset and apply PHY calibration values */
+        ufs_qcom_assert_reset(hba);
+        /* provide 1ms delay to let the reset pulse propagate */
+        usleep_range(1000, 1100);
+
+        ufs_qcom_get_controller_revision(hba, &major, &minor, &step);
+        ufs_qcom_phy_save_controller_version(phy, major, minor, step);
+        ret = ufs_qcom_phy_calibrate_phy(phy, is_rate_B);
+        if (ret) {
+                dev_err(hba->dev, "%s: ufs_qcom_phy_calibrate_phy() failed, ret = %d\n",
+                        __func__, ret);
+                goto out;
+        }
+
+        /* De-assert PHY reset and start serdes */
+        ufs_qcom_deassert_reset(hba);
+
+        /*
+         * after reset deassertion, phy will need all ref clocks,
+         * voltage, current to settle down before starting serdes.
+         */
+        usleep_range(1000, 1100);
+        ret = ufs_qcom_phy_start_serdes(phy);
+        if (ret) {
+                dev_err(hba->dev, "%s: ufs_qcom_phy_start_serdes() failed, ret = %d\n",
+                        __func__, ret);
+                goto out;
+        }
+
+        ret = ufs_qcom_phy_is_pcs_ready(phy);
+        if (ret)
+                dev_err(hba->dev, "%s: is_physical_coding_sublayer_ready() failed, ret = %d\n",
+                        __func__, ret);
+
+out:
+        return ret;
+}
+
+/*
+ * The UTP controller has a number of internal clock gating cells (CGCs).
+ * Internal hardware sub-modules within the UTP controller control the CGCs.
+ * Hardware CGCs disable the clock to inactivate UTP sub-modules not involved
+ * in a specific operation, UTP controller CGCs are by default disabled and
+ * this function enables them (after every UFS link startup) to save some power
+ * leakage.
+ */
+static void ufs_qcom_enable_hw_clk_gating(struct ufs_hba *hba)
+{
+        ufshcd_writel(hba,
+                ufshcd_readl(hba, REG_UFS_CFG2) | REG_UFS_CFG2_CGC_EN_ALL,
+                REG_UFS_CFG2);
+
+        /* Ensure that HW clock gating is enabled before next operations */
+        mb();
+}
+
+static int ufs_qcom_hce_enable_notify(struct ufs_hba *hba, bool status)
+{
+        struct ufs_qcom_host *host = hba->priv;
+        int err = 0;
+
+        switch (status) {
+        case PRE_CHANGE:
+                ufs_qcom_power_up_sequence(hba);
+                /*
+                 * The PHY PLL output is the source of tx/rx lane symbol
+                 * clocks, hence, enable the lane clocks only after PHY
+                 * is initialized.
+                 */
+                err = ufs_qcom_enable_lane_clks(host);
+                break;
+        case POST_CHANGE:
+                /* check if UFS PHY moved from DISABLED to HIBERN8 */
+                err = ufs_qcom_check_hibern8(hba);
+                ufs_qcom_enable_hw_clk_gating(hba);
+
+                break;
+        default:
+                dev_err(hba->dev, "%s: invalid status %d\n", __func__, status);
+                err = -EINVAL;
+                break;
+        }
+        return err;
+}
+
+/**
+ * Returns non-zero for success (which rate of core_clk) and 0
+ * in case of a failure
+ */
+static unsigned long
+ufs_qcom_cfg_timers(struct ufs_hba *hba, u32 gear, u32 hs, u32 rate)
+{
+        struct ufs_clk_info *clki;
+        u32 core_clk_period_in_ns;
+        u32 tx_clk_cycles_per_us = 0;
+        unsigned long core_clk_rate = 0;
+        u32 core_clk_cycles_per_us = 0;
+
+        static u32 pwm_fr_table[][2] = {
+                {UFS_PWM_G1, 0x1},
+                {UFS_PWM_G2, 0x1},
+                {UFS_PWM_G3, 0x1},
+                {UFS_PWM_G4, 0x1},
+        };
+
+        static u32 hs_fr_table_rA[][2] = {
+                {UFS_HS_G1, 0x1F},
+                {UFS_HS_G2, 0x3e},
+        };
+
+        static u32 hs_fr_table_rB[][2] = {
+                {UFS_HS_G1, 0x24},
+                {UFS_HS_G2, 0x49},
+        };
+
+        if (gear == 0) {
+                dev_err(hba->dev, "%s: invalid gear = %d\n", __func__, gear);
+                goto out_error;
+        }
+
+        list_for_each_entry(clki, &hba->clk_list_head, list) {
+                if (!strcmp(clki->name, "core_clk"))
+                        core_clk_rate = clk_get_rate(clki->clk);
+        }
+
+        /* If frequency is smaller than 1MHz, set to 1MHz */
+        if (core_clk_rate < DEFAULT_CLK_RATE_HZ)
+                core_clk_rate = DEFAULT_CLK_RATE_HZ;
+
+        core_clk_cycles_per_us = core_clk_rate / USEC_PER_SEC;
+        ufshcd_writel(hba, core_clk_cycles_per_us, REG_UFS_SYS1CLK_1US);
+
+        core_clk_period_in_ns = NSEC_PER_SEC / core_clk_rate;
+        core_clk_period_in_ns <<= OFFSET_CLK_NS_REG;
+        core_clk_period_in_ns &= MASK_CLK_NS_REG;
+
+        switch (hs) {
+        case FASTAUTO_MODE:
+        case FAST_MODE:
+                if (rate == PA_HS_MODE_A) {
+                        if (gear > ARRAY_SIZE(hs_fr_table_rA)) {
+                                dev_err(hba->dev,
+                                        "%s: index %d exceeds table size %zu\n",
+                                        __func__, gear,
+                                        ARRAY_SIZE(hs_fr_table_rA));
+                                goto out_error;
+                        }
+                        tx_clk_cycles_per_us = hs_fr_table_rA[gear-1][1];
+                } else if (rate == PA_HS_MODE_B) {
+                        if (gear > ARRAY_SIZE(hs_fr_table_rB)) {
+                                dev_err(hba->dev,
+                                        "%s: index %d exceeds table size %zu\n",
+                                        __func__, gear,
+                                        ARRAY_SIZE(hs_fr_table_rB));
+                                goto out_error;
+                        }
+                        tx_clk_cycles_per_us = hs_fr_table_rB[gear-1][1];
+                } else {
+                        dev_err(hba->dev, "%s: invalid rate = %d\n",
+                                __func__, rate);
+                        goto out_error;
+                }
+                break;
+        case SLOWAUTO_MODE:
+        case SLOW_MODE:
+                if (gear > ARRAY_SIZE(pwm_fr_table)) {
+                        dev_err(hba->dev,
+                                        "%s: index %d exceeds table size %zu\n",
+                                        __func__, gear,
+                                        ARRAY_SIZE(pwm_fr_table));
+                        goto out_error;
+                }
+                tx_clk_cycles_per_us = pwm_fr_table[gear-1][1];
+                break;
+        case UNCHANGED:
+        default:
+                dev_err(hba->dev, "%s: invalid mode = %d\n", __func__, hs);
+                goto out_error;
+        }
+
+        /* this register 2 fields shall be written at once */
+        ufshcd_writel(hba, core_clk_period_in_ns | tx_clk_cycles_per_us,
+                                                REG_UFS_TX_SYMBOL_CLK_NS_US);
+        goto out;
+
+out_error:
+        core_clk_rate = 0;
+out:
+        return core_clk_rate;
+}
+
+static int ufs_qcom_link_startup_notify(struct ufs_hba *hba, bool status)
+{
+        unsigned long core_clk_rate = 0;
+        u32 core_clk_cycles_per_100ms;
+
+        switch (status) {
+        case PRE_CHANGE:
+                core_clk_rate = ufs_qcom_cfg_timers(hba, UFS_PWM_G1,
+                                                    SLOWAUTO_MODE, 0);
+                if (!core_clk_rate) {
+                        dev_err(hba->dev, "%s: ufs_qcom_cfg_timers() failed\n",
+                                __func__);
+                        return -EINVAL;
+                }
+                core_clk_cycles_per_100ms =
+                        (core_clk_rate / MSEC_PER_SEC) * 100;
+                ufshcd_writel(hba, core_clk_cycles_per_100ms,
+                                        REG_UFS_PA_LINK_STARTUP_TIMER);
+                break;
+        case POST_CHANGE:
+                ufs_qcom_link_startup_post_change(hba);
+                break;
+        default:
+                break;
+        }
+
+        return 0;
+}
+
+static int ufs_qcom_suspend(struct ufs_hba *hba, enum ufs_pm_op pm_op)
+{
+        struct ufs_qcom_host *host = hba->priv;
+        struct phy *phy = host->generic_phy;
+        int ret = 0;
+
+        if (ufs_qcom_is_link_off(hba)) {
+                /*
+                 * Disable the tx/rx lane symbol clocks before PHY is
+                 * powered down as the PLL source should be disabled
+                 * after downstream clocks are disabled.
+                 */
+                ufs_qcom_disable_lane_clks(host);
+                phy_power_off(phy);
+
+                /* Assert PHY soft reset */
+                ufs_qcom_assert_reset(hba);
+                goto out;
+        }
+
+        /*
+         * If UniPro link is not active, PHY ref_clk, main PHY analog power
+         * rail and low noise analog power rail for PLL can be switched off.
+         */
+        if (!ufs_qcom_is_link_active(hba))
+                phy_power_off(phy);
+
+out:
+        return ret;
+}
+
+static int ufs_qcom_resume(struct ufs_hba *hba, enum ufs_pm_op pm_op)
+{
+        struct ufs_qcom_host *host = hba->priv;
+        struct phy *phy = host->generic_phy;
+        int err;
+
+        err = phy_power_on(phy);
+        if (err) {
+                dev_err(hba->dev, "%s: failed enabling regs, err = %d\n",
+                        __func__, err);
+                goto out;
+        }
+
+        hba->is_sys_suspended = false;
+
+out:
+        return err;
+}
+
+struct ufs_qcom_dev_params {
+        u32 pwm_rx_gear;        /* pwm rx gear to work in */
+        u32 pwm_tx_gear;        /* pwm tx gear to work in */
+        u32 hs_rx_gear;         /* hs rx gear to work in */
+        u32 hs_tx_gear;         /* hs tx gear to work in */
+        u32 rx_lanes;           /* number of rx lanes */
+        u32 tx_lanes;           /* number of tx lanes */
+        u32 rx_pwr_pwm;         /* rx pwm working pwr */
+        u32 tx_pwr_pwm;         /* tx pwm working pwr */
+        u32 rx_pwr_hs;          /* rx hs working pwr */
+        u32 tx_pwr_hs;          /* tx hs working pwr */
+        u32 hs_rate;            /* rate A/B to work in HS */
+        u32 desired_working_mode;
+};
+
+static int ufs_qcom_get_pwr_dev_param(struct ufs_qcom_dev_params *qcom_param,
+                                      struct ufs_pa_layer_attr *dev_max,
+                                      struct ufs_pa_layer_attr *agreed_pwr)
+{
+        int min_qcom_gear;
+        int min_dev_gear;
+        bool is_dev_sup_hs = false;
+        bool is_qcom_max_hs = false;
+
+        if (dev_max->pwr_rx == FAST_MODE)
+                is_dev_sup_hs = true;
+
+        if (qcom_param->desired_working_mode == FAST) {
+                is_qcom_max_hs = true;
+                min_qcom_gear = min_t(u32, qcom_param->hs_rx_gear,
+                                      qcom_param->hs_tx_gear);
+        } else {
+                min_qcom_gear = min_t(u32, qcom_param->pwm_rx_gear,
+                                      qcom_param->pwm_tx_gear);
+        }
+
+        /*
+         * device doesn't support HS but qcom_param->desired_working_mode is
+         * HS, thus device and qcom_param don't agree
+         */
+        if (!is_dev_sup_hs && is_qcom_max_hs) {
+                pr_err("%s: failed to agree on power mode (device doesn't support HS but requested power is HS)\n",
+                        __func__);
+                return -ENOTSUPP;
+        } else if (is_dev_sup_hs && is_qcom_max_hs) {
+                /*
+                 * since device supports HS, it supports FAST_MODE.
+                 * since qcom_param->desired_working_mode is also HS
+                 * then final decision (FAST/FASTAUTO) is done according
+                 * to qcom_params as it is the restricting factor
+                 */
+                agreed_pwr->pwr_rx = agreed_pwr->pwr_tx =
+                                                qcom_param->rx_pwr_hs;
+        } else {
+                /*
+                 * here qcom_param->desired_working_mode is PWM.
+                 * it doesn't matter whether device supports HS or PWM,
+                 * in both cases qcom_param->desired_working_mode will
+                 * determine the mode
+                 */
+                 agreed_pwr->pwr_rx = agreed_pwr->pwr_tx =
+                                                qcom_param->rx_pwr_pwm;
+        }
+
+        /*
+         * we would like tx to work in the minimum number of lanes
+         * between device capability and vendor preferences.
+         * the same decision will be made for rx
+         */
+        agreed_pwr->lane_tx = min_t(u32, dev_max->lane_tx,
+                                                qcom_param->tx_lanes);
+        agreed_pwr->lane_rx = min_t(u32, dev_max->lane_rx,
+                                                qcom_param->rx_lanes);
+
+        /* device maximum gear is the minimum between device rx and tx gears */
+        min_dev_gear = min_t(u32, dev_max->gear_rx, dev_max->gear_tx);
+
+        /*
+         * if both device capabilities and vendor pre-defined preferences are
+         * both HS or both PWM then set the minimum gear to be the chosen
+         * working gear.
+         * if one is PWM and one is HS then the one that is PWM get to decide
+         * what is the gear, as it is the one that also decided previously what
+         * pwr the device will be configured to.
+         */
+        if ((is_dev_sup_hs && is_qcom_max_hs) ||
+            (!is_dev_sup_hs && !is_qcom_max_hs))
+                agreed_pwr->gear_rx = agreed_pwr->gear_tx =
+                        min_t(u32, min_dev_gear, min_qcom_gear);
+        else if (!is_dev_sup_hs)
+                agreed_pwr->gear_rx = agreed_pwr->gear_tx = min_dev_gear;
+        else
+                agreed_pwr->gear_rx = agreed_pwr->gear_tx = min_qcom_gear;
+
+        agreed_pwr->hs_rate = qcom_param->hs_rate;
+        return 0;
+}
+
+static int ufs_qcom_update_bus_bw_vote(struct ufs_qcom_host *host)
+{
+        int vote;
+        int err = 0;
+        char mode[BUS_VECTOR_NAME_LEN];
+
+        ufs_qcom_get_speed_mode(&host->dev_req_params, mode);
+
+        vote = ufs_qcom_get_bus_vote(host, mode);
+        if (vote >= 0)
+                err = ufs_qcom_set_bus_vote(host, vote);
+        else
+                err = vote;
+
+        if (err)
+                dev_err(host->hba->dev, "%s: failed %d\n", __func__, err);
+        else
+                host->bus_vote.saved_vote = vote;
+        return err;
+}
+
+static int ufs_qcom_pwr_change_notify(struct ufs_hba *hba,
+                                bool status,
+                                struct ufs_pa_layer_attr *dev_max_params,
+                                struct ufs_pa_layer_attr *dev_req_params)
+{
+        u32 val;
+        struct ufs_qcom_host *host = hba->priv;
+        struct phy *phy = host->generic_phy;
+        struct ufs_qcom_dev_params ufs_qcom_cap;
+        int ret = 0;
+        int res = 0;
+
+        if (!dev_req_params) {
+                pr_err("%s: incoming dev_req_params is NULL\n", __func__);
+                ret = -EINVAL;
+                goto out;
+        }
+
+        switch (status) {
+        case PRE_CHANGE:
+                ufs_qcom_cap.tx_lanes = UFS_QCOM_LIMIT_NUM_LANES_TX;
+                ufs_qcom_cap.rx_lanes = UFS_QCOM_LIMIT_NUM_LANES_RX;
+                ufs_qcom_cap.hs_rx_gear = UFS_QCOM_LIMIT_HSGEAR_RX;
+                ufs_qcom_cap.hs_tx_gear = UFS_QCOM_LIMIT_HSGEAR_TX;
+                ufs_qcom_cap.pwm_rx_gear = UFS_QCOM_LIMIT_PWMGEAR_RX;
+                ufs_qcom_cap.pwm_tx_gear = UFS_QCOM_LIMIT_PWMGEAR_TX;
+                ufs_qcom_cap.rx_pwr_pwm = UFS_QCOM_LIMIT_RX_PWR_PWM;
+                ufs_qcom_cap.tx_pwr_pwm = UFS_QCOM_LIMIT_TX_PWR_PWM;
+                ufs_qcom_cap.rx_pwr_hs = UFS_QCOM_LIMIT_RX_PWR_HS;
+                ufs_qcom_cap.tx_pwr_hs = UFS_QCOM_LIMIT_TX_PWR_HS;
+                ufs_qcom_cap.hs_rate = UFS_QCOM_LIMIT_HS_RATE;
+                ufs_qcom_cap.desired_working_mode =
+                                        UFS_QCOM_LIMIT_DESIRED_MODE;
+
+                ret = ufs_qcom_get_pwr_dev_param(&ufs_qcom_cap,
+                                                 dev_max_params,
+                                                 dev_req_params);
+                if (ret) {
+                        pr_err("%s: failed to determine capabilities\n",
+                                        __func__);
+                        goto out;
+                }
+
+                break;
+        case POST_CHANGE:
+                if (!ufs_qcom_cfg_timers(hba, dev_req_params->gear_rx,
+                                        dev_req_params->pwr_rx,
+                                        dev_req_params->hs_rate)) {
+                        dev_err(hba->dev, "%s: ufs_qcom_cfg_timers() failed\n",
+                                __func__);
+                        /*
+                         * we return error code at the end of the routine,
+                         * but continue to configure UFS_PHY_TX_LANE_ENABLE
+                         * and bus voting as usual
+                         */
+                        ret = -EINVAL;
+                }
+
+                val = ~(MAX_U32 << dev_req_params->lane_tx);
+                res = ufs_qcom_phy_set_tx_lane_enable(phy, val);
+                if (res) {
+                        dev_err(hba->dev, "%s: ufs_qcom_phy_set_tx_lane_enable() failed res = %d\n",
+                                __func__, res);
+                        ret = res;
+                }
+
+                /* cache the power mode parameters to use internally */
+                memcpy(&host->dev_req_params,
+                                dev_req_params, sizeof(*dev_req_params));
+                ufs_qcom_update_bus_bw_vote(host);
+                break;
+        default:
+                ret = -EINVAL;
+                break;
+        }
+out:
+        return ret;
+}
+
+/**
+ * ufs_qcom_advertise_quirks - advertise the known QCOM UFS controller quirks
+ * @hba: host controller instance
+ *
+ * QCOM UFS host controller might have some non standard behaviours (quirks)
+ * than what is specified by UFSHCI specification. Advertise all such
+ * quirks to standard UFS host controller driver so standard takes them into
+ * account.
+ */
+static void ufs_qcom_advertise_quirks(struct ufs_hba *hba)
+{
+        u8 major;
+        u16 minor, step;
+
+        ufs_qcom_get_controller_revision(hba, &major, &minor, &step);
+
+        /*
+         * TBD
+         * here we should be advertising controller quirks according to
+         * controller version.
+         */
+}
+
+static int ufs_qcom_get_bus_vote(struct ufs_qcom_host *host,
+                const char *speed_mode)
+{
+        struct device *dev = host->hba->dev;
+        struct device_node *np = dev->of_node;
+        int err;
+        const char *key = "qcom,bus-vector-names";
+
+        if (!speed_mode) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        if (host->bus_vote.is_max_bw_needed && !!strcmp(speed_mode, "MIN"))
+                err = of_property_match_string(np, key, "MAX");
+        else
+                err = of_property_match_string(np, key, speed_mode);
+
+out:
+        if (err < 0)
+                dev_err(dev, "%s: Invalid %s mode %d\n",
+                                __func__, speed_mode, err);
+        return err;
+}
+
+static int ufs_qcom_set_bus_vote(struct ufs_qcom_host *host, int vote)
+{
+        int err = 0;
+
+        if (vote != host->bus_vote.curr_vote)
+                host->bus_vote.curr_vote = vote;
+
+        return err;
+}
+
+static void ufs_qcom_get_speed_mode(struct ufs_pa_layer_attr *p, char *result)
+{
+        int gear = max_t(u32, p->gear_rx, p->gear_tx);
+        int lanes = max_t(u32, p->lane_rx, p->lane_tx);
+        int pwr;
+
+        /* default to PWM Gear 1, Lane 1 if power mode is not initialized */
+        if (!gear)
+                gear = 1;
+
+        if (!lanes)
+                lanes = 1;
+
+        if (!p->pwr_rx && !p->pwr_tx) {
+                pwr = SLOWAUTO_MODE;
+                snprintf(result, BUS_VECTOR_NAME_LEN, "MIN");
+        } else if (p->pwr_rx == FAST_MODE || p->pwr_rx == FASTAUTO_MODE ||
+                 p->pwr_tx == FAST_MODE || p->pwr_tx == FASTAUTO_MODE) {
+                pwr = FAST_MODE;
+                snprintf(result, BUS_VECTOR_NAME_LEN, "%s_R%s_G%d_L%d", "HS",
+                         p->hs_rate == PA_HS_MODE_B ? "B" : "A", gear, lanes);
+        } else {
+                pwr = SLOW_MODE;
+                snprintf(result, BUS_VECTOR_NAME_LEN, "%s_G%d_L%d",
+                         "PWM", gear, lanes);
+        }
+}
+
+static int ufs_qcom_setup_clocks(struct ufs_hba *hba, bool on)
+{
+        struct ufs_qcom_host *host = hba->priv;
+        int err = 0;
+        int vote = 0;
+
+        /*
+         * In case ufs_qcom_init() is not yet done, simply ignore.
+         * This ufs_qcom_setup_clocks() shall be called from
+         * ufs_qcom_init() after init is done.
+         */
+        if (!host)
+                return 0;
+
+        if (on) {
+                err = ufs_qcom_phy_enable_iface_clk(host->generic_phy);
+                if (err)
+                        goto out;
+
+                err = ufs_qcom_phy_enable_ref_clk(host->generic_phy);
+                if (err) {
+                        dev_err(hba->dev, "%s enable phy ref clock failed, err=%d\n",
+                                __func__, err);
+                        ufs_qcom_phy_disable_iface_clk(host->generic_phy);
+                        goto out;
+                }
+                /* enable the device ref clock */
+                ufs_qcom_phy_enable_dev_ref_clk(host->generic_phy);
+                vote = host->bus_vote.saved_vote;
+                if (vote == host->bus_vote.min_bw_vote)
+                        ufs_qcom_update_bus_bw_vote(host);
+        } else {
+                /* M-PHY RMMI interface clocks can be turned off */
+                ufs_qcom_phy_disable_iface_clk(host->generic_phy);
+                if (!ufs_qcom_is_link_active(hba)) {
+                        /* turn off UFS local PHY ref_clk */
+                        ufs_qcom_phy_disable_ref_clk(host->generic_phy);
+                        /* disable device ref_clk */
+                        ufs_qcom_phy_disable_dev_ref_clk(host->generic_phy);
+                }
+                vote = host->bus_vote.min_bw_vote;
+        }
+
+        err = ufs_qcom_set_bus_vote(host, vote);
+        if (err)
+                dev_err(hba->dev, "%s: set bus vote failed %d\n",
+                                __func__, err);
+
+out:
+        return err;
+}
+
+static ssize_t
+show_ufs_to_mem_max_bus_bw(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        struct ufs_hba *hba = dev_get_drvdata(dev);
+        struct ufs_qcom_host *host = hba->priv;
+
+        return snprintf(buf, PAGE_SIZE, "%u\n",
+                        host->bus_vote.is_max_bw_needed);
+}
+
+static ssize_t
+store_ufs_to_mem_max_bus_bw(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct ufs_hba *hba = dev_get_drvdata(dev);
+        struct ufs_qcom_host *host = hba->priv;
+        uint32_t value;
+
+        if (!kstrtou32(buf, 0, &value)) {
+                host->bus_vote.is_max_bw_needed = !!value;
+                ufs_qcom_update_bus_bw_vote(host);
+        }
+
+        return count;
+}
+
+static int ufs_qcom_bus_register(struct ufs_qcom_host *host)
+{
+        int err;
+        struct device *dev = host->hba->dev;
+        struct device_node *np = dev->of_node;
+
+        err = of_property_count_strings(np, "qcom,bus-vector-names");
+        if (err < 0 ) {
+                dev_err(dev, "%s: qcom,bus-vector-names not specified correctly %d\n",
+                                __func__, err);
+                goto out;
+        }
+
+        /* cache the vote index for minimum and maximum bandwidth */
+        host->bus_vote.min_bw_vote = ufs_qcom_get_bus_vote(host, "MIN");
+        host->bus_vote.max_bw_vote = ufs_qcom_get_bus_vote(host, "MAX");
+
+        host->bus_vote.max_bus_bw.show = show_ufs_to_mem_max_bus_bw;
+        host->bus_vote.max_bus_bw.store = store_ufs_to_mem_max_bus_bw;
+        sysfs_attr_init(&host->bus_vote.max_bus_bw.attr);
+        host->bus_vote.max_bus_bw.attr.name = "max_bus_bw";
+        host->bus_vote.max_bus_bw.attr.mode = S_IRUGO | S_IWUSR;
+        err = device_create_file(dev, &host->bus_vote.max_bus_bw);
+out:
+        return err;
+}
+
+#define ANDROID_BOOT_DEV_MAX    30
+static char android_boot_dev[ANDROID_BOOT_DEV_MAX];
+static int get_android_boot_dev(char *str)
+{
+        strlcpy(android_boot_dev, str, ANDROID_BOOT_DEV_MAX);
+        return 1;
+}
+__setup("androidboot.bootdevice=", get_android_boot_dev);
+
+/**
+ * ufs_qcom_init - bind phy with controller
+ * @hba: host controller instance
+ *
+ * Binds PHY with controller and powers up PHY enabling clocks
+ * and regulators.
+ *
+ * Returns -EPROBE_DEFER if binding fails, returns negative error
+ * on phy power up failure and returns zero on success.
+ */
+static int ufs_qcom_init(struct ufs_hba *hba)
+{
+        int err;
+        struct device *dev = hba->dev;
+        struct ufs_qcom_host *host;
+
+        if (strlen(android_boot_dev) && strcmp(android_boot_dev, dev_name(dev)))
+                return -ENODEV;
+
+        host = devm_kzalloc(dev, sizeof(*host), GFP_KERNEL);
+        if (!host) {
+                err = -ENOMEM;
+                dev_err(dev, "%s: no memory for qcom ufs host\n", __func__);
+                goto out;
+        }
+
+        host->hba = hba;
+        hba->priv = (void *)host;
+
+        host->generic_phy = devm_phy_get(dev, "ufsphy");
+
+        if (IS_ERR(host->generic_phy)) {
+                err = PTR_ERR(host->generic_phy);
+                dev_err(dev, "%s: PHY get failed %d\n", __func__, err);
+                goto out;
+        }
+
+        err = ufs_qcom_bus_register(host);
+        if (err)
+                goto out_host_free;
+
+        phy_init(host->generic_phy);
+        err = phy_power_on(host->generic_phy);
+        if (err)
+                goto out_unregister_bus;
+
+        err = ufs_qcom_init_lane_clks(host);
+        if (err)
+                goto out_disable_phy;
+
+        ufs_qcom_advertise_quirks(hba);
+
+        hba->caps |= UFSHCD_CAP_CLK_GATING | UFSHCD_CAP_CLK_SCALING;
+        hba->caps |= UFSHCD_CAP_AUTO_BKOPS_SUSPEND;
+
+        ufs_qcom_setup_clocks(hba, true);
+
+        if (hba->dev->id < MAX_UFS_QCOM_HOSTS)
+                ufs_qcom_hosts[hba->dev->id] = host;
+
+        goto out;
+
+out_disable_phy:
+        phy_power_off(host->generic_phy);
+out_unregister_bus:
+        phy_exit(host->generic_phy);
+out_host_free:
+        devm_kfree(dev, host);
+        hba->priv = NULL;
+out:
+        return err;
+}
+
+static void ufs_qcom_exit(struct ufs_hba *hba)
+{
+        struct ufs_qcom_host *host = hba->priv;
+
+        ufs_qcom_disable_lane_clks(host);
+        phy_power_off(host->generic_phy);
+}
+
+static
+void ufs_qcom_clk_scale_notify(struct ufs_hba *hba)
+{
+        struct ufs_qcom_host *host = hba->priv;
+        struct ufs_pa_layer_attr *dev_req_params = &host->dev_req_params;
+
+        if (!dev_req_params)
+                return;
+
+        ufs_qcom_cfg_timers(hba, dev_req_params->gear_rx,
+                                dev_req_params->pwr_rx,
+                                dev_req_params->hs_rate);
+}
+
+/**
+ * struct ufs_hba_qcom_vops - UFS QCOM specific variant operations
+ *
+ * The variant operations configure the necessary controller and PHY
+ * handshake during initialization.
+ */
+static const struct ufs_hba_variant_ops ufs_hba_qcom_vops = {
+        .name                   = "qcom",
+        .init                   = ufs_qcom_init,
+        .exit                   = ufs_qcom_exit,
+        .clk_scale_notify       = ufs_qcom_clk_scale_notify,
+        .setup_clocks           = ufs_qcom_setup_clocks,
+        .hce_enable_notify      = ufs_qcom_hce_enable_notify,
+        .link_startup_notify    = ufs_qcom_link_startup_notify,
+        .pwr_change_notify      = ufs_qcom_pwr_change_notify,
+        .suspend                = ufs_qcom_suspend,
+        .resume                 = ufs_qcom_resume,
+};
+EXPORT_SYMBOL(ufs_hba_qcom_vops);
diff --git a/drivers/scsi/ufs/ufs-qcom.h b/drivers/scsi/ufs/ufs-qcom.h
new file mode 100644
index 000000000000..9a6febd007df
--- /dev/null
+++ b/drivers/scsi/ufs/ufs-qcom.h
@@ -0,0 +1,170 @@
+/* Copyright (c) 2013-2015, The Linux Foundation. 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 version 2 and
+ * only 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 UFS_QCOM_H_
+#define UFS_QCOM_H_
+
+#define MAX_UFS_QCOM_HOSTS      1
+#define MAX_U32                 (~(u32)0)
+#define MPHY_TX_FSM_STATE       0x41
+#define TX_FSM_HIBERN8          0x1
+#define HBRN8_POLL_TOUT_MS      100
+#define DEFAULT_CLK_RATE_HZ     1000000
+#define BUS_VECTOR_NAME_LEN     32
+
+#define UFS_HW_VER_MAJOR_SHFT   (28)
+#define UFS_HW_VER_MAJOR_MASK   (0x000F << UFS_HW_VER_MAJOR_SHFT)
+#define UFS_HW_VER_MINOR_SHFT   (16)
+#define UFS_HW_VER_MINOR_MASK   (0x0FFF << UFS_HW_VER_MINOR_SHFT)
+#define UFS_HW_VER_STEP_SHFT    (0)
+#define UFS_HW_VER_STEP_MASK    (0xFFFF << UFS_HW_VER_STEP_SHFT)
+
+/* vendor specific pre-defined parameters */
+#define SLOW 1
+#define FAST 2
+
+#define UFS_QCOM_LIMIT_NUM_LANES_RX     2
+#define UFS_QCOM_LIMIT_NUM_LANES_TX     2
+#define UFS_QCOM_LIMIT_HSGEAR_RX        UFS_HS_G2
+#define UFS_QCOM_LIMIT_HSGEAR_TX        UFS_HS_G2
+#define UFS_QCOM_LIMIT_PWMGEAR_RX       UFS_PWM_G4
+#define UFS_QCOM_LIMIT_PWMGEAR_TX       UFS_PWM_G4
+#define UFS_QCOM_LIMIT_RX_PWR_PWM       SLOW_MODE
+#define UFS_QCOM_LIMIT_TX_PWR_PWM       SLOW_MODE
+#define UFS_QCOM_LIMIT_RX_PWR_HS        FAST_MODE
+#define UFS_QCOM_LIMIT_TX_PWR_HS        FAST_MODE
+#define UFS_QCOM_LIMIT_HS_RATE          PA_HS_MODE_B
+#define UFS_QCOM_LIMIT_DESIRED_MODE     FAST
+
+/* QCOM UFS host controller vendor specific registers */
+enum {
+        REG_UFS_SYS1CLK_1US                 = 0xC0,
+        REG_UFS_TX_SYMBOL_CLK_NS_US         = 0xC4,
+        REG_UFS_LOCAL_PORT_ID_REG           = 0xC8,
+        REG_UFS_PA_ERR_CODE                 = 0xCC,
+        REG_UFS_RETRY_TIMER_REG             = 0xD0,
+        REG_UFS_PA_LINK_STARTUP_TIMER       = 0xD8,
+        REG_UFS_CFG1                        = 0xDC,
+        REG_UFS_CFG2                        = 0xE0,
+        REG_UFS_HW_VERSION                  = 0xE4,
+
+        UFS_DBG_RD_REG_UAWM                     = 0x100,
+        UFS_DBG_RD_REG_UARM                     = 0x200,
+        UFS_DBG_RD_REG_TXUC                     = 0x300,
+        UFS_DBG_RD_REG_RXUC                     = 0x400,
+        UFS_DBG_RD_REG_DFC                      = 0x500,
+        UFS_DBG_RD_REG_TRLUT                    = 0x600,
+        UFS_DBG_RD_REG_TMRLUT                   = 0x700,
+        UFS_UFS_DBG_RD_REG_OCSC                 = 0x800,
+
+        UFS_UFS_DBG_RD_DESC_RAM                 = 0x1500,
+        UFS_UFS_DBG_RD_PRDT_RAM                 = 0x1700,
+        UFS_UFS_DBG_RD_RESP_RAM                 = 0x1800,
+        UFS_UFS_DBG_RD_EDTL_RAM                 = 0x1900,
+};
+
+/* bit definitions for REG_UFS_CFG2 register */
+#define UAWM_HW_CGC_EN          (1 << 0)
+#define UARM_HW_CGC_EN          (1 << 1)
+#define TXUC_HW_CGC_EN          (1 << 2)
+#define RXUC_HW_CGC_EN          (1 << 3)
+#define DFC_HW_CGC_EN           (1 << 4)
+#define TRLUT_HW_CGC_EN         (1 << 5)
+#define TMRLUT_HW_CGC_EN        (1 << 6)
+#define OCSC_HW_CGC_EN          (1 << 7)
+
+#define REG_UFS_CFG2_CGC_EN_ALL (UAWM_HW_CGC_EN | UARM_HW_CGC_EN |\
+                                 TXUC_HW_CGC_EN | RXUC_HW_CGC_EN |\
+                                 DFC_HW_CGC_EN | TRLUT_HW_CGC_EN |\
+                                 TMRLUT_HW_CGC_EN | OCSC_HW_CGC_EN)
+
+/* bit offset */
+enum {
+        OFFSET_UFS_PHY_SOFT_RESET           = 1,
+        OFFSET_CLK_NS_REG                   = 10,
+};
+
+/* bit masks */
+enum {
+        MASK_UFS_PHY_SOFT_RESET             = 0x2,
+        MASK_TX_SYMBOL_CLK_1US_REG          = 0x3FF,
+        MASK_CLK_NS_REG                     = 0xFFFC00,
+};
+
+enum ufs_qcom_phy_init_type {
+        UFS_PHY_INIT_FULL,
+        UFS_PHY_INIT_CFG_RESTORE,
+};
+
+static inline void
+ufs_qcom_get_controller_revision(struct ufs_hba *hba,
+                                 u8 *major, u16 *minor, u16 *step)
+{
+        u32 ver = ufshcd_readl(hba, REG_UFS_HW_VERSION);
+
+        *major = (ver & UFS_HW_VER_MAJOR_MASK) >> UFS_HW_VER_MAJOR_SHFT;
+        *minor = (ver & UFS_HW_VER_MINOR_MASK) >> UFS_HW_VER_MINOR_SHFT;
+        *step = (ver & UFS_HW_VER_STEP_MASK) >> UFS_HW_VER_STEP_SHFT;
+};
+
+static inline void ufs_qcom_assert_reset(struct ufs_hba *hba)
+{
+        ufshcd_rmwl(hba, MASK_UFS_PHY_SOFT_RESET,
+                        1 << OFFSET_UFS_PHY_SOFT_RESET, REG_UFS_CFG1);
+
+        /*
+         * Make sure assertion of ufs phy reset is written to
+         * register before returning
+         */
+        mb();
+}
+
+static inline void ufs_qcom_deassert_reset(struct ufs_hba *hba)
+{
+        ufshcd_rmwl(hba, MASK_UFS_PHY_SOFT_RESET,
+                        0 << OFFSET_UFS_PHY_SOFT_RESET, REG_UFS_CFG1);
+
+        /*
+         * Make sure de-assertion of ufs phy reset is written to
+         * register before returning
+         */
+        mb();
+}
+
+struct ufs_qcom_bus_vote {
+        uint32_t client_handle;
+        uint32_t curr_vote;
+        int min_bw_vote;
+        int max_bw_vote;
+        int saved_vote;
+        bool is_max_bw_needed;
+        struct device_attribute max_bus_bw;
+};
+
+struct ufs_qcom_host {
+        struct phy *generic_phy;
+        struct ufs_hba *hba;
+        struct ufs_qcom_bus_vote bus_vote;
+        struct ufs_pa_layer_attr dev_req_params;
+        struct clk *rx_l0_sync_clk;
+        struct clk *tx_l0_sync_clk;
+        struct clk *rx_l1_sync_clk;
+        struct clk *tx_l1_sync_clk;
+        bool is_lane_clks_enabled;
+};
+
+#define ufs_qcom_is_link_off(hba) ufshcd_is_link_off(hba)
+#define ufs_qcom_is_link_active(hba) ufshcd_is_link_active(hba)
+#define ufs_qcom_is_link_hibern8(hba) ufshcd_is_link_hibern8(hba)
+
+#endif /* UFS_QCOM_H_ */
diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 2e4614b9dddf..5d60a868830d 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
@@ -4714,10 +4714,8 @@ static int ufshcd_set_dev_pwr_mode(struct ufs_hba *hba,
                 sdev_printk(KERN_WARNING, sdp,
                             "START_STOP failed for power mode: %d, result %x\n",
                             pwr_mode, ret);
-                if (driver_byte(ret) & DRIVER_SENSE) {
-                        scsi_show_sense_hdr(sdp, NULL, &sshdr);
-                        scsi_show_extd_sense(sdp, NULL, sshdr.asc, sshdr.ascq);
-                }
+                if (driver_byte(ret) & DRIVER_SENSE)
+                        scsi_print_sense_hdr(sdp, NULL, &sshdr);
         }
 
         if (!ret)
diff --git a/drivers/scsi/virtio_scsi.c b/drivers/scsi/virtio_scsi.c
index c52bb5dfaedb..f164f24a4a55 100644
--- a/drivers/scsi/virtio_scsi.c
+++ b/drivers/scsi/virtio_scsi.c
@@ -950,6 +950,12 @@ static int virtscsi_probe(struct virtio_device *vdev)
         u32 num_queues;
         struct scsi_host_template *hostt;
 
+        if (!vdev->config->get) {
+                dev_err(&vdev->dev, "%s failure: config access disabled\n",
+                        __func__);
+                return -EINVAL;
+        }
+
         /* We need to know how many queues before we allocate. */
         num_queues = virtscsi_config_get(vdev, num_queues) ? : 1;
 
diff --git a/drivers/scsi/wd33c93.c b/drivers/scsi/wd33c93.c
index c0506de4f3b6..9e09da412b92 100644
--- a/drivers/scsi/wd33c93.c
+++ b/drivers/scsi/wd33c93.c
@@ -2143,22 +2143,22 @@ wd33c93_show_info(struct seq_file *m, struct Scsi_Host *instance)
                 seq_printf(m, "\nclock_freq=%02x no_sync=%02x no_dma=%d"
                         " dma_mode=%02x fast=%d",
                         hd->clock_freq, hd->no_sync, hd->no_dma, hd->dma_mode, hd->fast);
-                seq_printf(m, "\nsync_xfer[] =       ");
+                seq_puts(m, "\nsync_xfer[] =       ");
                 for (x = 0; x < 7; x++)
                         seq_printf(m, "\t%02x", hd->sync_xfer[x]);
-                seq_printf(m, "\nsync_stat[] =       ");
+                seq_puts(m, "\nsync_stat[] =       ");
                 for (x = 0; x < 7; x++)
                         seq_printf(m, "\t%02x", hd->sync_stat[x]);
         }
 #ifdef PROC_STATISTICS
         if (hd->proc & PR_STATISTICS) {
-                seq_printf(m, "\ncommands issued:    ");
+                seq_puts(m, "\ncommands issued:    ");
                 for (x = 0; x < 7; x++)
                         seq_printf(m, "\t%ld", hd->cmd_cnt[x]);
-                seq_printf(m, "\ndisconnects allowed:");
+                seq_puts(m, "\ndisconnects allowed:");
                 for (x = 0; x < 7; x++)
                         seq_printf(m, "\t%ld", hd->disc_allowed_cnt[x]);
-                seq_printf(m, "\ndisconnects done:   ");
+                seq_puts(m, "\ndisconnects done:   ");
                 for (x = 0; x < 7; x++)
                         seq_printf(m, "\t%ld", hd->disc_done_cnt[x]);
                 seq_printf(m,
@@ -2167,7 +2167,7 @@ wd33c93_show_info(struct seq_file *m, struct Scsi_Host *instance)
         }
 #endif
         if (hd->proc & PR_CONNECTED) {
-                seq_printf(m, "\nconnected:     ");
+                seq_puts(m, "\nconnected:     ");
                 if (hd->connected) {
                         cmd = (struct scsi_cmnd *) hd->connected;
                         seq_printf(m, " %d:%llu(%02x)",
@@ -2175,7 +2175,7 @@ wd33c93_show_info(struct seq_file *m, struct Scsi_Host *instance)
                 }
         }
         if (hd->proc & PR_INPUTQ) {
-                seq_printf(m, "\ninput_Q:       ");
+                seq_puts(m, "\ninput_Q:       ");
                 cmd = (struct scsi_cmnd *) hd->input_Q;
                 while (cmd) {
                         seq_printf(m, " %d:%llu(%02x)",
@@ -2184,7 +2184,7 @@ wd33c93_show_info(struct seq_file *m, struct Scsi_Host *instance)
                 }
         }
         if (hd->proc & PR_DISCQ) {
-                seq_printf(m, "\ndisconnected_Q:");
+                seq_puts(m, "\ndisconnected_Q:");
                 cmd = (struct scsi_cmnd *) hd->disconnected_Q;
                 while (cmd) {
                         seq_printf(m, " %d:%llu(%02x)",
@@ -2192,7 +2192,7 @@ wd33c93_show_info(struct seq_file *m, struct Scsi_Host *instance)
                         cmd = (struct scsi_cmnd *) cmd->host_scribble;
                 }
         }
-        seq_printf(m, "\n");
+        seq_putc(m, '\n');
         spin_unlock_irq(&hd->lock);
 #endif                          /* PROC_INTERFACE */
         return 0;
diff --git a/drivers/scsi/wd7000.c b/drivers/scsi/wd7000.c
index f94d73611ab4..0c0f17b9a3eb 100644
--- a/drivers/scsi/wd7000.c
+++ b/drivers/scsi/wd7000.c
@@ -1295,9 +1295,6 @@ static void wd7000_revision(Adapter * host)
 }
 
 
-#undef SPRINTF
-#define SPRINTF(args...) { seq_printf(m, ## args); }
-
 static int wd7000_set_info(struct Scsi_Host *host, char *buffer, int length)
 {
         dprintk("Buffer = <%.*s>, length = %d\n", length, buffer, length);
@@ -1320,43 +1317,43 @@ static int wd7000_show_info(struct seq_file *m, struct Scsi_Host *host)
 #endif
 
         spin_lock_irqsave(host->host_lock, flags);
-        SPRINTF("Host scsi%d: Western Digital WD-7000 (rev %d.%d)\n", host->host_no, adapter->rev1, adapter->rev2);
-        SPRINTF("  IO base:      0x%x\n", adapter->iobase);
-        SPRINTF("  IRQ:          %d\n", adapter->irq);
-        SPRINTF("  DMA channel:  %d\n", adapter->dma);
-        SPRINTF("  Interrupts:   %d\n", adapter->int_counter);
-        SPRINTF("  BUS_ON time:  %d nanoseconds\n", adapter->bus_on * 125);
-        SPRINTF("  BUS_OFF time: %d nanoseconds\n", adapter->bus_off * 125);
+        seq_printf(m, "Host scsi%d: Western Digital WD-7000 (rev %d.%d)\n", host->host_no, adapter->rev1, adapter->rev2);
+        seq_printf(m, "  IO base:      0x%x\n", adapter->iobase);
+        seq_printf(m, "  IRQ:          %d\n", adapter->irq);
+        seq_printf(m, "  DMA channel:  %d\n", adapter->dma);
+        seq_printf(m, "  Interrupts:   %d\n", adapter->int_counter);
+        seq_printf(m, "  BUS_ON time:  %d nanoseconds\n", adapter->bus_on * 125);
+        seq_printf(m, "  BUS_OFF time: %d nanoseconds\n", adapter->bus_off * 125);
 
 #ifdef WD7000_DEBUG
         ogmbs = adapter->mb.ogmb;
         icmbs = adapter->mb.icmb;
 
-        SPRINTF("\nControl port value: 0x%x\n", adapter->control);
-        SPRINTF("Incoming mailbox:\n");
-        SPRINTF("  size: %d\n", ICMB_CNT);
-        SPRINTF("  queued messages: ");
+        seq_printf(m, "\nControl port value: 0x%x\n", adapter->control);
+        seq_puts(m, "Incoming mailbox:\n");
+        seq_printf(m, "  size: %d\n", ICMB_CNT);
+        seq_puts(m, "  queued messages: ");
 
         for (i = count = 0; i < ICMB_CNT; i++)
                 if (icmbs[i].status) {
                         count++;
-                        SPRINTF("0x%x ", i);
+                        seq_printf(m, "0x%x ", i);
                 }
 
-        SPRINTF(count ? "\n" : "none\n");
+        seq_puts(m, count ? "\n" : "none\n");
 
-        SPRINTF("Outgoing mailbox:\n");
-        SPRINTF("  size: %d\n", OGMB_CNT);
-        SPRINTF("  next message: 0x%x\n", adapter->next_ogmb);
-        SPRINTF("  queued messages: ");
+        seq_puts(m, "Outgoing mailbox:\n");
+        seq_printf(m, "  size: %d\n", OGMB_CNT);
+        seq_printf(m, "  next message: 0x%x\n", adapter->next_ogmb);
+        seq_puts(m, "  queued messages: ");
 
         for (i = count = 0; i < OGMB_CNT; i++)
                 if (ogmbs[i].status) {
                         count++;
-                        SPRINTF("0x%x ", i);
+                        seq_printf(m, "0x%x ", i);
                 }
 
-        SPRINTF(count ? "\n" : "none\n");
+        seq_puts(m, count ? "\n" : "none\n");
 #endif
 
         spin_unlock_irqrestore(host->host_lock, flags);
diff --git a/drivers/scsi/wd719x.c b/drivers/scsi/wd719x.c
index 7702664d7ed3..289ad016d925 100644
--- a/drivers/scsi/wd719x.c
+++ b/drivers/scsi/wd719x.c
@@ -870,6 +870,7 @@ fail_free_params:
 }
 
 static struct scsi_host_template wd719x_template = {
+        .module                         = THIS_MODULE,
         .name                           = "Western Digital 719x",
         .queuecommand                   = wd719x_queuecommand,
         .eh_abort_handler               = wd719x_abort,