Merge git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6: (110 commits)
  [SCSI] qla2xxx: Refactor call to qla2xxx_read_sfp for thermal temperature.
  [SCSI] qla2xxx: Unify the read/write sfp mailbox command routines.
  [SCSI] qla2xxx: Clear complete initialization control block.
  [SCSI] qla2xxx: Allow an override of the registered maximum LUN.
  [SCSI] qla2xxx: Add host number in reset and quiescent message logs.
  [SCSI] qla2xxx: Correctly read sfp single byte mailbox register.
  [SCSI] qla2xxx: Add qla82xx_rom_unlock() function.
  [SCSI] qla2xxx: Log if qla82xx firmware fails to load from flash.
  [SCSI] qla2xxx: Use passed in host to initialize local scsi_qla_host in queuecommand function
  [SCSI] qla2xxx: Correct buffer start in edc sysfs debug print.
  [SCSI] qla2xxx: Update firmware version after flash update for ISP82xx.
  [SCSI] qla2xxx: Fix hang during driver unload when vport is active.
  [SCSI] qla2xxx: Properly set the dsd_list_len for dsd_chaining in cmd type 6.
  [SCSI] qla2xxx: Fix virtual port failing to login after chip reset.
  [SCSI] qla2xxx: Fix vport delete hang when logins are outstanding.
  [SCSI] hpsa: Change memset using sizeof(ptr) to sizeof(*ptr)
  [SCSI] ipr: Rate limit DMA mapping errors
  [SCSI] hpsa: add P2000 to list of shared SAS devices
  [SCSI] hpsa: do not attempt PCI power management reset method if we know it won't work.
  [SCSI] hpsa: remove superfluous sleeps around reset code
  ...

119 files changed, 6387 insertions, 1679 deletions

diff --git a/Documentation/scsi/LICENSE.qla2xxx b/Documentation/scsi/LICENSE.qla2xxx
index 9e15b4f9cd28..19e7cd4bba66 100644
--- a/Documentation/scsi/LICENSE.qla2xxx
+++ b/Documentation/scsi/LICENSE.qla2xxx
@@ -1,11 +1,11 @@
-Copyright (c)  2003-2005 QLogic Corporation
-QLogic Linux Fibre Channel HBA Driver
+Copyright (c) 2003-2011 QLogic Corporation
+QLogic Linux/ESX Fibre Channel HBA Driver
 
-This program includes a device driver for Linux 2.6 that may be
+This program includes a device driver for Linux 2.6/ESX that may be
 distributed with QLogic hardware specific firmware binary file.
 You may modify and redistribute the device driver code under the
-GNU General Public License as published by the Free Software
-Foundation (version 2 or a later version).
+GNU General Public License (a copy of which is attached hereto as
+Exhibit A) published by the Free Software Foundation (version 2).
 
 You may redistribute the hardware specific firmware binary file
 under the following terms:
@@ -43,3 +43,285 @@ OTHERWISE IN ANY INTELLECTUAL PROPERTY RIGHTS (PATENT, COPYRIGHT,
 TRADE SECRET, MASK WORK, OR OTHER PROPRIETARY RIGHT) EMBODIED IN
 ANY OTHER QLOGIC HARDWARE OR SOFTWARE EITHER SOLELY OR IN
 COMBINATION WITH THIS PROGRAM.
+
+
+EXHIBIT A
+
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
diff --git a/MAINTAINERS b/MAINTAINERS
index 8df8d2dfba28..ae67c34518cd 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -5611,9 +5611,9 @@ F:	include/linux/ata.h
 F:      include/linux/libata.h
 
 SERVER ENGINES 10Gbps iSCSI - BladeEngine 2 DRIVER
-M:      Jayamohan Kallickal <jayamohank@serverengines.com>
+M:      Jayamohan Kallickal <jayamohan.kallickal@emulex.com>
 L:      linux-scsi@vger.kernel.org
-W:      http://www.serverengines.com
+W:      http://www.emulex.com
 S:      Supported
 F:      drivers/scsi/be2iscsi/
 
diff --git a/drivers/message/fusion/mptbase.h b/drivers/message/fusion/mptbase.h
index 1735c84ff757..fe902338539b 100644
--- a/drivers/message/fusion/mptbase.h
+++ b/drivers/message/fusion/mptbase.h
@@ -76,8 +76,8 @@
 #define COPYRIGHT       "Copyright (c) 1999-2008 " MODULEAUTHOR
 #endif
 
-#define MPT_LINUX_VERSION_COMMON        "3.04.18"
-#define MPT_LINUX_PACKAGE_NAME          "@(#)mptlinux-3.04.18"
+#define MPT_LINUX_VERSION_COMMON        "3.04.19"
+#define MPT_LINUX_PACKAGE_NAME          "@(#)mptlinux-3.04.19"
 #define WHAT_MAGIC_STRING               "@" "(" "#" ")"
 
 #define show_mptmod_ver(s,ver)  \
diff --git a/drivers/message/fusion/mptsas.c b/drivers/message/fusion/mptsas.c
index 66f94125de4e..7596aecd5072 100644
--- a/drivers/message/fusion/mptsas.c
+++ b/drivers/message/fusion/mptsas.c
@@ -5012,7 +5012,6 @@ mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
                         (ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)) {
                         VirtTarget *vtarget = NULL;
                         u8              id, channel;
-                        u32      log_info = le32_to_cpu(reply->IOCLogInfo);
 
                         id = sas_event_data->TargetID;
                         channel = sas_event_data->Bus;
@@ -5023,7 +5022,8 @@ mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply)
                                     "LogInfo (0x%x) available for "
                                    "INTERNAL_DEVICE_RESET"
                                    "fw_id %d fw_channel %d\n", ioc->name,
-                                   log_info, id, channel));
+                                   le32_to_cpu(reply->IOCLogInfo),
+                                   id, channel));
                                 if (vtarget->raidVolume) {
                                         devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT
                                         "Skipping Raid Volume for inDMD\n",
diff --git a/drivers/message/fusion/mptscsih.c b/drivers/message/fusion/mptscsih.c
index 0d9b82a44540..a1d4ee6671be 100644
--- a/drivers/message/fusion/mptscsih.c
+++ b/drivers/message/fusion/mptscsih.c
@@ -1415,11 +1415,8 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
         dmfprintk(ioc, printk(MYIOC_s_DEBUG_FMT "qcmd: SCpnt=%p, done()=%p\n",
                 ioc->name, SCpnt, done));
 
-        if (ioc->taskmgmt_quiesce_io) {
-                dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "qcmd: SCpnt=%p timeout + 60HZ\n",
-                        ioc->name, SCpnt));
+        if (ioc->taskmgmt_quiesce_io)
                 return SCSI_MLQUEUE_HOST_BUSY;
-        }
 
         /*
          *  Put together a MPT SCSI request...
@@ -1773,7 +1770,6 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
         int              scpnt_idx;
         int              retval;
         VirtDevice       *vdevice;
-        ulong            sn = SCpnt->serial_number;
         MPT_ADAPTER     *ioc;
 
         /* If we can't locate our host adapter structure, return FAILED status.
@@ -1859,8 +1855,7 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
                          vdevice->vtarget->id, vdevice->lun,
                          ctx2abort, mptscsih_get_tm_timeout(ioc));
 
-        if (SCPNT_TO_LOOKUP_IDX(ioc, SCpnt) == scpnt_idx &&
-            SCpnt->serial_number == sn) {
+        if (SCPNT_TO_LOOKUP_IDX(ioc, SCpnt) == scpnt_idx) {
                 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT
                     "task abort: command still in active list! (sc=%p)\n",
                     ioc->name, SCpnt));
@@ -1873,9 +1868,9 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
         }
 
  out:
-        printk(MYIOC_s_INFO_FMT "task abort: %s (rv=%04x) (sc=%p) (sn=%ld)\n",
+        printk(MYIOC_s_INFO_FMT "task abort: %s (rv=%04x) (sc=%p)\n",
             ioc->name, ((retval == SUCCESS) ? "SUCCESS" : "FAILED"), retval,
-            SCpnt, SCpnt->serial_number);
+            SCpnt);
 
         return retval;
 }
diff --git a/drivers/message/fusion/mptspi.c b/drivers/message/fusion/mptspi.c
index 6d9568d2ec59..8f61ba6aac23 100644
--- a/drivers/message/fusion/mptspi.c
+++ b/drivers/message/fusion/mptspi.c
@@ -867,6 +867,10 @@ static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
         struct _x_config_parms cfg;
         struct _CONFIG_PAGE_HEADER hdr;
         int err = -EBUSY;
+        u32 nego_parms;
+        u32 period;
+        struct scsi_device *sdev;
+        int i;
 
         /* don't allow updating nego parameters on RAID devices */
         if (starget->channel == 0 &&
@@ -904,6 +908,24 @@ static int mptspi_write_spi_device_pg1(struct scsi_target *starget,
         pg1->Header.PageNumber = hdr.PageNumber;
         pg1->Header.PageType = hdr.PageType;
 
+        nego_parms = le32_to_cpu(pg1->RequestedParameters);
+        period = (nego_parms & MPI_SCSIDEVPAGE1_RP_MIN_SYNC_PERIOD_MASK) >>
+                MPI_SCSIDEVPAGE1_RP_SHIFT_MIN_SYNC_PERIOD;
+        if (period == 8) {
+                /* Turn on inline data padding for TAPE when running U320 */
+                for (i = 0 ; i < 16; i++) {
+                        sdev = scsi_device_lookup_by_target(starget, i);
+                        if (sdev && sdev->type == TYPE_TAPE) {
+                                sdev_printk(KERN_DEBUG, sdev, MYIOC_s_FMT
+                                            "IDP:ON\n", ioc->name);
+                                nego_parms |= MPI_SCSIDEVPAGE1_RP_IDP;
+                                pg1->RequestedParameters =
+                                    cpu_to_le32(nego_parms);
+                                break;
+                        }
+                }
+        }
+
         mptspi_print_write_nego(hd, starget, le32_to_cpu(pg1->RequestedParameters));
 
         if (mpt_config(ioc, &cfg)) {
diff --git a/drivers/message/i2o/i2o_scsi.c b/drivers/message/i2o/i2o_scsi.c
index f003957e8e1c..74fbe56321ff 100644
--- a/drivers/message/i2o/i2o_scsi.c
+++ b/drivers/message/i2o/i2o_scsi.c
@@ -361,7 +361,7 @@ static int i2o_scsi_reply(struct i2o_controller *c, u32 m,
          */
         error = le32_to_cpu(msg->body[0]);
 
-        osm_debug("Completed %ld\n", cmd->serial_number);
+        osm_debug("Completed %0x%p\n", cmd);
 
         cmd->result = error & 0xff;
         /*
@@ -678,7 +678,7 @@ static int i2o_scsi_queuecommand_lck(struct scsi_cmnd *SCpnt,
         /* Queue the message */
         i2o_msg_post(c, msg);
 
-        osm_debug("Issued %ld\n", SCpnt->serial_number);
+        osm_debug("Issued %0x%p\n", SCpnt);
 
         return 0;
 
diff --git a/drivers/scsi/arcmsr/arcmsr_hba.c b/drivers/scsi/arcmsr/arcmsr_hba.c
index da7b9887ec48..f980600f78a8 100644
--- a/drivers/scsi/arcmsr/arcmsr_hba.c
+++ b/drivers/scsi/arcmsr/arcmsr_hba.c
@@ -75,8 +75,10 @@ MODULE_AUTHOR("Nick Cheng <support@areca.com.tw>");
 MODULE_DESCRIPTION("ARECA (ARC11xx/12xx/16xx/1880) SATA/SAS RAID Host Bus Adapter");
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_VERSION(ARCMSR_DRIVER_VERSION);
-static int sleeptime = 10;
-static int retrycount = 12;
+
+#define ARCMSR_SLEEPTIME        10
+#define ARCMSR_RETRYCOUNT       12
+
 wait_queue_head_t wait_q;
 static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb,
                                         struct scsi_cmnd *cmd);
@@ -171,24 +173,6 @@ static struct pci_driver arcmsr_pci_driver = {
 ****************************************************************************
 ****************************************************************************
 */
-int arcmsr_sleep_for_bus_reset(struct scsi_cmnd *cmd)
-{
-                struct Scsi_Host *shost = NULL;
-                int i, isleep;
-                shost = cmd->device->host;
-                isleep = sleeptime / 10;
-                if (isleep > 0) {
-                        for (i = 0; i < isleep; i++) {
-                                msleep(10000);
-                        }
-                }
-
-                isleep = sleeptime % 10;
-                if (isleep > 0) {
-                        msleep(isleep*1000);
-                }
-                return 0;
-}
 
 static void arcmsr_free_hbb_mu(struct AdapterControlBlock *acb)
 {
@@ -323,66 +307,64 @@ static void arcmsr_define_adapter_type(struct AdapterControlBlock *acb)
 
         default: acb->adapter_type = ACB_ADAPTER_TYPE_A;
         }
-}       
+}
 
 static uint8_t arcmsr_hba_wait_msgint_ready(struct AdapterControlBlock *acb)
 {
         struct MessageUnit_A __iomem *reg = acb->pmuA;
-        uint32_t Index;
-        uint8_t Retries = 0x00;
-        do {
-                for (Index = 0; Index < 100; Index++) {
-                        if (readl(&reg->outbound_intstatus) &
-                                        ARCMSR_MU_OUTBOUND_MESSAGE0_INT) {
-                                writel(ARCMSR_MU_OUTBOUND_MESSAGE0_INT,
-                                        &reg->outbound_intstatus);
-                                return true;
-                        }
-                        msleep(10);
-                }/*max 1 seconds*/
+        int i;
+
+        for (i = 0; i < 2000; i++) {
+                if (readl(&reg->outbound_intstatus) &
+                                ARCMSR_MU_OUTBOUND_MESSAGE0_INT) {
+                        writel(ARCMSR_MU_OUTBOUND_MESSAGE0_INT,
+                                &reg->outbound_intstatus);
+                        return true;
+                }
+                msleep(10);
+        } /* max 20 seconds */
 
-        } while (Retries++ < 20);/*max 20 sec*/
         return false;
 }
 
 static uint8_t arcmsr_hbb_wait_msgint_ready(struct AdapterControlBlock *acb)
 {
         struct MessageUnit_B *reg = acb->pmuB;
-        uint32_t Index;
-        uint8_t Retries = 0x00;
-        do {
-                for (Index = 0; Index < 100; Index++) {
-                        if (readl(reg->iop2drv_doorbell)
-                                & ARCMSR_IOP2DRV_MESSAGE_CMD_DONE) {
-                                writel(ARCMSR_MESSAGE_INT_CLEAR_PATTERN
-                                        , reg->iop2drv_doorbell);
-                                writel(ARCMSR_DRV2IOP_END_OF_INTERRUPT, reg->drv2iop_doorbell);
-                                return true;
-                        }
-                        msleep(10);
-                }/*max 1 seconds*/
+        int i;
+
+        for (i = 0; i < 2000; i++) {
+                if (readl(reg->iop2drv_doorbell)
+                        & ARCMSR_IOP2DRV_MESSAGE_CMD_DONE) {
+                        writel(ARCMSR_MESSAGE_INT_CLEAR_PATTERN,
+                                        reg->iop2drv_doorbell);
+                        writel(ARCMSR_DRV2IOP_END_OF_INTERRUPT,
+                                        reg->drv2iop_doorbell);
+                        return true;
+                }
+                msleep(10);
+        } /* max 20 seconds */
 
-        } while (Retries++ < 20);/*max 20 sec*/
         return false;
 }
 
 static uint8_t arcmsr_hbc_wait_msgint_ready(struct AdapterControlBlock *pACB)
 {
         struct MessageUnit_C *phbcmu = (struct MessageUnit_C *)pACB->pmuC;
-        unsigned char Retries = 0x00;
-        uint32_t Index;
-        do {
-                for (Index = 0; Index < 100; Index++) {
-                        if (readl(&phbcmu->outbound_doorbell) & ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE) {
-                                writel(ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE_DOORBELL_CLEAR, &phbcmu->outbound_doorbell_clear);/*clear interrupt*/
-                                return true;
-                        }
-                        /* one us delay */
-                        msleep(10);
-                } /*max 1 seconds*/
-        } while (Retries++ < 20); /*max 20 sec*/
+        int i;
+
+        for (i = 0; i < 2000; i++) {
+                if (readl(&phbcmu->outbound_doorbell)
+                                & ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE) {
+                        writel(ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE_DOORBELL_CLEAR,
+                                &phbcmu->outbound_doorbell_clear); /*clear interrupt*/
+                        return true;
+                }
+                msleep(10);
+        } /* max 20 seconds */
+
         return false;
 }
+
 static void arcmsr_flush_hba_cache(struct AdapterControlBlock *acb)
 {
         struct MessageUnit_A __iomem *reg = acb->pmuA;
@@ -459,10 +441,11 @@ static int arcmsr_alloc_ccb_pool(struct AdapterControlBlock *acb)
         struct CommandControlBlock *ccb_tmp;
         int i = 0, j = 0;
         dma_addr_t cdb_phyaddr;
-        unsigned long roundup_ccbsize = 0, offset;
+        unsigned long roundup_ccbsize;
         unsigned long max_xfer_len;
         unsigned long max_sg_entrys;
         uint32_t  firm_config_version;
+
         for (i = 0; i < ARCMSR_MAX_TARGETID; i++)
                 for (j = 0; j < ARCMSR_MAX_TARGETLUN; j++)
                         acb->devstate[i][j] = ARECA_RAID_GONE;
@@ -472,23 +455,20 @@ static int arcmsr_alloc_ccb_pool(struct AdapterControlBlock *acb)
         firm_config_version = acb->firm_cfg_version;
         if((firm_config_version & 0xFF) >= 3){
                 max_xfer_len = (ARCMSR_CDB_SG_PAGE_LENGTH << ((firm_config_version >> 8) & 0xFF)) * 1024;/* max 4M byte */
-                max_sg_entrys = (max_xfer_len/4096);    
+                max_sg_entrys = (max_xfer_len/4096);
         }
         acb->host->max_sectors = max_xfer_len/512;
         acb->host->sg_tablesize = max_sg_entrys;
         roundup_ccbsize = roundup(sizeof(struct CommandControlBlock) + (max_sg_entrys - 1) * sizeof(struct SG64ENTRY), 32);
-        acb->uncache_size = roundup_ccbsize * ARCMSR_MAX_FREECCB_NUM + 32;
+        acb->uncache_size = roundup_ccbsize * ARCMSR_MAX_FREECCB_NUM;
         dma_coherent = dma_alloc_coherent(&pdev->dev, acb->uncache_size, &dma_coherent_handle, GFP_KERNEL);
         if(!dma_coherent){
-                printk(KERN_NOTICE "arcmsr%d: dma_alloc_coherent got error \n", acb->host->host_no);
+                printk(KERN_NOTICE "arcmsr%d: dma_alloc_coherent got error\n", acb->host->host_no);
                 return -ENOMEM;
         }
         acb->dma_coherent = dma_coherent;
         acb->dma_coherent_handle = dma_coherent_handle;
         memset(dma_coherent, 0, acb->uncache_size);
-        offset = roundup((unsigned long)dma_coherent, 32) - (unsigned long)dma_coherent;
-        dma_coherent_handle = dma_coherent_handle + offset;
-        dma_coherent = (struct CommandControlBlock *)dma_coherent + offset;
         ccb_tmp = dma_coherent;
         acb->vir2phy_offset = (unsigned long)dma_coherent - (unsigned long)dma_coherent_handle;
         for(i = 0; i < ARCMSR_MAX_FREECCB_NUM; i++){
@@ -2602,12 +2582,8 @@ static int arcmsr_iop_confirm(struct AdapterControlBlock *acb)
                 if (cdb_phyaddr_hi32 != 0) {
                         struct MessageUnit_C *reg = (struct MessageUnit_C *)acb->pmuC;
 
-                        if (cdb_phyaddr_hi32 != 0) {
-                                unsigned char Retries = 0x00;
-                                do {
-                                        printk(KERN_NOTICE "arcmsr%d: cdb_phyaddr_hi32=0x%x \n", acb->adapter_index, cdb_phyaddr_hi32);
-                                } while (Retries++ < 100);
-                        }
+                        printk(KERN_NOTICE "arcmsr%d: cdb_phyaddr_hi32=0x%x\n",
+                                        acb->adapter_index, cdb_phyaddr_hi32);
                         writel(ARCMSR_SIGNATURE_SET_CONFIG, &reg->msgcode_rwbuffer[0]);
                         writel(cdb_phyaddr_hi32, &reg->msgcode_rwbuffer[1]);
                         writel(ARCMSR_INBOUND_MESG0_SET_CONFIG, &reg->inbound_msgaddr0);
@@ -2955,12 +2931,12 @@ static int arcmsr_bus_reset(struct scsi_cmnd *cmd)
                                 arcmsr_hardware_reset(acb);
                                 acb->acb_flags &= ~ACB_F_IOP_INITED;
 sleep_again:
-                                arcmsr_sleep_for_bus_reset(cmd);
+                                ssleep(ARCMSR_SLEEPTIME);
                                 if ((readl(&reg->outbound_msgaddr1) & ARCMSR_OUTBOUND_MESG1_FIRMWARE_OK) == 0) {
-                                        printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, retry=%d \n", acb->host->host_no, retry_count);
-                                        if (retry_count > retrycount) {
+                                        printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, retry=%d\n", acb->host->host_no, retry_count);
+                                        if (retry_count > ARCMSR_RETRYCOUNT) {
                                                 acb->fw_flag = FW_DEADLOCK;
-                                                printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, RETRY TERMINATED!! \n", acb->host->host_no);
+                                                printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, RETRY TERMINATED!!\n", acb->host->host_no);
                                                 return FAILED;
                                         }
                                         retry_count++;
@@ -3025,12 +3001,12 @@ sleep_again:
                                 arcmsr_hardware_reset(acb);
                                 acb->acb_flags &= ~ACB_F_IOP_INITED;
 sleep:
-                                arcmsr_sleep_for_bus_reset(cmd);
+                                ssleep(ARCMSR_SLEEPTIME);
                                 if ((readl(&reg->host_diagnostic) & 0x04) != 0) {
-                                        printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, retry=%d \n", acb->host->host_no, retry_count);
-                                        if (retry_count > retrycount) {
+                                        printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, retry=%d\n", acb->host->host_no, retry_count);
+                                        if (retry_count > ARCMSR_RETRYCOUNT) {
                                                 acb->fw_flag = FW_DEADLOCK;
-                                                printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, RETRY TERMINATED!! \n", acb->host->host_no);
+                                                printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, RETRY TERMINATED!!\n", acb->host->host_no);
                                                 return FAILED;
                                         }
                                         retry_count++;
diff --git a/drivers/scsi/be2iscsi/be.h b/drivers/scsi/be2iscsi/be.h
index 1cb8a5e85c7f..1d7b976c850f 100644
--- a/drivers/scsi/be2iscsi/be.h
+++ b/drivers/scsi/be2iscsi/be.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -8,11 +8,11 @@
  * Public License is included in this distribution in the file called COPYING.
  *
  * Contact Information:
- * linux-drivers@serverengines.com
+ * linux-drivers@emulex.com
  *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #ifndef BEISCSI_H
diff --git a/drivers/scsi/be2iscsi/be_cmds.c b/drivers/scsi/be2iscsi/be_cmds.c
index ad246369d373..b8a82f2c62c8 100644
--- a/drivers/scsi/be2iscsi/be_cmds.c
+++ b/drivers/scsi/be2iscsi/be_cmds.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -8,11 +8,11 @@
  * Public License is included in this distribution in the file called COPYING.
  *
  * Contact Information:
- * linux-drivers@serverengines.com
+ * linux-drivers@emulex.com
  *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #include "be.h"
@@ -458,6 +458,7 @@ void be_cmd_hdr_prepare(struct be_cmd_req_hdr *req_hdr,
         req_hdr->opcode = opcode;
         req_hdr->subsystem = subsystem;
         req_hdr->request_length = cpu_to_le32(cmd_len - sizeof(*req_hdr));
+        req_hdr->timeout = 120;
 }
 
 static void be_cmd_page_addrs_prepare(struct phys_addr *pages, u32 max_pages,
diff --git a/drivers/scsi/be2iscsi/be_cmds.h b/drivers/scsi/be2iscsi/be_cmds.h
index fbd1dc2c15f7..497eb29e5c9e 100644
--- a/drivers/scsi/be2iscsi/be_cmds.h
+++ b/drivers/scsi/be2iscsi/be_cmds.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -8,11 +8,11 @@
  * Public License is included in this distribution in the file called COPYING.
  *
  * Contact Information:
- * linux-drivers@serverengines.com
+ * linux-drivers@emulex.com
  *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #ifndef BEISCSI_CMDS_H
diff --git a/drivers/scsi/be2iscsi/be_iscsi.c b/drivers/scsi/be2iscsi/be_iscsi.c
index 868cc5590145..3cad10605023 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.c
+++ b/drivers/scsi/be2iscsi/be_iscsi.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -7,15 +7,14 @@
  * as published by the Free Software Foundation.  The full GNU General
  * Public License is included in this distribution in the file called COPYING.
  *
- * Written by: Jayamohan Kallickal (jayamohank@serverengines.com)
+ * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
  *
  * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * linux-drivers@emulex.com
  *
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #include <scsi/libiscsi.h>
diff --git a/drivers/scsi/be2iscsi/be_iscsi.h b/drivers/scsi/be2iscsi/be_iscsi.h
index 9c532797c29e..ff60b7fd92d6 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.h
+++ b/drivers/scsi/be2iscsi/be_iscsi.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -7,15 +7,14 @@
  * as published by the Free Software Foundation.  The full GNU General
  * Public License is included in this distribution in the file called COPYING.
  *
- * Written by: Jayamohan Kallickal (jayamohank@serverengines.com)
+ * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
  *
  * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * linux-drivers@emulex.com
  *
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #ifndef _BE_ISCSI_
diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 24e20ba9633c..cea9b275965c 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -7,16 +7,16 @@
  * as published by the Free Software Foundation.  The full GNU General
  * Public License is included in this distribution in the file called COPYING.
  *
- * Written by: Jayamohan Kallickal (jayamohank@serverengines.com)
+ * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
  *
  * Contact Information:
- * linux-drivers@serverengines.com
- *
- *  ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * linux-drivers@emulex.com
  *
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
+
 #include <linux/reboot.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
@@ -420,7 +420,8 @@ static int beiscsi_setup_boot_info(struct beiscsi_hba *phba)
         return 0;
 
 free_kset:
-        iscsi_boot_destroy_kset(phba->boot_kset);
+        if (phba->boot_kset)
+                iscsi_boot_destroy_kset(phba->boot_kset);
         return -ENOMEM;
 }
 
@@ -3464,23 +3465,23 @@ static void hwi_enable_intr(struct beiscsi_hba *phba)
         addr = (u8 __iomem *) ((u8 __iomem *) ctrl->pcicfg +
                         PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET);
         reg = ioread32(addr);
-        SE_DEBUG(DBG_LVL_8, "reg =x%08x\n", reg);
 
         enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
         if (!enabled) {
                 reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
                 SE_DEBUG(DBG_LVL_8, "reg =x%08x addr=%p\n", reg, addr);
                 iowrite32(reg, addr);
-                if (!phba->msix_enabled) {
-                        eq = &phwi_context->be_eq[0].q;
+        }
+
+        if (!phba->msix_enabled) {
+                eq = &phwi_context->be_eq[0].q;
+                SE_DEBUG(DBG_LVL_8, "eq->id=%d\n", eq->id);
+                hwi_ring_eq_db(phba, eq->id, 0, 0, 1, 1);
+        } else {
+                for (i = 0; i <= phba->num_cpus; i++) {
+                        eq = &phwi_context->be_eq[i].q;
                         SE_DEBUG(DBG_LVL_8, "eq->id=%d\n", eq->id);
                         hwi_ring_eq_db(phba, eq->id, 0, 0, 1, 1);
-                } else {
-                        for (i = 0; i <= phba->num_cpus; i++) {
-                                eq = &phwi_context->be_eq[i].q;
-                                SE_DEBUG(DBG_LVL_8, "eq->id=%d\n", eq->id);
-                                hwi_ring_eq_db(phba, eq->id, 0, 0, 1, 1);
-                        }
                 }
         }
 }
@@ -4019,12 +4020,17 @@ static int beiscsi_mtask(struct iscsi_task *task)
                 hwi_write_buffer(pwrb, task);
                 break;
         case ISCSI_OP_NOOP_OUT:
-                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                              INI_RD_CMD);
-                if (task->hdr->ttt == ISCSI_RESERVED_TAG)
+                if (task->hdr->ttt != ISCSI_RESERVED_TAG) {
+                        AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                                      TGT_DM_CMD);
+                        AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt,
+                                      pwrb, 0);
                         AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
-                else
+                } else {
+                        AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                                      INI_RD_CMD);
                         AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 1);
+                }
                 hwi_write_buffer(pwrb, task);
                 break;
         case ISCSI_OP_TEXT:
@@ -4144,10 +4150,11 @@ static void beiscsi_remove(struct pci_dev *pcidev)
                             phba->ctrl.mbox_mem_alloced.size,
                             phba->ctrl.mbox_mem_alloced.va,
                             phba->ctrl.mbox_mem_alloced.dma);
+        if (phba->boot_kset)
+                iscsi_boot_destroy_kset(phba->boot_kset);
         iscsi_host_remove(phba->shost);
         pci_dev_put(phba->pcidev);
         iscsi_host_free(phba->shost);
-        iscsi_boot_destroy_kset(phba->boot_kset);
 }
 
 static void beiscsi_msix_enable(struct beiscsi_hba *phba)
diff --git a/drivers/scsi/be2iscsi/be_main.h b/drivers/scsi/be2iscsi/be_main.h
index 90eb74f6bcab..081c171a1ed6 100644
--- a/drivers/scsi/be2iscsi/be_main.h
+++ b/drivers/scsi/be2iscsi/be_main.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -7,15 +7,14 @@
  * as published by the Free Software Foundation.  The full GNU General
  * Public License is included in this distribution in the file called COPYING.
  *
- * Written by: Jayamohan Kallickal (jayamohank@serverengines.com)
+ * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
  *
  * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * linux-drivers@emulex.com
  *
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #ifndef _BEISCSI_MAIN_
@@ -35,7 +34,7 @@
 
 #include "be.h"
 #define DRV_NAME                "be2iscsi"
-#define BUILD_STR               "2.0.549.0"
+#define BUILD_STR               "2.103.298.0"
 #define BE_NAME                 "ServerEngines BladeEngine2" \
                                 "Linux iSCSI Driver version" BUILD_STR
 #define DRV_DESC                BE_NAME " " "Driver"
diff --git a/drivers/scsi/be2iscsi/be_mgmt.c b/drivers/scsi/be2iscsi/be_mgmt.c
index 877324fc594c..44762cfa3e12 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.c
+++ b/drivers/scsi/be2iscsi/be_mgmt.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -7,15 +7,14 @@
  * as published by the Free Software Foundation.  The full GNU General
  * Public License is included in this distribution in the file called COPYING.
  *
- * Written by: Jayamohan Kallickal (jayamohank@serverengines.com)
+ * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
  *
  * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * linux-drivers@emulex.com
  *
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #include "be_mgmt.h"
@@ -203,8 +202,8 @@ int mgmt_epfw_cleanup(struct beiscsi_hba *phba, unsigned short chute)
                            OPCODE_COMMON_ISCSI_CLEANUP, sizeof(*req));
 
         req->chute = chute;
-        req->hdr_ring_id = 0;
-        req->data_ring_id = 0;
+        req->hdr_ring_id = cpu_to_le16(HWI_GET_DEF_HDRQ_ID(phba));
+        req->data_ring_id = cpu_to_le16(HWI_GET_DEF_BUFQ_ID(phba));
 
         status =  be_mcc_notify_wait(phba);
         if (status)
diff --git a/drivers/scsi/be2iscsi/be_mgmt.h b/drivers/scsi/be2iscsi/be_mgmt.h
index b9acedf78653..08428824ace2 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.h
+++ b/drivers/scsi/be2iscsi/be_mgmt.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2010 ServerEngines
+ * Copyright (C) 2005 - 2011 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -7,15 +7,14 @@
  * as published by the Free Software Foundation.  The full GNU General
  * Public License is included in this distribution in the file called COPYING.
  *
- * Written by: Jayamohan Kallickal (jayamohank@serverengines.com)
+ * Written by: Jayamohan Kallickal (jayamohan.kallickal@emulex.com)
  *
  * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
+ * linux-drivers@emulex.com
  *
+ * Emulex
+ * 3333 Susan Street
+ * Costa Mesa, CA 92626
  */
 
 #ifndef _BEISCSI_MGMT_
diff --git a/drivers/scsi/bfa/bfad.c b/drivers/scsi/bfa/bfad.c
index 0fd510a01561..59b5e9b61d71 100644
--- a/drivers/scsi/bfa/bfad.c
+++ b/drivers/scsi/bfa/bfad.c
@@ -57,9 +57,19 @@ int		pcie_max_read_reqsz;
 int             bfa_debugfs_enable = 1;
 int             msix_disable_cb = 0, msix_disable_ct = 0;
 
+/* Firmware releated */
 u32     bfi_image_ct_fc_size, bfi_image_ct_cna_size, bfi_image_cb_fc_size;
 u32     *bfi_image_ct_fc, *bfi_image_ct_cna, *bfi_image_cb_fc;
 
+#define BFAD_FW_FILE_CT_FC      "ctfw_fc.bin"
+#define BFAD_FW_FILE_CT_CNA     "ctfw_cna.bin"
+#define BFAD_FW_FILE_CB_FC      "cbfw_fc.bin"
+
+static u32 *bfad_load_fwimg(struct pci_dev *pdev);
+static void bfad_free_fwimg(void);
+static void bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
+                u32 *bfi_image_size, char *fw_name);
+
 static const char *msix_name_ct[] = {
         "cpe0", "cpe1", "cpe2", "cpe3",
         "rme0", "rme1", "rme2", "rme3",
@@ -222,6 +232,9 @@ bfad_sm_created(struct bfad_s *bfad, enum bfad_sm_event event)
                 if ((bfad->bfad_flags & BFAD_HAL_INIT_DONE)) {
                         bfa_sm_send_event(bfad, BFAD_E_INIT_SUCCESS);
                 } else {
+                        printk(KERN_WARNING
+                                "bfa %s: bfa init failed\n",
+                                bfad->pci_name);
                         bfad->bfad_flags |= BFAD_HAL_INIT_FAIL;
                         bfa_sm_send_event(bfad, BFAD_E_INIT_FAILED);
                 }
@@ -991,10 +1004,6 @@ bfad_cfg_pport(struct bfad_s *bfad, enum bfa_lport_role role)
                 bfad->pport.roles |= BFA_LPORT_ROLE_FCP_IM;
         }
 
-        /* Setup the debugfs node for this scsi_host */
-        if (bfa_debugfs_enable)
-                bfad_debugfs_init(&bfad->pport);
-
         bfad->bfad_flags |= BFAD_CFG_PPORT_DONE;
 
 out:
@@ -1004,10 +1013,6 @@ out:
 void
 bfad_uncfg_pport(struct bfad_s *bfad)
 {
-        /* Remove the debugfs node for this scsi_host */
-        kfree(bfad->regdata);
-        bfad_debugfs_exit(&bfad->pport);
-
         if ((supported_fc4s & BFA_LPORT_ROLE_FCP_IM) &&
             (bfad->pport.roles & BFA_LPORT_ROLE_FCP_IM)) {
                 bfad_im_scsi_host_free(bfad, bfad->pport.im_port);
@@ -1389,6 +1394,10 @@ bfad_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pid)
         bfad->pport.bfad = bfad;
         INIT_LIST_HEAD(&bfad->pbc_vport_list);
 
+        /* Setup the debugfs node for this bfad */
+        if (bfa_debugfs_enable)
+                bfad_debugfs_init(&bfad->pport);
+
         retval = bfad_drv_init(bfad);
         if (retval != BFA_STATUS_OK)
                 goto out_drv_init_failure;
@@ -1404,6 +1413,9 @@ out_bfad_sm_failure:
         bfa_detach(&bfad->bfa);
         bfad_hal_mem_release(bfad);
 out_drv_init_failure:
+        /* Remove the debugfs node for this bfad */
+        kfree(bfad->regdata);
+        bfad_debugfs_exit(&bfad->pport);
         mutex_lock(&bfad_mutex);
         bfad_inst--;
         list_del(&bfad->list_entry);
@@ -1445,6 +1457,10 @@ bfad_pci_remove(struct pci_dev *pdev)
         spin_unlock_irqrestore(&bfad->bfad_lock, flags);
         bfad_hal_mem_release(bfad);
 
+        /* Remove the debugfs node for this bfad */
+        kfree(bfad->regdata);
+        bfad_debugfs_exit(&bfad->pport);
+
         /* Cleaning the BFAD instance */
         mutex_lock(&bfad_mutex);
         bfad_inst--;
@@ -1550,7 +1566,7 @@ bfad_exit(void)
 }
 
 /* Firmware handling */
-u32 *
+static void
 bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
                 u32 *bfi_image_size, char *fw_name)
 {
@@ -1558,27 +1574,25 @@ bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
 
         if (request_firmware(&fw, fw_name, &pdev->dev)) {
                 printk(KERN_ALERT "Can't locate firmware %s\n", fw_name);
-                goto error;
+                *bfi_image = NULL;
+                goto out;
         }
 
         *bfi_image = vmalloc(fw->size);
         if (NULL == *bfi_image) {
                 printk(KERN_ALERT "Fail to allocate buffer for fw image "
                         "size=%x!\n", (u32) fw->size);
-                goto error;
+                goto out;
         }
 
         memcpy(*bfi_image, fw->data, fw->size);
         *bfi_image_size = fw->size/sizeof(u32);
-
-        return *bfi_image;
-
-error:
-        return NULL;
+out:
+        release_firmware(fw);
 }
 
-u32 *
-bfad_get_firmware_buf(struct pci_dev *pdev)
+static u32 *
+bfad_load_fwimg(struct pci_dev *pdev)
 {
         if (pdev->device == BFA_PCI_DEVICE_ID_CT_FC) {
                 if (bfi_image_ct_fc_size == 0)
@@ -1598,6 +1612,17 @@ bfad_get_firmware_buf(struct pci_dev *pdev)
         }
 }
 
+static void
+bfad_free_fwimg(void)
+{
+        if (bfi_image_ct_fc_size && bfi_image_ct_fc)
+                vfree(bfi_image_ct_fc);
+        if (bfi_image_ct_cna_size && bfi_image_ct_cna)
+                vfree(bfi_image_ct_cna);
+        if (bfi_image_cb_fc_size && bfi_image_cb_fc)
+                vfree(bfi_image_cb_fc);
+}
+
 module_init(bfad_init);
 module_exit(bfad_exit);
 MODULE_LICENSE("GPL");
diff --git a/drivers/scsi/bfa/bfad_debugfs.c b/drivers/scsi/bfa/bfad_debugfs.c
index c66e32eced7b..48be0c54f2de 100644
--- a/drivers/scsi/bfa/bfad_debugfs.c
+++ b/drivers/scsi/bfa/bfad_debugfs.c
@@ -28,10 +28,10 @@
  * mount -t debugfs none /sys/kernel/debug
  *
  * BFA Hierarchy:
- *      - bfa/host#
- * where the host number corresponds to the one under /sys/class/scsi_host/host#
+ *      - bfa/pci_dev:<pci_name>
+ * where the pci_name corresponds to the one under /sys/bus/pci/drivers/bfa
  *
- * Debugging service available per host:
+ * Debugging service available per pci_dev:
  * fwtrc:  To collect current firmware trace.
  * drvtrc: To collect current driver trace
  * fwsave: To collect last saved fw trace as a result of firmware crash.
@@ -489,11 +489,9 @@ static atomic_t bfa_debugfs_port_count;
 inline void
 bfad_debugfs_init(struct bfad_port_s *port)
 {
-        struct bfad_im_port_s *im_port = port->im_port;
-        struct bfad_s *bfad = im_port->bfad;
-        struct Scsi_Host *shost = im_port->shost;
+        struct bfad_s *bfad = port->bfad;
         const struct bfad_debugfs_entry *file;
-        char name[16];
+        char name[64];
         int i;
 
         if (!bfa_debugfs_enable)
@@ -510,17 +508,15 @@ bfad_debugfs_init(struct bfad_port_s *port)
                 }
         }
 
-        /*
-         * Setup the host# directory for the port,
-         * corresponds to the scsi_host num of this port.
-         */
-        snprintf(name, sizeof(name), "host%d", shost->host_no);
+        /* Setup the pci_dev debugfs directory for the port */
+        snprintf(name, sizeof(name), "pci_dev:%s", bfad->pci_name);
         if (!port->port_debugfs_root) {
                 port->port_debugfs_root =
                         debugfs_create_dir(name, bfa_debugfs_root);
                 if (!port->port_debugfs_root) {
                         printk(KERN_WARNING
-                                "BFA host root dir creation failed\n");
+                                "bfa %s: debugfs root creation failed\n",
+                                bfad->pci_name);
                         goto err;
                 }
 
@@ -536,8 +532,8 @@ bfad_debugfs_init(struct bfad_port_s *port)
                                                         file->fops);
                         if (!bfad->bfad_dentry_files[i]) {
                                 printk(KERN_WARNING
-                                        "BFA host%d: create %s entry failed\n",
-                                        shost->host_no, file->name);
+                                        "bfa %s: debugfs %s creation failed\n",
+                                        bfad->pci_name, file->name);
                                 goto err;
                         }
                 }
@@ -550,8 +546,7 @@ err:
 inline void
 bfad_debugfs_exit(struct bfad_port_s *port)
 {
-        struct bfad_im_port_s *im_port = port->im_port;
-        struct bfad_s *bfad = im_port->bfad;
+        struct bfad_s *bfad = port->bfad;
         int i;
 
         for (i = 0; i < ARRAY_SIZE(bfad_debugfs_files); i++) {
@@ -562,9 +557,7 @@ bfad_debugfs_exit(struct bfad_port_s *port)
         }
 
         /*
-         * Remove the host# directory for the port,
-         * corresponds to the scsi_host num of this port.
-        */
+         * Remove the pci_dev debugfs directory for the port */
         if (port->port_debugfs_root) {
                 debugfs_remove(port->port_debugfs_root);
                 port->port_debugfs_root = NULL;
diff --git a/drivers/scsi/bfa/bfad_im.h b/drivers/scsi/bfa/bfad_im.h
index bfee63b16fa9..c296c8968511 100644
--- a/drivers/scsi/bfa/bfad_im.h
+++ b/drivers/scsi/bfa/bfad_im.h
@@ -141,29 +141,4 @@ extern struct device_attribute *bfad_im_vport_attrs[];
 
 irqreturn_t bfad_intx(int irq, void *dev_id);
 
-/* Firmware releated */
-#define BFAD_FW_FILE_CT_FC      "ctfw_fc.bin"
-#define BFAD_FW_FILE_CT_CNA     "ctfw_cna.bin"
-#define BFAD_FW_FILE_CB_FC      "cbfw_fc.bin"
-
-u32 *bfad_get_firmware_buf(struct pci_dev *pdev);
-u32 *bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image,
-                u32 *bfi_image_size, char *fw_name);
-
-static inline u32 *
-bfad_load_fwimg(struct pci_dev *pdev)
-{
-        return bfad_get_firmware_buf(pdev);
-}
-
-static inline void
-bfad_free_fwimg(void)
-{
-        if (bfi_image_ct_fc_size && bfi_image_ct_fc)
-                vfree(bfi_image_ct_fc);
-        if (bfi_image_ct_cna_size && bfi_image_ct_cna)
-                vfree(bfi_image_ct_cna);
-        if (bfi_image_cb_fc_size && bfi_image_cb_fc)
-                vfree(bfi_image_cb_fc);
-}
 #endif
diff --git a/drivers/scsi/bnx2fc/bnx2fc.h b/drivers/scsi/bnx2fc/bnx2fc.h
index b6d350ac4288..0a404bfb44fe 100644
--- a/drivers/scsi/bnx2fc/bnx2fc.h
+++ b/drivers/scsi/bnx2fc/bnx2fc.h
@@ -130,7 +130,7 @@
 #define BNX2FC_TM_TIMEOUT               60      /* secs */
 #define BNX2FC_IO_TIMEOUT               20000UL /* msecs */
 
-#define BNX2FC_WAIT_CNT                 120
+#define BNX2FC_WAIT_CNT                 1200
 #define BNX2FC_FW_TIMEOUT               (3 * HZ)
 #define PORT_MAX                        2
 
diff --git a/drivers/scsi/bnx2fc/bnx2fc_fcoe.c b/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
index e2e647509a73..662365676689 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
@@ -1130,7 +1130,7 @@ static void bnx2fc_interface_release(struct kref *kref)
         struct net_device *phys_dev;
 
         hba = container_of(kref, struct bnx2fc_hba, kref);
-        BNX2FC_HBA_DBG(hba->ctlr.lp, "Interface is being released\n");
+        BNX2FC_MISC_DBG("Interface is being released\n");
 
         netdev = hba->netdev;
         phys_dev = hba->phys_dev;
@@ -1254,20 +1254,17 @@ setup_err:
 static struct fc_lport *bnx2fc_if_create(struct bnx2fc_hba *hba,
                                   struct device *parent, int npiv)
 {
-        struct fc_lport         *lport = NULL;
+        struct fc_lport         *lport, *n_port;
         struct fcoe_port        *port;
         struct Scsi_Host        *shost;
         struct fc_vport         *vport = dev_to_vport(parent);
         int                     rc = 0;
 
         /* Allocate Scsi_Host structure */
-        if (!npiv) {
-                lport = libfc_host_alloc(&bnx2fc_shost_template,
-                                          sizeof(struct fcoe_port));
-        } else {
-                lport = libfc_vport_create(vport,
-                                           sizeof(struct fcoe_port));
-        }
+        if (!npiv)
+                lport = libfc_host_alloc(&bnx2fc_shost_template, sizeof(*port));
+        else
+                lport = libfc_vport_create(vport, sizeof(*port));
 
         if (!lport) {
                 printk(KERN_ERR PFX "could not allocate scsi host structure\n");
@@ -1285,7 +1282,6 @@ static struct fc_lport *bnx2fc_if_create(struct bnx2fc_hba *hba,
                 goto lp_config_err;
 
         if (npiv) {
-                vport = dev_to_vport(parent);
                 printk(KERN_ERR PFX "Setting vport names, 0x%llX 0x%llX\n",
                         vport->node_name, vport->port_name);
                 fc_set_wwnn(lport, vport->node_name);
@@ -1314,12 +1310,17 @@ static struct fc_lport *bnx2fc_if_create(struct bnx2fc_hba *hba,
         fc_host_port_type(lport->host) = FC_PORTTYPE_UNKNOWN;
 
         /* Allocate exchange manager */
-        if (!npiv) {
+        if (!npiv)
                 rc = bnx2fc_em_config(lport);
-                if (rc) {
-                        printk(KERN_ERR PFX "Error on bnx2fc_em_config\n");
-                        goto shost_err;
-                }
+        else {
+                shost = vport_to_shost(vport);
+                n_port = shost_priv(shost);
+                rc = fc_exch_mgr_list_clone(n_port, lport);
+        }
+
+        if (rc) {
+                printk(KERN_ERR PFX "Error on bnx2fc_em_config\n");
+                goto shost_err;
         }
 
         bnx2fc_interface_get(hba);
@@ -1352,8 +1353,6 @@ static void bnx2fc_if_destroy(struct fc_lport *lport)
         /* Free existing transmit skbs */
         fcoe_clean_pending_queue(lport);
 
-        bnx2fc_interface_put(hba);
-
         /* Free queued packets for the receive thread */
         bnx2fc_clean_rx_queue(lport);
 
@@ -1372,6 +1371,8 @@ static void bnx2fc_if_destroy(struct fc_lport *lport)
 
         /* Release Scsi_Host */
         scsi_host_put(lport->host);
+
+        bnx2fc_interface_put(hba);
 }
 
 /**
diff --git a/drivers/scsi/bnx2fc/bnx2fc_hwi.c b/drivers/scsi/bnx2fc/bnx2fc_hwi.c
index 1b680e288c56..f756d5f85c7a 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_hwi.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_hwi.c
@@ -522,6 +522,7 @@ void bnx2fc_process_l2_frame_compl(struct bnx2fc_rport *tgt,
         fp = fc_frame_alloc(lport, payload_len);
         if (!fp) {
                 printk(KERN_ERR PFX "fc_frame_alloc failure\n");
+                kfree(unsol_els);
                 return;
         }
 
@@ -547,6 +548,7 @@ void bnx2fc_process_l2_frame_compl(struct bnx2fc_rport *tgt,
                                  */
                                 printk(KERN_ERR PFX "dropping ELS 0x%x\n", op);
                                 kfree_skb(skb);
+                                kfree(unsol_els);
                                 return;
                         }
                 }
@@ -563,6 +565,7 @@ void bnx2fc_process_l2_frame_compl(struct bnx2fc_rport *tgt,
         } else {
                 BNX2FC_HBA_DBG(lport, "fh_r_ctl = 0x%x\n", fh->fh_r_ctl);
                 kfree_skb(skb);
+                kfree(unsol_els);
         }
 }
 
diff --git a/drivers/scsi/bnx2fc/bnx2fc_io.c b/drivers/scsi/bnx2fc/bnx2fc_io.c
index 1decefbf32e3..b5b5c346d779 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_io.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_io.c
@@ -1663,6 +1663,12 @@ int bnx2fc_queuecommand(struct Scsi_Host *host,
         tgt = (struct bnx2fc_rport *)&rp[1];
 
         if (!test_bit(BNX2FC_FLAG_SESSION_READY, &tgt->flags)) {
+                if (test_bit(BNX2FC_FLAG_UPLD_REQ_COMPL, &tgt->flags))  {
+                        sc_cmd->result = DID_NO_CONNECT << 16;
+                        sc_cmd->scsi_done(sc_cmd);
+                        return 0;
+
+                }
                 /*
                  * Session is not offloaded yet. Let SCSI-ml retry
                  * the command.
diff --git a/drivers/scsi/constants.c b/drivers/scsi/constants.c
index d0c82340f0e2..60d2ef291646 100644
--- a/drivers/scsi/constants.c
+++ b/drivers/scsi/constants.c
@@ -772,6 +772,7 @@ static const struct error_info additional[] =
         {0x3802, "Esn - power management class event"},
         {0x3804, "Esn - media class event"},
         {0x3806, "Esn - device busy class event"},
+        {0x3807, "Thin Provisioning soft threshold reached"},
 
         {0x3900, "Saving parameters not supported"},
 
diff --git a/drivers/scsi/dc395x.c b/drivers/scsi/dc395x.c
index b10b3841535c..f5b718d3c31b 100644
--- a/drivers/scsi/dc395x.c
+++ b/drivers/scsi/dc395x.c
@@ -778,8 +778,8 @@ static void srb_free_insert(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb)
 static void srb_waiting_insert(struct DeviceCtlBlk *dcb,
                 struct ScsiReqBlk *srb)
 {
-        dprintkdbg(DBG_0, "srb_waiting_insert: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+        dprintkdbg(DBG_0, "srb_waiting_insert: (0x%p) <%02i-%i> srb=%p\n",
+                srb->cmd, dcb->target_id, dcb->target_lun, srb);
         list_add(&srb->list, &dcb->srb_waiting_list);
 }
 
@@ -787,16 +787,16 @@ static void srb_waiting_insert(struct DeviceCtlBlk *dcb,
 static void srb_waiting_append(struct DeviceCtlBlk *dcb,
                 struct ScsiReqBlk *srb)
 {
-        dprintkdbg(DBG_0, "srb_waiting_append: (pid#%li) <%02i-%i> srb=%p\n",
-                 srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+        dprintkdbg(DBG_0, "srb_waiting_append: (0x%p) <%02i-%i> srb=%p\n",
+                 srb->cmd, dcb->target_id, dcb->target_lun, srb);
         list_add_tail(&srb->list, &dcb->srb_waiting_list);
 }
 
 
 static void srb_going_append(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb)
 {
-        dprintkdbg(DBG_0, "srb_going_append: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+        dprintkdbg(DBG_0, "srb_going_append: (0x%p) <%02i-%i> srb=%p\n",
+                srb->cmd, dcb->target_id, dcb->target_lun, srb);
         list_add_tail(&srb->list, &dcb->srb_going_list);
 }
 
@@ -805,8 +805,8 @@ static void srb_going_remove(struct DeviceCtlBlk *dcb, struct ScsiReqBlk *srb)
 {
         struct ScsiReqBlk *i;
         struct ScsiReqBlk *tmp;
-        dprintkdbg(DBG_0, "srb_going_remove: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+        dprintkdbg(DBG_0, "srb_going_remove: (0x%p) <%02i-%i> srb=%p\n",
+                srb->cmd, dcb->target_id, dcb->target_lun, srb);
 
         list_for_each_entry_safe(i, tmp, &dcb->srb_going_list, list)
                 if (i == srb) {
@@ -821,8 +821,8 @@ static void srb_waiting_remove(struct DeviceCtlBlk *dcb,
 {
         struct ScsiReqBlk *i;
         struct ScsiReqBlk *tmp;
-        dprintkdbg(DBG_0, "srb_waiting_remove: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+        dprintkdbg(DBG_0, "srb_waiting_remove: (0x%p) <%02i-%i> srb=%p\n",
+                srb->cmd, dcb->target_id, dcb->target_lun, srb);
 
         list_for_each_entry_safe(i, tmp, &dcb->srb_waiting_list, list)
                 if (i == srb) {
@@ -836,8 +836,8 @@ static void srb_going_to_waiting_move(struct DeviceCtlBlk *dcb,
                 struct ScsiReqBlk *srb)
 {
         dprintkdbg(DBG_0,
-                "srb_going_to_waiting_move: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+                "srb_going_to_waiting_move: (0x%p) <%02i-%i> srb=%p\n",
+                srb->cmd, dcb->target_id, dcb->target_lun, srb);
         list_move(&srb->list, &dcb->srb_waiting_list);
 }
 
@@ -846,8 +846,8 @@ static void srb_waiting_to_going_move(struct DeviceCtlBlk *dcb,
                 struct ScsiReqBlk *srb)
 {
         dprintkdbg(DBG_0,
-                "srb_waiting_to_going_move: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+                "srb_waiting_to_going_move: (0x%p) <%02i-%i> srb=%p\n",
+                srb->cmd, dcb->target_id, dcb->target_lun, srb);
         list_move(&srb->list, &dcb->srb_going_list);
 }
 
@@ -982,8 +982,8 @@ static void build_srb(struct scsi_cmnd *cmd, struct DeviceCtlBlk *dcb,
 {
         int nseg;
         enum dma_data_direction dir = cmd->sc_data_direction;
-        dprintkdbg(DBG_0, "build_srb: (pid#%li) <%02i-%i>\n",
-                cmd->serial_number, dcb->target_id, dcb->target_lun);
+        dprintkdbg(DBG_0, "build_srb: (0x%p) <%02i-%i>\n",
+                cmd, dcb->target_id, dcb->target_lun);
 
         srb->dcb = dcb;
         srb->cmd = cmd;
@@ -1086,8 +1086,8 @@ static int dc395x_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct s
         struct ScsiReqBlk *srb;
         struct AdapterCtlBlk *acb =
             (struct AdapterCtlBlk *)cmd->device->host->hostdata;
-        dprintkdbg(DBG_0, "queue_command: (pid#%li) <%02i-%i> cmnd=0x%02x\n",
-                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+        dprintkdbg(DBG_0, "queue_command: (0x%p) <%02i-%i> cmnd=0x%02x\n",
+                cmd, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
 
         /* Assume BAD_TARGET; will be cleared later */
         cmd->result = DID_BAD_TARGET << 16;
@@ -1140,7 +1140,7 @@ static int dc395x_queue_command_lck(struct scsi_cmnd *cmd, void (*done)(struct s
                 /* process immediately */
                 send_srb(acb, srb);
         }
-        dprintkdbg(DBG_1, "queue_command: (pid#%li) done\n", cmd->serial_number);
+        dprintkdbg(DBG_1, "queue_command: (0x%p) done\n", cmd);
         return 0;
 
 complete:
@@ -1203,9 +1203,9 @@ static void dump_register_info(struct AdapterCtlBlk *acb,
                         dprintkl(KERN_INFO, "dump: srb=%p cmd=%p OOOPS!\n",
                                 srb, srb->cmd);
                 else
-                        dprintkl(KERN_INFO, "dump: srb=%p cmd=%p (pid#%li) "
+                        dprintkl(KERN_INFO, "dump: srb=%p cmd=%p "
                                  "cmnd=0x%02x <%02i-%i>\n",
-                                srb, srb->cmd, srb->cmd->serial_number,
+                                srb, srb->cmd,
                                 srb->cmd->cmnd[0], srb->cmd->device->id,
                                 srb->cmd->device->lun);
                 printk("  sglist=%p cnt=%i idx=%i len=%zu\n",
@@ -1301,8 +1301,8 @@ static int __dc395x_eh_bus_reset(struct scsi_cmnd *cmd)
         struct AdapterCtlBlk *acb =
                 (struct AdapterCtlBlk *)cmd->device->host->hostdata;
         dprintkl(KERN_INFO,
-                "eh_bus_reset: (pid#%li) target=<%02i-%i> cmd=%p\n",
-                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd);
+                "eh_bus_reset: (0%p) target=<%02i-%i> cmd=%p\n",
+                cmd, cmd->device->id, cmd->device->lun, cmd);
 
         if (timer_pending(&acb->waiting_timer))
                 del_timer(&acb->waiting_timer);
@@ -1368,8 +1368,8 @@ static int dc395x_eh_abort(struct scsi_cmnd *cmd)
             (struct AdapterCtlBlk *)cmd->device->host->hostdata;
         struct DeviceCtlBlk *dcb;
         struct ScsiReqBlk *srb;
-        dprintkl(KERN_INFO, "eh_abort: (pid#%li) target=<%02i-%i> cmd=%p\n",
-                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd);
+        dprintkl(KERN_INFO, "eh_abort: (0x%p) target=<%02i-%i> cmd=%p\n",
+                cmd, cmd->device->id, cmd->device->lun, cmd);
 
         dcb = find_dcb(acb, cmd->device->id, cmd->device->lun);
         if (!dcb) {
@@ -1495,8 +1495,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
         u16 s_stat2, return_code;
         u8 s_stat, scsicommand, i, identify_message;
         u8 *ptr;
-        dprintkdbg(DBG_0, "start_scsi: (pid#%li) <%02i-%i> srb=%p\n",
-                srb->cmd->serial_number, dcb->target_id, dcb->target_lun, srb);
+        dprintkdbg(DBG_0, "start_scsi: (0x%p) <%02i-%i> srb=%p\n",
+                dcb->target_id, dcb->target_lun, srb);
 
         srb->tag_number = TAG_NONE;     /* acb->tag_max_num: had error read in eeprom */
 
@@ -1505,8 +1505,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
         s_stat2 = DC395x_read16(acb, TRM_S1040_SCSI_STATUS);
 #if 1
         if (s_stat & 0x20 /* s_stat2 & 0x02000 */ ) {
-                dprintkdbg(DBG_KG, "start_scsi: (pid#%li) BUSY %02x %04x\n",
-                        srb->cmd->serial_number, s_stat, s_stat2);
+                dprintkdbg(DBG_KG, "start_scsi: (0x%p) BUSY %02x %04x\n",
+                        s_stat, s_stat2);
                 /*
                  * Try anyway?
                  *
@@ -1522,16 +1522,15 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
         }
 #endif
         if (acb->active_dcb) {
-                dprintkl(KERN_DEBUG, "start_scsi: (pid#%li) Attempt to start a"
-                        "command while another command (pid#%li) is active.",
-                        srb->cmd->serial_number,
+                dprintkl(KERN_DEBUG, "start_scsi: (0x%p) Attempt to start a"
+                        "command while another command (0x%p) is active.",
+                        srb->cmd,
                         acb->active_dcb->active_srb ?
-                            acb->active_dcb->active_srb->cmd->serial_number : 0);
+                            acb->active_dcb->active_srb->cmd : 0);
                 return 1;
         }
         if (DC395x_read16(acb, TRM_S1040_SCSI_STATUS) & SCSIINTERRUPT) {
-                dprintkdbg(DBG_KG, "start_scsi: (pid#%li) Failed (busy)\n",
-                        srb->cmd->serial_number);
+                dprintkdbg(DBG_KG, "start_scsi: (0x%p) Failed (busy)\n", srb->cmd);
                 return 1;
         }
         /* Allow starting of SCSI commands half a second before we allow the mid-level
@@ -1603,9 +1602,9 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
                         tag_number++;
                 }
                 if (tag_number >= dcb->max_command) {
-                        dprintkl(KERN_WARNING, "start_scsi: (pid#%li) "
+                        dprintkl(KERN_WARNING, "start_scsi: (0x%p) "
                                 "Out of tags target=<%02i-%i>)\n",
-                                srb->cmd->serial_number, srb->cmd->device->id,
+                                srb->cmd, srb->cmd->device->id,
                                 srb->cmd->device->lun);
                         srb->state = SRB_READY;
                         DC395x_write16(acb, TRM_S1040_SCSI_CONTROL,
@@ -1623,8 +1622,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
 #endif
 /*polling:*/
         /* Send CDB ..command block ......... */
-        dprintkdbg(DBG_KG, "start_scsi: (pid#%li) <%02i-%i> cmnd=0x%02x tag=%i\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun,
+        dprintkdbg(DBG_KG, "start_scsi: (0x%p) <%02i-%i> cmnd=0x%02x tag=%i\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun,
                 srb->cmd->cmnd[0], srb->tag_number);
         if (srb->flag & AUTO_REQSENSE) {
                 DC395x_write8(acb, TRM_S1040_SCSI_FIFO, REQUEST_SENSE);
@@ -1647,8 +1646,8 @@ static u8 start_scsi(struct AdapterCtlBlk* acb, struct DeviceCtlBlk* dcb,
                  * we caught an interrupt (must be reset or reselection ... )
                  * : Let's process it first!
                  */
-                dprintkdbg(DBG_0, "start_scsi: (pid#%li) <%02i-%i> Failed - busy\n",
-                        srb->cmd->serial_number, dcb->target_id, dcb->target_lun);
+                dprintkdbg(DBG_0, "start_scsi: (0x%p) <%02i-%i> Failed - busy\n",
+                        srb->cmd, dcb->target_id, dcb->target_lun);
                 srb->state = SRB_READY;
                 free_tag(dcb, srb);
                 srb->msg_count = 0;
@@ -1843,7 +1842,7 @@ static irqreturn_t dc395x_interrupt(int irq, void *dev_id)
 static void msgout_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "msgout_phase0: (pid#%li)\n", srb->cmd->serial_number);
+        dprintkdbg(DBG_0, "msgout_phase0: (0x%p)\n", srb->cmd);
         if (srb->state & (SRB_UNEXPECT_RESEL + SRB_ABORT_SENT))
                 *pscsi_status = PH_BUS_FREE;    /*.. initial phase */
 
@@ -1857,18 +1856,18 @@ static void msgout_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 {
         u16 i;
         u8 *ptr;
-        dprintkdbg(DBG_0, "msgout_phase1: (pid#%li)\n", srb->cmd->serial_number);
+        dprintkdbg(DBG_0, "msgout_phase1: (0x%p)\n", srb->cmd);
 
         clear_fifo(acb, "msgout_phase1");
         if (!(srb->state & SRB_MSGOUT)) {
                 srb->state |= SRB_MSGOUT;
                 dprintkl(KERN_DEBUG,
-                        "msgout_phase1: (pid#%li) Phase unexpected\n",
-                        srb->cmd->serial_number);       /* So what ? */
+                        "msgout_phase1: (0x%p) Phase unexpected\n",
+                        srb->cmd);      /* So what ? */
         }
         if (!srb->msg_count) {
-                dprintkdbg(DBG_0, "msgout_phase1: (pid#%li) NOP msg\n",
-                        srb->cmd->serial_number);
+                dprintkdbg(DBG_0, "msgout_phase1: (0x%p) NOP msg\n",
+                        srb->cmd);
                 DC395x_write8(acb, TRM_S1040_SCSI_FIFO, MSG_NOP);
                 DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH);      /* it's important for atn stop */
                 DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_FIFO_OUT);
@@ -1888,7 +1887,7 @@ static void msgout_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 static void command_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "command_phase0: (pid#%li)\n", srb->cmd->serial_number);
+        dprintkdbg(DBG_0, "command_phase0: (0x%p)\n", srb->cmd);
         DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH);
 }
 
@@ -1899,7 +1898,7 @@ static void command_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
         struct DeviceCtlBlk *dcb;
         u8 *ptr;
         u16 i;
-        dprintkdbg(DBG_0, "command_phase1: (pid#%li)\n", srb->cmd->serial_number);
+        dprintkdbg(DBG_0, "command_phase1: (0x%p)\n", srb->cmd);
 
         clear_fifo(acb, "command_phase1");
         DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_CLRATN);
@@ -2041,8 +2040,8 @@ static void data_out_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
         struct DeviceCtlBlk *dcb = srb->dcb;
         u16 scsi_status = *pscsi_status;
         u32 d_left_counter = 0;
-        dprintkdbg(DBG_0, "data_out_phase0: (pid#%li) <%02i-%i>\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
+        dprintkdbg(DBG_0, "data_out_phase0: (0x%p) <%02i-%i>\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
 
         /*
          * KG: We need to drain the buffers before we draw any conclusions!
@@ -2171,8 +2170,8 @@ static void data_out_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 static void data_out_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "data_out_phase1: (pid#%li) <%02i-%i>\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
+        dprintkdbg(DBG_0, "data_out_phase1: (0x%p) <%02i-%i>\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
         clear_fifo(acb, "data_out_phase1");
         /* do prepare before transfer when data out phase */
         data_io_transfer(acb, srb, XFERDATAOUT);
@@ -2183,8 +2182,8 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 {
         u16 scsi_status = *pscsi_status;
 
-        dprintkdbg(DBG_0, "data_in_phase0: (pid#%li) <%02i-%i>\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
+        dprintkdbg(DBG_0, "data_in_phase0: (0x%p) <%02i-%i>\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
 
         /*
          * KG: DataIn is much more tricky than DataOut. When the device is finished
@@ -2204,8 +2203,8 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 unsigned int sc, fc;
 
                 if (scsi_status & PARITYERROR) {
-                        dprintkl(KERN_INFO, "data_in_phase0: (pid#%li) "
-                                "Parity Error\n", srb->cmd->serial_number);
+                        dprintkl(KERN_INFO, "data_in_phase0: (0x%p) "
+                                "Parity Error\n", srb->cmd);
                         srb->status |= PARITY_ERROR;
                 }
                 /*
@@ -2394,8 +2393,8 @@ static void data_in_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 static void data_in_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "data_in_phase1: (pid#%li) <%02i-%i>\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
+        dprintkdbg(DBG_0, "data_in_phase1: (0x%p) <%02i-%i>\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
         data_io_transfer(acb, srb, XFERDATAIN);
 }
 
@@ -2406,8 +2405,8 @@ static void data_io_transfer(struct AdapterCtlBlk *acb,
         struct DeviceCtlBlk *dcb = srb->dcb;
         u8 bval;
         dprintkdbg(DBG_0,
-                "data_io_transfer: (pid#%li) <%02i-%i> %c len=%i, sg=(%i/%i)\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun,
+                "data_io_transfer: (0x%p) <%02i-%i> %c len=%i, sg=(%i/%i)\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun,
                 ((io_dir & DMACMD_DIR) ? 'r' : 'w'),
                 srb->total_xfer_length, srb->sg_index, srb->sg_count);
         if (srb == acb->tmp_srb)
@@ -2579,8 +2578,8 @@ static void data_io_transfer(struct AdapterCtlBlk *acb,
 static void status_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "status_phase0: (pid#%li) <%02i-%i>\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
+        dprintkdbg(DBG_0, "status_phase0: (0x%p) <%02i-%i>\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
         srb->target_status = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
         srb->end_message = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);      /* get message */
         srb->state = SRB_COMPLETED;
@@ -2593,8 +2592,8 @@ static void status_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 static void status_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "status_phase1: (pid#%li) <%02i-%i>\n",
-                srb->cmd->serial_number, srb->cmd->device->id, srb->cmd->device->lun);
+        dprintkdbg(DBG_0, "status_phase1: (0x%p) <%02i-%i>\n",
+                srb->cmd, srb->cmd->device->id, srb->cmd->device->lun);
         srb->state = SRB_STATUS;
         DC395x_write16(acb, TRM_S1040_SCSI_CONTROL, DO_DATALATCH);      /* it's important for atn stop */
         DC395x_write8(acb, TRM_S1040_SCSI_COMMAND, SCMD_COMP);
@@ -2635,8 +2634,8 @@ static struct ScsiReqBlk *msgin_qtag(struct AdapterCtlBlk *acb,
 {
         struct ScsiReqBlk *srb = NULL;
         struct ScsiReqBlk *i;
-        dprintkdbg(DBG_0, "msgin_qtag: (pid#%li) tag=%i srb=%p\n",
-                   srb->cmd->serial_number, tag, srb);
+        dprintkdbg(DBG_0, "msgin_qtag: (0x%p) tag=%i srb=%p\n",
+                   srb->cmd, tag, srb);
 
         if (!(dcb->tag_mask & (1 << tag)))
                 dprintkl(KERN_DEBUG,
@@ -2654,8 +2653,8 @@ static struct ScsiReqBlk *msgin_qtag(struct AdapterCtlBlk *acb,
         if (!srb)
                 goto mingx0;
 
-        dprintkdbg(DBG_0, "msgin_qtag: (pid#%li) <%02i-%i>\n",
-                srb->cmd->serial_number, srb->dcb->target_id, srb->dcb->target_lun);
+        dprintkdbg(DBG_0, "msgin_qtag: (0x%p) <%02i-%i>\n",
+                srb->cmd, srb->dcb->target_id, srb->dcb->target_lun);
         if (dcb->flag & ABORT_DEV_) {
                 /*srb->state = SRB_ABORT_SENT; */
                 enable_msgout_abort(acb, srb);
@@ -2865,7 +2864,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
         struct DeviceCtlBlk *dcb = acb->active_dcb;
-        dprintkdbg(DBG_0, "msgin_phase0: (pid#%li)\n", srb->cmd->serial_number);
+        dprintkdbg(DBG_0, "msgin_phase0: (0x%p)\n", srb->cmd);
 
         srb->msgin_buf[acb->msg_len++] = DC395x_read8(acb, TRM_S1040_SCSI_FIFO);
         if (msgin_completed(srb->msgin_buf, acb->msg_len)) {
@@ -2931,9 +2930,9 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                          * SAVE POINTER may be ignored as we have the struct
                          * ScsiReqBlk* associated with the scsi command.
                          */
-                        dprintkdbg(DBG_0, "msgin_phase0: (pid#%li) "
+                        dprintkdbg(DBG_0, "msgin_phase0: (0x%p) "
                                 "SAVE POINTER rem=%i Ignore\n",
-                                srb->cmd->serial_number, srb->total_xfer_length);
+                                srb->cmd, srb->total_xfer_length);
                         break;
 
                 case RESTORE_POINTERS:
@@ -2941,9 +2940,9 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                         break;
 
                 case ABORT:
-                        dprintkdbg(DBG_0, "msgin_phase0: (pid#%li) "
+                        dprintkdbg(DBG_0, "msgin_phase0: (0x%p) "
                                 "<%02i-%i> ABORT msg\n",
-                                srb->cmd->serial_number, dcb->target_id,
+                                srb->cmd, dcb->target_id,
                                 dcb->target_lun);
                         dcb->flag |= ABORT_DEV_;
                         enable_msgout_abort(acb, srb);
@@ -2975,7 +2974,7 @@ static void msgin_phase0(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
 static void msgin_phase1(struct AdapterCtlBlk *acb, struct ScsiReqBlk *srb,
                 u16 *pscsi_status)
 {
-        dprintkdbg(DBG_0, "msgin_phase1: (pid#%li)\n", srb->cmd->serial_number);
+        dprintkdbg(DBG_0, "msgin_phase1: (0x%p)\n", srb->cmd);
         clear_fifo(acb, "msgin_phase1");
         DC395x_write32(acb, TRM_S1040_SCSI_COUNTER, 1);
         if (!(srb->state & SRB_MSGIN)) {
@@ -3041,7 +3040,7 @@ static void disconnect(struct AdapterCtlBlk *acb)
         }
         srb = dcb->active_srb;
         acb->active_dcb = NULL;
-        dprintkdbg(DBG_0, "disconnect: (pid#%li)\n", srb->cmd->serial_number);
+        dprintkdbg(DBG_0, "disconnect: (0x%p)\n", srb->cmd);
 
         srb->scsi_phase = PH_BUS_FREE;  /* initial phase */
         clear_fifo(acb, "disconnect");
@@ -3071,14 +3070,14 @@ static void disconnect(struct AdapterCtlBlk *acb)
                             && srb->state != SRB_MSGOUT) {
                                 srb->state = SRB_READY;
                                 dprintkl(KERN_DEBUG,
-                                        "disconnect: (pid#%li) Unexpected\n",
-                                        srb->cmd->serial_number);
+                                        "disconnect: (0x%p) Unexpected\n",
+                                        srb->cmd);
                                 srb->target_status = SCSI_STAT_SEL_TIMEOUT;
                                 goto disc1;
                         } else {
                                 /* Normal selection timeout */
-                                dprintkdbg(DBG_KG, "disconnect: (pid#%li) "
-                                        "<%02i-%i> SelTO\n", srb->cmd->serial_number,
+                                dprintkdbg(DBG_KG, "disconnect: (0x%p) "
+                                        "<%02i-%i> SelTO\n", srb->cmd,
                                         dcb->target_id, dcb->target_lun);
                                 if (srb->retry_count++ > DC395x_MAX_RETRIES
                                     || acb->scan_devices) {
@@ -3089,8 +3088,8 @@ static void disconnect(struct AdapterCtlBlk *acb)
                                 free_tag(dcb, srb);
                                 srb_going_to_waiting_move(dcb, srb);
                                 dprintkdbg(DBG_KG,
-                                        "disconnect: (pid#%li) Retry\n",
-                                        srb->cmd->serial_number);
+                                        "disconnect: (0x%p) Retry\n",
+                                        srb->cmd);
                                 waiting_set_timer(acb, HZ / 20);
                         }
                 } else if (srb->state & SRB_DISCONNECT) {
@@ -3142,9 +3141,9 @@ static void reselect(struct AdapterCtlBlk *acb)
                 }
                 /* Why the if ? */
                 if (!acb->scan_devices) {
-                        dprintkdbg(DBG_KG, "reselect: (pid#%li) <%02i-%i> "
+                        dprintkdbg(DBG_KG, "reselect: (0x%p) <%02i-%i> "
                                 "Arb lost but Resel win rsel=%i stat=0x%04x\n",
-                                srb->cmd->serial_number, dcb->target_id,
+                                srb->cmd, dcb->target_id,
                                 dcb->target_lun, rsel_tar_lun_id,
                                 DC395x_read16(acb, TRM_S1040_SCSI_STATUS));
                         arblostflag = 1;
@@ -3318,7 +3317,7 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
         enum dma_data_direction dir = cmd->sc_data_direction;
         int ckc_only = 1;
 
-        dprintkdbg(DBG_1, "srb_done: (pid#%li) <%02i-%i>\n", srb->cmd->serial_number,
+        dprintkdbg(DBG_1, "srb_done: (0x%p) <%02i-%i>\n", srb->cmd,
                 srb->cmd->device->id, srb->cmd->device->lun);
         dprintkdbg(DBG_SG, "srb_done: srb=%p sg=%i(%i/%i) buf=%p\n",
                    srb, scsi_sg_count(cmd), srb->sg_index, srb->sg_count,
@@ -3497,9 +3496,9 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
         cmd->SCp.buffers_residual = 0;
         if (debug_enabled(DBG_KG)) {
                 if (srb->total_xfer_length)
-                        dprintkdbg(DBG_KG, "srb_done: (pid#%li) <%02i-%i> "
+                        dprintkdbg(DBG_KG, "srb_done: (0x%p) <%02i-%i> "
                                 "cmnd=0x%02x Missed %i bytes\n",
-                                cmd->serial_number, cmd->device->id, cmd->device->lun,
+                                cmd, cmd->device->id, cmd->device->lun,
                                 cmd->cmnd[0], srb->total_xfer_length);
         }
 
@@ -3508,8 +3507,8 @@ static void srb_done(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
         if (srb == acb->tmp_srb)
                 dprintkl(KERN_ERR, "srb_done: ERROR! Completed cmd with tmp_srb\n");
         else {
-                dprintkdbg(DBG_0, "srb_done: (pid#%li) done result=0x%08x\n",
-                        cmd->serial_number, cmd->result);
+                dprintkdbg(DBG_0, "srb_done: (0x%p) done result=0x%08x\n",
+                        cmd, cmd->result);
                 srb_free_insert(acb, srb);
         }
         pci_unmap_srb(acb, srb);
@@ -3538,7 +3537,7 @@ static void doing_srb_done(struct AdapterCtlBlk *acb, u8 did_flag,
                         p = srb->cmd;
                         dir = p->sc_data_direction;
                         result = MK_RES(0, did_flag, 0, 0);
-                        printk("G:%li(%02i-%i) ", p->serial_number,
+                        printk("G:%p(%02i-%i) ", p,
                                p->device->id, p->device->lun);
                         srb_going_remove(dcb, srb);
                         free_tag(dcb, srb);
@@ -3568,7 +3567,7 @@ static void doing_srb_done(struct AdapterCtlBlk *acb, u8 did_flag,
                         p = srb->cmd;
 
                         result = MK_RES(0, did_flag, 0, 0);
-                        printk("W:%li<%02i-%i>", p->serial_number, p->device->id,
+                        printk("W:%p<%02i-%i>", p, p->device->id,
                                p->device->lun);
                         srb_waiting_remove(dcb, srb);
                         srb_free_insert(acb, srb);
@@ -3677,8 +3676,8 @@ static void request_sense(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
                 struct ScsiReqBlk *srb)
 {
         struct scsi_cmnd *cmd = srb->cmd;
-        dprintkdbg(DBG_1, "request_sense: (pid#%li) <%02i-%i>\n",
-                cmd->serial_number, cmd->device->id, cmd->device->lun);
+        dprintkdbg(DBG_1, "request_sense: (0x%p) <%02i-%i>\n",
+                cmd, cmd->device->id, cmd->device->lun);
 
         srb->flag |= AUTO_REQSENSE;
         srb->adapter_status = 0;
@@ -3708,8 +3707,8 @@ static void request_sense(struct AdapterCtlBlk *acb, struct DeviceCtlBlk *dcb,
 
         if (start_scsi(acb, dcb, srb)) {        /* Should only happen, if sb. else grabs the bus */
                 dprintkl(KERN_DEBUG,
-                        "request_sense: (pid#%li) failed <%02i-%i>\n",
-                        srb->cmd->serial_number, dcb->target_id, dcb->target_lun);
+                        "request_sense: (0x%p) failed <%02i-%i>\n",
+                        srb->cmd, dcb->target_id, dcb->target_lun);
                 srb_going_to_waiting_move(dcb, srb);
                 waiting_set_timer(acb, HZ / 100);
         }
@@ -4717,13 +4716,13 @@ static int dc395x_proc_info(struct Scsi_Host *host, char *buffer,
                                 dcb->target_id, dcb->target_lun,
                                 list_size(&dcb->srb_waiting_list));
                 list_for_each_entry(srb, &dcb->srb_waiting_list, list)
-                        SPRINTF(" %li", srb->cmd->serial_number);
+                        SPRINTF(" %p", srb->cmd);
                 if (!list_empty(&dcb->srb_going_list))
                         SPRINTF("\nDCB (%02i-%i): Going  : %i:",
                                 dcb->target_id, dcb->target_lun,
                                 list_size(&dcb->srb_going_list));
                 list_for_each_entry(srb, &dcb->srb_going_list, list)
-                        SPRINTF(" %li", srb->cmd->serial_number);
+                        SPRINTF(" %p", srb->cmd);
                 if (!list_empty(&dcb->srb_waiting_list) || !list_empty(&dcb->srb_going_list))
                         SPRINTF("\n");
         }
diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c
index 42fe52902add..6fec9fe5dc39 100644
--- a/drivers/scsi/device_handler/scsi_dh_alua.c
+++ b/drivers/scsi/device_handler/scsi_dh_alua.c
@@ -782,7 +782,7 @@ static int alua_bus_attach(struct scsi_device *sdev)
         h->sdev = sdev;
 
         err = alua_initialize(sdev, h);
-        if (err != SCSI_DH_OK)
+        if ((err != SCSI_DH_OK) && (err != SCSI_DH_DEV_OFFLINED))
                 goto failed;
 
         if (!try_module_get(THIS_MODULE))
diff --git a/drivers/scsi/device_handler/scsi_dh_rdac.c b/drivers/scsi/device_handler/scsi_dh_rdac.c
index 293c183dfe6d..e7fc70d6b478 100644
--- a/drivers/scsi/device_handler/scsi_dh_rdac.c
+++ b/drivers/scsi/device_handler/scsi_dh_rdac.c
@@ -182,14 +182,24 @@ struct rdac_dh_data {
         struct rdac_controller  *ctlr;
 #define UNINITIALIZED_LUN       (1 << 8)
         unsigned                lun;
+
+#define RDAC_MODE               0
+#define RDAC_MODE_AVT           1
+#define RDAC_MODE_IOSHIP        2
+        unsigned char           mode;
+
 #define RDAC_STATE_ACTIVE       0
 #define RDAC_STATE_PASSIVE      1
         unsigned char           state;
 
 #define RDAC_LUN_UNOWNED        0
 #define RDAC_LUN_OWNED          1
-#define RDAC_LUN_AVT            2
         char                    lun_state;
+
+#define RDAC_PREFERRED          0
+#define RDAC_NON_PREFERRED      1
+        char                    preferred;
+
         unsigned char           sense[SCSI_SENSE_BUFFERSIZE];
         union                   {
                 struct c2_inquiry c2;
@@ -199,11 +209,15 @@ struct rdac_dh_data {
         } inq;
 };
 
+static const char *mode[] = {
+        "RDAC",
+        "AVT",
+        "IOSHIP",
+};
 static const char *lun_state[] =
 {
         "unowned",
         "owned",
-        "owned (AVT mode)",
 };
 
 struct rdac_queue_data {
@@ -458,25 +472,33 @@ static int check_ownership(struct scsi_device *sdev, struct rdac_dh_data *h)
         int err;
         struct c9_inquiry *inqp;
 
-        h->lun_state = RDAC_LUN_UNOWNED;
         h->state = RDAC_STATE_ACTIVE;
         err = submit_inquiry(sdev, 0xC9, sizeof(struct c9_inquiry), h);
         if (err == SCSI_DH_OK) {
                 inqp = &h->inq.c9;
-                if ((inqp->avte_cvp >> 7) == 0x1) {
-                        /* LUN in AVT mode */
-                        sdev_printk(KERN_NOTICE, sdev,
-                                    "%s: AVT mode detected\n",
-                                    RDAC_NAME);
-                        h->lun_state = RDAC_LUN_AVT;
-                } else if ((inqp->avte_cvp & 0x1) != 0) {
-                        /* LUN was owned by the controller */
+                /* detect the operating mode */
+                if ((inqp->avte_cvp >> 5) & 0x1)
+                        h->mode = RDAC_MODE_IOSHIP; /* LUN in IOSHIP mode */
+                else if (inqp->avte_cvp >> 7)
+                        h->mode = RDAC_MODE_AVT; /* LUN in AVT mode */
+                else
+                        h->mode = RDAC_MODE; /* LUN in RDAC mode */
+
+                /* Update ownership */
+                if (inqp->avte_cvp & 0x1)
                         h->lun_state = RDAC_LUN_OWNED;
+                else {
+                        h->lun_state = RDAC_LUN_UNOWNED;
+                        if (h->mode == RDAC_MODE)
+                                h->state = RDAC_STATE_PASSIVE;
                 }
-        }
 
-        if (h->lun_state == RDAC_LUN_UNOWNED)
-                h->state = RDAC_STATE_PASSIVE;
+                /* Update path prio*/
+                if (inqp->path_prio & 0x1)
+                        h->preferred = RDAC_PREFERRED;
+                else
+                        h->preferred = RDAC_NON_PREFERRED;
+        }
 
         return err;
 }
@@ -648,12 +670,27 @@ static int rdac_activate(struct scsi_device *sdev,
 {
         struct rdac_dh_data *h = get_rdac_data(sdev);
         int err = SCSI_DH_OK;
+        int act = 0;
 
         err = check_ownership(sdev, h);
         if (err != SCSI_DH_OK)
                 goto done;
 
-        if (h->lun_state == RDAC_LUN_UNOWNED) {
+        switch (h->mode) {
+        case RDAC_MODE:
+                if (h->lun_state == RDAC_LUN_UNOWNED)
+                        act = 1;
+                break;
+        case RDAC_MODE_IOSHIP:
+                if ((h->lun_state == RDAC_LUN_UNOWNED) &&
+                    (h->preferred == RDAC_PREFERRED))
+                        act = 1;
+                break;
+        default:
+                break;
+        }
+
+        if (act) {
                 err = queue_mode_select(sdev, fn, data);
                 if (err == SCSI_DH_OK)
                         return 0;
@@ -836,8 +873,9 @@ static int rdac_bus_attach(struct scsi_device *sdev)
         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 
         sdev_printk(KERN_NOTICE, sdev,
-                    "%s: LUN %d (%s)\n",
-                    RDAC_NAME, h->lun, lun_state[(int)h->lun_state]);
+                    "%s: LUN %d (%s) (%s)\n",
+                    RDAC_NAME, h->lun, mode[(int)h->mode],
+                    lun_state[(int)h->lun_state]);
 
         return 0;
 
diff --git a/drivers/scsi/dpt_i2o.c b/drivers/scsi/dpt_i2o.c
index cffcb108ac96..b4f6c9a84e71 100644
--- a/drivers/scsi/dpt_i2o.c
+++ b/drivers/scsi/dpt_i2o.c
@@ -780,7 +780,7 @@ static int adpt_abort(struct scsi_cmnd * cmd)
                 return FAILED;
         }
         pHba = (adpt_hba*) cmd->device->host->hostdata[0];
-        printk(KERN_INFO"%s: Trying to Abort cmd=%ld\n",pHba->name, cmd->serial_number);
+        printk(KERN_INFO"%s: Trying to Abort\n",pHba->name);
         if ((dptdevice = (void*) (cmd->device->hostdata)) == NULL) {
                 printk(KERN_ERR "%s: Unable to abort: No device in cmnd\n",pHba->name);
                 return FAILED;
@@ -802,10 +802,10 @@ static int adpt_abort(struct scsi_cmnd * cmd)
                         printk(KERN_INFO"%s: Abort cmd not supported\n",pHba->name);
                         return FAILED;
                 }
-                printk(KERN_INFO"%s: Abort cmd=%ld failed.\n",pHba->name, cmd->serial_number);
+                printk(KERN_INFO"%s: Abort failed.\n",pHba->name);
                 return FAILED;
         } 
-        printk(KERN_INFO"%s: Abort cmd=%ld complete.\n",pHba->name, cmd->serial_number);
+        printk(KERN_INFO"%s: Abort complete.\n",pHba->name);
         return SUCCESS;
 }
 
diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index 0eb4fe6a4c8a..94de88955a99 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -1766,8 +1766,8 @@ static int eata2x_queuecommand_lck(struct scsi_cmnd *SCpnt,
         struct mscp *cpp;
 
         if (SCpnt->host_scribble)
-                panic("%s: qcomm, pid %ld, SCpnt %p already active.\n",
-                      ha->board_name, SCpnt->serial_number, SCpnt);
+                panic("%s: qcomm, SCpnt %p already active.\n",
+                      ha->board_name, SCpnt);
 
         /* i is the mailbox number, look for the first free mailbox
            starting from last_cp_used */
@@ -1801,7 +1801,7 @@ static int eata2x_queuecommand_lck(struct scsi_cmnd *SCpnt,
 
         if (do_trace)
                 scmd_printk(KERN_INFO, SCpnt,
-                        "qcomm, mbox %d, pid %ld.\n", i, SCpnt->serial_number);
+                        "qcomm, mbox %d.\n", i);
 
         cpp->reqsen = 1;
         cpp->dispri = 1;
@@ -1833,8 +1833,7 @@ static int eata2x_queuecommand_lck(struct scsi_cmnd *SCpnt,
         if (do_dma(shost->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
                 unmap_dma(i, ha);
                 SCpnt->host_scribble = NULL;
-                scmd_printk(KERN_INFO, SCpnt,
-                        "qcomm, pid %ld, adapter busy.\n", SCpnt->serial_number);
+                scmd_printk(KERN_INFO, SCpnt, "qcomm, adapter busy.\n");
                 return 1;
         }
 
@@ -1851,14 +1850,12 @@ static int eata2x_eh_abort(struct scsi_cmnd *SCarg)
         unsigned int i;
 
         if (SCarg->host_scribble == NULL) {
-                scmd_printk(KERN_INFO, SCarg,
-                        "abort, pid %ld inactive.\n", SCarg->serial_number);
+                scmd_printk(KERN_INFO, SCarg, "abort, cmd inactive.\n");
                 return SUCCESS;
         }
 
         i = *(unsigned int *)SCarg->host_scribble;
-        scmd_printk(KERN_WARNING, SCarg,
-                "abort, mbox %d, pid %ld.\n", i, SCarg->serial_number);
+        scmd_printk(KERN_WARNING, SCarg, "abort, mbox %d.\n", i);
 
         if (i >= shost->can_queue)
                 panic("%s: abort, invalid SCarg->host_scribble.\n", ha->board_name);
@@ -1902,8 +1899,8 @@ static int eata2x_eh_abort(struct scsi_cmnd *SCarg)
                 SCarg->result = DID_ABORT << 16;
                 SCarg->host_scribble = NULL;
                 ha->cp_stat[i] = FREE;
-                printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n",
-                       ha->board_name, i, SCarg->serial_number);
+                printk("%s, abort, mbox %d ready, DID_ABORT, done.\n",
+                       ha->board_name, i);
                 SCarg->scsi_done(SCarg);
                 return SUCCESS;
         }
@@ -1919,13 +1916,12 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
         struct Scsi_Host *shost = SCarg->device->host;
         struct hostdata *ha = (struct hostdata *)shost->hostdata;
 
-        scmd_printk(KERN_INFO, SCarg,
-                "reset, enter, pid %ld.\n", SCarg->serial_number);
+        scmd_printk(KERN_INFO, SCarg, "reset, enter.\n");
 
         spin_lock_irq(shost->host_lock);
 
         if (SCarg->host_scribble == NULL)
-                printk("%s: reset, pid %ld inactive.\n", ha->board_name, SCarg->serial_number);
+                printk("%s: reset, inactive.\n", ha->board_name);
 
         if (ha->in_reset) {
                 printk("%s: reset, exit, already in reset.\n", ha->board_name);
@@ -1964,14 +1960,14 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
 
                 if (ha->cp_stat[i] == READY || ha->cp_stat[i] == ABORTING) {
                         ha->cp_stat[i] = ABORTING;
-                        printk("%s: reset, mbox %d aborting, pid %ld.\n",
-                               ha->board_name, i, SCpnt->serial_number);
+                        printk("%s: reset, mbox %d aborting.\n",
+                               ha->board_name, i);
                 }
 
                 else {
                         ha->cp_stat[i] = IN_RESET;
-                        printk("%s: reset, mbox %d in reset, pid %ld.\n",
-                               ha->board_name, i, SCpnt->serial_number);
+                        printk("%s: reset, mbox %d in reset.\n",
+                               ha->board_name, i);
                 }
 
                 if (SCpnt->host_scribble == NULL)
@@ -2025,8 +2021,8 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
                         ha->cp_stat[i] = LOCKED;
 
                         printk
-                            ("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n",
-                             ha->board_name, i, SCpnt->serial_number);
+                            ("%s, reset, mbox %d locked, DID_RESET, done.\n",
+                             ha->board_name, i);
                 }
 
                 else if (ha->cp_stat[i] == ABORTING) {
@@ -2039,8 +2035,8 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
                         ha->cp_stat[i] = FREE;
 
                         printk
-                            ("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n",
-                             ha->board_name, i, SCpnt->serial_number);
+                            ("%s, reset, mbox %d aborting, DID_RESET, done.\n",
+                             ha->board_name, i);
                 }
 
                 else
@@ -2054,7 +2050,7 @@ static int eata2x_eh_host_reset(struct scsi_cmnd *SCarg)
         do_trace = 0;
 
         if (arg_done)
-                printk("%s: reset, exit, pid %ld done.\n", ha->board_name, SCarg->serial_number);
+                printk("%s: reset, exit, done.\n", ha->board_name);
         else
                 printk("%s: reset, exit.\n", ha->board_name);
 
@@ -2238,10 +2234,10 @@ static int reorder(struct hostdata *ha, unsigned long cursec,
                         cpp = &ha->cp[k];
                         SCpnt = cpp->SCpnt;
                         scmd_printk(KERN_INFO, SCpnt,
-                            "%s pid %ld mb %d fc %d nr %d sec %ld ns %u"
+                            "%s mb %d fc %d nr %d sec %ld ns %u"
                              " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
                              (ihdlr ? "ihdlr" : "qcomm"),
-                             SCpnt->serial_number, k, flushcount,
+                             k, flushcount,
                              n_ready, blk_rq_pos(SCpnt->request),
                              blk_rq_sectors(SCpnt->request), cursec, YESNO(s),
                              YESNO(r), YESNO(rev), YESNO(input_only),
@@ -2285,10 +2281,10 @@ static void flush_dev(struct scsi_device *dev, unsigned long cursec,
 
                 if (do_dma(dev->host->io_port, cpp->cp_dma_addr, SEND_CP_DMA)) {
                         scmd_printk(KERN_INFO, SCpnt,
-                            "%s, pid %ld, mbox %d, adapter"
+                            "%s, mbox %d, adapter"
                              " busy, will abort.\n",
                              (ihdlr ? "ihdlr" : "qcomm"),
-                             SCpnt->serial_number, k);
+                             k);
                         ha->cp_stat[k] = ABORTING;
                         continue;
                 }
@@ -2398,12 +2394,12 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
                 panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", ha->board_name, i);
 
         if (SCpnt->host_scribble == NULL)
-                panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", ha->board_name,
-                      i, SCpnt->serial_number, SCpnt);
+                panic("%s: ihdlr, mbox %d, SCpnt %p garbled.\n", ha->board_name,
+                      i, SCpnt);
 
         if (*(unsigned int *)SCpnt->host_scribble != i)
-                panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n",
-                      ha->board_name, i, SCpnt->serial_number,
+                panic("%s: ihdlr, mbox %d, index mismatch %d.\n",
+                      ha->board_name, i,
                       *(unsigned int *)SCpnt->host_scribble);
 
         sync_dma(i, ha);
@@ -2449,11 +2445,11 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
                 if (spp->target_status && SCpnt->device->type == TYPE_DISK &&
                     (!(tstatus == CHECK_CONDITION && ha->iocount <= 1000 &&
                        (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
-                        printk("%s: ihdlr, target %d.%d:%d, pid %ld, "
+                        printk("%s: ihdlr, target %d.%d:%d, "
                                "target_status 0x%x, sense key 0x%x.\n",
                                ha->board_name,
                                SCpnt->device->channel, SCpnt->device->id,
-                               SCpnt->device->lun, SCpnt->serial_number,
+                               SCpnt->device->lun,
                                spp->target_status, SCpnt->sense_buffer[2]);
 
                 ha->target_to[SCpnt->device->id][SCpnt->device->channel] = 0;
@@ -2522,9 +2518,9 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
             do_trace || msg_byte(spp->target_status))
 #endif
                 scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"
-                       " pid %ld, reg 0x%x, count %d.\n",
+                       " reg 0x%x, count %d.\n",
                        i, spp->adapter_status, spp->target_status,
-                       SCpnt->serial_number, reg, ha->iocount);
+                       reg, ha->iocount);
 
         unmap_dma(i, ha);
 
diff --git a/drivers/scsi/eata_pio.c b/drivers/scsi/eata_pio.c
index 4a9641e69f54..d5f8362335d3 100644
--- a/drivers/scsi/eata_pio.c
+++ b/drivers/scsi/eata_pio.c
@@ -372,8 +372,7 @@ static int eata_pio_queue_lck(struct scsi_cmnd *cmd,
         cp->status = USED;      /* claim free slot */
 
         DBG(DBG_QUEUE, scmd_printk(KERN_DEBUG, cmd,
-                "eata_pio_queue pid %ld, y %d\n",
-                cmd->serial_number, y));
+                "eata_pio_queue 0x%p, y %d\n", cmd, y));
 
         cmd->scsi_done = (void *) done;
 
@@ -417,8 +416,8 @@ static int eata_pio_queue_lck(struct scsi_cmnd *cmd,
         if (eata_pio_send_command(base, EATA_CMD_PIO_SEND_CP)) {
                 cmd->result = DID_BUS_BUSY << 16;
                 scmd_printk(KERN_NOTICE, cmd,
-                        "eata_pio_queue pid %ld, HBA busy, "
-                        "returning DID_BUS_BUSY, done.\n", cmd->serial_number);
+                        "eata_pio_queue pid 0x%p, HBA busy, "
+                        "returning DID_BUS_BUSY, done.\n", cmd);
                 done(cmd);
                 cp->status = FREE;
                 return 0;
@@ -432,8 +431,8 @@ static int eata_pio_queue_lck(struct scsi_cmnd *cmd,
                 outw(0, base + HA_RDATA);
 
         DBG(DBG_QUEUE, scmd_printk(KERN_DEBUG, cmd,
-                "Queued base %#.4lx pid: %ld "
-                "slot %d irq %d\n", sh->base, cmd->serial_number, y, sh->irq));
+                "Queued base %#.4lx cmd: 0x%p "
+                "slot %d irq %d\n", sh->base, cmd, y, sh->irq));
 
         return 0;
 }
@@ -445,8 +444,7 @@ static int eata_pio_abort(struct scsi_cmnd *cmd)
         unsigned int loop = 100;
 
         DBG(DBG_ABNORM, scmd_printk(KERN_WARNING, cmd,
-                "eata_pio_abort called pid: %ld\n",
-                cmd->serial_number));
+                "eata_pio_abort called pid: 0x%p\n", cmd));
 
         while (inb(cmd->device->host->base + HA_RAUXSTAT) & HA_ABUSY)
                 if (--loop == 0) {
@@ -481,8 +479,7 @@ static int eata_pio_host_reset(struct scsi_cmnd *cmd)
         struct Scsi_Host *host = cmd->device->host;
 
         DBG(DBG_ABNORM, scmd_printk(KERN_WARNING, cmd,
-                "eata_pio_reset called pid:%ld\n",
-                cmd->serial_number));
+                "eata_pio_reset called\n"));
 
         spin_lock_irq(host->host_lock);
 
@@ -501,7 +498,7 @@ static int eata_pio_host_reset(struct scsi_cmnd *cmd)
 
                 sp = HD(cmd)->ccb[x].cmd;
                 HD(cmd)->ccb[x].status = RESET;
-                printk(KERN_WARNING "eata_pio_reset: slot %d in reset, pid %ld.\n", x, sp->serial_number);
+                printk(KERN_WARNING "eata_pio_reset: slot %d in reset.\n", x);
 
                 if (sp == NULL)
                         panic("eata_pio_reset: slot %d, sp==NULL.\n", x);
diff --git a/drivers/scsi/esp_scsi.c b/drivers/scsi/esp_scsi.c
index 57558523c1b8..9a1af1d6071a 100644
--- a/drivers/scsi/esp_scsi.c
+++ b/drivers/scsi/esp_scsi.c
@@ -708,8 +708,7 @@ static void esp_maybe_execute_command(struct esp *esp)
         tp = &esp->target[tgt];
         lp = dev->hostdata;
 
-        list_del(&ent->list);
-        list_add(&ent->list, &esp->active_cmds);
+        list_move(&ent->list, &esp->active_cmds);
 
         esp->active_cmd = ent;
 
@@ -1244,8 +1243,7 @@ static int esp_finish_select(struct esp *esp)
                 /* Now that the state is unwound properly, put back onto
                  * the issue queue.  This command is no longer active.
                  */
-                list_del(&ent->list);
-                list_add(&ent->list, &esp->queued_cmds);
+                list_move(&ent->list, &esp->queued_cmds);
                 esp->active_cmd = NULL;
 
                 /* Return value ignored by caller, it directly invokes
diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c
index bde6ee5333eb..5d3700dc6f8c 100644
--- a/drivers/scsi/fcoe/fcoe.c
+++ b/drivers/scsi/fcoe/fcoe.c
@@ -381,6 +381,42 @@ out:
 }
 
 /**
+ * fcoe_interface_release() - fcoe_port kref release function
+ * @kref: Embedded reference count in an fcoe_interface struct
+ */
+static void fcoe_interface_release(struct kref *kref)
+{
+        struct fcoe_interface *fcoe;
+        struct net_device *netdev;
+
+        fcoe = container_of(kref, struct fcoe_interface, kref);
+        netdev = fcoe->netdev;
+        /* tear-down the FCoE controller */
+        fcoe_ctlr_destroy(&fcoe->ctlr);
+        kfree(fcoe);
+        dev_put(netdev);
+        module_put(THIS_MODULE);
+}
+
+/**
+ * fcoe_interface_get() - Get a reference to a FCoE interface
+ * @fcoe: The FCoE interface to be held
+ */
+static inline void fcoe_interface_get(struct fcoe_interface *fcoe)
+{
+        kref_get(&fcoe->kref);
+}
+
+/**
+ * fcoe_interface_put() - Put a reference to a FCoE interface
+ * @fcoe: The FCoE interface to be released
+ */
+static inline void fcoe_interface_put(struct fcoe_interface *fcoe)
+{
+        kref_put(&fcoe->kref, fcoe_interface_release);
+}
+
+/**
  * fcoe_interface_cleanup() - Clean up a FCoE interface
  * @fcoe: The FCoE interface to be cleaned up
  *
@@ -392,6 +428,21 @@ void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
         struct fcoe_ctlr *fip = &fcoe->ctlr;
         u8 flogi_maddr[ETH_ALEN];
         const struct net_device_ops *ops;
+        struct fcoe_port *port = lport_priv(fcoe->ctlr.lp);
+
+        FCOE_NETDEV_DBG(netdev, "Destroying interface\n");
+
+        /* Logout of the fabric */
+        fc_fabric_logoff(fcoe->ctlr.lp);
+
+        /* Cleanup the fc_lport */
+        fc_lport_destroy(fcoe->ctlr.lp);
+
+        /* Stop the transmit retry timer */
+        del_timer_sync(&port->timer);
+
+        /* Free existing transmit skbs */
+        fcoe_clean_pending_queue(fcoe->ctlr.lp);
 
         /*
          * Don't listen for Ethernet packets anymore.
@@ -414,6 +465,9 @@ void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
         } else
                 dev_mc_del(netdev, FIP_ALL_ENODE_MACS);
 
+        if (!is_zero_ether_addr(port->data_src_addr))
+                dev_uc_del(netdev, port->data_src_addr);
+
         /* Tell the LLD we are done w/ FCoE */
         ops = netdev->netdev_ops;
         if (ops->ndo_fcoe_disable) {
@@ -421,42 +475,7 @@ void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
                         FCOE_NETDEV_DBG(netdev, "Failed to disable FCoE"
                                         " specific feature for LLD.\n");
         }
-}
-
-/**
- * fcoe_interface_release() - fcoe_port kref release function
- * @kref: Embedded reference count in an fcoe_interface struct
- */
-static void fcoe_interface_release(struct kref *kref)
-{
-        struct fcoe_interface *fcoe;
-        struct net_device *netdev;
-
-        fcoe = container_of(kref, struct fcoe_interface, kref);
-        netdev = fcoe->netdev;
-        /* tear-down the FCoE controller */
-        fcoe_ctlr_destroy(&fcoe->ctlr);
-        kfree(fcoe);
-        dev_put(netdev);
-        module_put(THIS_MODULE);
-}
-
-/**
- * fcoe_interface_get() - Get a reference to a FCoE interface
- * @fcoe: The FCoE interface to be held
- */
-static inline void fcoe_interface_get(struct fcoe_interface *fcoe)
-{
-        kref_get(&fcoe->kref);
-}
-
-/**
- * fcoe_interface_put() - Put a reference to a FCoE interface
- * @fcoe: The FCoE interface to be released
- */
-static inline void fcoe_interface_put(struct fcoe_interface *fcoe)
-{
-        kref_put(&fcoe->kref, fcoe_interface_release);
+        fcoe_interface_put(fcoe);
 }
 
 /**
@@ -821,39 +840,9 @@ skip_oem:
  * fcoe_if_destroy() - Tear down a SW FCoE instance
  * @lport: The local port to be destroyed
  *
- * Locking: must be called with the RTNL mutex held and RTNL mutex
- * needed to be dropped by this function since not dropping RTNL
- * would cause circular locking warning on synchronous fip worker
- * cancelling thru fcoe_interface_put invoked by this function.
- *
  */
 static void fcoe_if_destroy(struct fc_lport *lport)
 {
-        struct fcoe_port *port = lport_priv(lport);
-        struct fcoe_interface *fcoe = port->priv;
-        struct net_device *netdev = fcoe->netdev;
-
-        FCOE_NETDEV_DBG(netdev, "Destroying interface\n");
-
-        /* Logout of the fabric */
-        fc_fabric_logoff(lport);
-
-        /* Cleanup the fc_lport */
-        fc_lport_destroy(lport);
-
-        /* Stop the transmit retry timer */
-        del_timer_sync(&port->timer);
-
-        /* Free existing transmit skbs */
-        fcoe_clean_pending_queue(lport);
-
-        if (!is_zero_ether_addr(port->data_src_addr))
-                dev_uc_del(netdev, port->data_src_addr);
-        rtnl_unlock();
-
-        /* receives may not be stopped until after this */
-        fcoe_interface_put(fcoe);
-
         /* Free queued packets for the per-CPU receive threads */
         fcoe_percpu_clean(lport);
 
@@ -1783,23 +1772,8 @@ static int fcoe_disable(struct net_device *netdev)
         int rc = 0;
 
         mutex_lock(&fcoe_config_mutex);
-#ifdef CONFIG_FCOE_MODULE
-        /*
-         * Make sure the module has been initialized, and is not about to be
-         * removed.  Module paramter sysfs files are writable before the
-         * module_init function is called and after module_exit.
-         */
-        if (THIS_MODULE->state != MODULE_STATE_LIVE) {
-                rc = -ENODEV;
-                goto out_nodev;
-        }
-#endif
-
-        if (!rtnl_trylock()) {
-                mutex_unlock(&fcoe_config_mutex);
-                return -ERESTARTSYS;
-        }
 
+        rtnl_lock();
         fcoe = fcoe_hostlist_lookup_port(netdev);
         rtnl_unlock();
 
@@ -1809,7 +1783,6 @@ static int fcoe_disable(struct net_device *netdev)
         } else
                 rc = -ENODEV;
 
-out_nodev:
         mutex_unlock(&fcoe_config_mutex);
         return rc;
 }
@@ -1828,22 +1801,7 @@ static int fcoe_enable(struct net_device *netdev)
         int rc = 0;
 
         mutex_lock(&fcoe_config_mutex);
-#ifdef CONFIG_FCOE_MODULE
-        /*
-         * Make sure the module has been initialized, and is not about to be
-         * removed.  Module paramter sysfs files are writable before the
-         * module_init function is called and after module_exit.
-         */
-        if (THIS_MODULE->state != MODULE_STATE_LIVE) {
-                rc = -ENODEV;
-                goto out_nodev;
-        }
-#endif
-        if (!rtnl_trylock()) {
-                mutex_unlock(&fcoe_config_mutex);
-                return -ERESTARTSYS;
-        }
-
+        rtnl_lock();
         fcoe = fcoe_hostlist_lookup_port(netdev);
         rtnl_unlock();
 
@@ -1852,7 +1810,6 @@ static int fcoe_enable(struct net_device *netdev)
         else if (!fcoe_link_ok(fcoe->ctlr.lp))
                 fcoe_ctlr_link_up(&fcoe->ctlr);
 
-out_nodev:
         mutex_unlock(&fcoe_config_mutex);
         return rc;
 }
@@ -1868,35 +1825,22 @@ out_nodev:
 static int fcoe_destroy(struct net_device *netdev)
 {
         struct fcoe_interface *fcoe;
+        struct fc_lport *lport;
         int rc = 0;
 
         mutex_lock(&fcoe_config_mutex);
-#ifdef CONFIG_FCOE_MODULE
-        /*
-         * Make sure the module has been initialized, and is not about to be
-         * removed.  Module paramter sysfs files are writable before the
-         * module_init function is called and after module_exit.
-         */
-        if (THIS_MODULE->state != MODULE_STATE_LIVE) {
-                rc = -ENODEV;
-                goto out_nodev;
-        }
-#endif
-        if (!rtnl_trylock()) {
-                mutex_unlock(&fcoe_config_mutex);
-                return -ERESTARTSYS;
-        }
-
+        rtnl_lock();
         fcoe = fcoe_hostlist_lookup_port(netdev);
         if (!fcoe) {
                 rtnl_unlock();
                 rc = -ENODEV;
                 goto out_nodev;
         }
-        fcoe_interface_cleanup(fcoe);
+        lport = fcoe->ctlr.lp;
         list_del(&fcoe->list);
-        /* RTNL mutex is dropped by fcoe_if_destroy */
-        fcoe_if_destroy(fcoe->ctlr.lp);
+        fcoe_interface_cleanup(fcoe);
+        rtnl_unlock();
+        fcoe_if_destroy(lport);
 out_nodev:
         mutex_unlock(&fcoe_config_mutex);
         return rc;
@@ -1912,8 +1856,6 @@ static void fcoe_destroy_work(struct work_struct *work)
 
         port = container_of(work, struct fcoe_port, destroy_work);
         mutex_lock(&fcoe_config_mutex);
-        rtnl_lock();
-        /* RTNL mutex is dropped by fcoe_if_destroy */
         fcoe_if_destroy(port->lport);
         mutex_unlock(&fcoe_config_mutex);
 }
@@ -1948,23 +1890,7 @@ static int fcoe_create(struct net_device *netdev, enum fip_state fip_mode)
         struct fc_lport *lport;
 
         mutex_lock(&fcoe_config_mutex);
-
-        if (!rtnl_trylock()) {
-                mutex_unlock(&fcoe_config_mutex);
-                return -ERESTARTSYS;
-        }
-
-#ifdef CONFIG_FCOE_MODULE
-        /*
-         * Make sure the module has been initialized, and is not about to be
-         * removed.  Module paramter sysfs files are writable before the
-         * module_init function is called and after module_exit.
-         */
-        if (THIS_MODULE->state != MODULE_STATE_LIVE) {
-                rc = -ENODEV;
-                goto out_nodev;
-        }
-#endif
+        rtnl_lock();
 
         /* look for existing lport */
         if (fcoe_hostlist_lookup(netdev)) {
diff --git a/drivers/scsi/fcoe/fcoe_ctlr.c b/drivers/scsi/fcoe/fcoe_ctlr.c
index 9d38be2a41f9..229e4af5508a 100644
--- a/drivers/scsi/fcoe/fcoe_ctlr.c
+++ b/drivers/scsi/fcoe/fcoe_ctlr.c
@@ -978,10 +978,8 @@ static void fcoe_ctlr_recv_adv(struct fcoe_ctlr *fip, struct sk_buff *skb)
          * the FCF that answers multicast solicitations, not the others that
          * are sending periodic multicast advertisements.
          */
-        if (mtu_valid) {
-                list_del(&fcf->list);
-                list_add(&fcf->list, &fip->fcfs);
-        }
+        if (mtu_valid)
+                list_move(&fcf->list, &fip->fcfs);
 
         /*
          * If this is the first validated FCF, note the time and
diff --git a/drivers/scsi/fcoe/fcoe_transport.c b/drivers/scsi/fcoe/fcoe_transport.c
index 258684101bfd..f81f77c8569e 100644
--- a/drivers/scsi/fcoe/fcoe_transport.c
+++ b/drivers/scsi/fcoe/fcoe_transport.c
@@ -335,7 +335,7 @@ out_attach:
 EXPORT_SYMBOL(fcoe_transport_attach);
 
 /**
- * fcoe_transport_attach - Detaches an FCoE transport
+ * fcoe_transport_detach - Detaches an FCoE transport
  * @ft: The fcoe transport to be attached
  *
  * Returns : 0 for success
@@ -343,6 +343,7 @@ EXPORT_SYMBOL(fcoe_transport_attach);
 int fcoe_transport_detach(struct fcoe_transport *ft)
 {
         int rc = 0;
+        struct fcoe_netdev_mapping *nm = NULL, *tmp;
 
         mutex_lock(&ft_mutex);
         if (!ft->attached) {
@@ -352,6 +353,19 @@ int fcoe_transport_detach(struct fcoe_transport *ft)
                 goto out_attach;
         }
 
+        /* remove netdev mapping for this transport as it is going away */
+        mutex_lock(&fn_mutex);
+        list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) {
+                if (nm->ft == ft) {
+                        LIBFCOE_TRANSPORT_DBG("transport %s going away, "
+                                "remove its netdev mapping for %s\n",
+                                ft->name, nm->netdev->name);
+                        list_del(&nm->list);
+                        kfree(nm);
+                }
+        }
+        mutex_unlock(&fn_mutex);
+
         list_del(&ft->list);
         ft->attached = false;
         LIBFCOE_TRANSPORT_DBG("detaching transport %s\n", ft->name);
@@ -371,9 +385,9 @@ static int fcoe_transport_show(char *buffer, const struct kernel_param *kp)
         i = j = sprintf(buffer, "Attached FCoE transports:");
         mutex_lock(&ft_mutex);
         list_for_each_entry(ft, &fcoe_transports, list) {
-                i += snprintf(&buffer[i], IFNAMSIZ, "%s ", ft->name);
-                if (i >= PAGE_SIZE)
+                if (i >= PAGE_SIZE - IFNAMSIZ)
                         break;
+                i += snprintf(&buffer[i], IFNAMSIZ, "%s ", ft->name);
         }
         mutex_unlock(&ft_mutex);
         if (i == j)
@@ -530,9 +544,6 @@ static int fcoe_transport_create(const char *buffer, struct kernel_param *kp)
         struct fcoe_transport *ft = NULL;
         enum fip_state fip_mode = (enum fip_state)(long)kp->arg;
 
-        if (!mutex_trylock(&ft_mutex))
-                return restart_syscall();
-
 #ifdef CONFIG_LIBFCOE_MODULE
         /*
          * Make sure the module has been initialized, and is not about to be
@@ -543,6 +554,8 @@ static int fcoe_transport_create(const char *buffer, struct kernel_param *kp)
                 goto out_nodev;
 #endif
 
+        mutex_lock(&ft_mutex);
+
         netdev = fcoe_if_to_netdev(buffer);
         if (!netdev) {
                 LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buffer);
@@ -586,10 +599,7 @@ out_putdev:
         dev_put(netdev);
 out_nodev:
         mutex_unlock(&ft_mutex);
-        if (rc == -ERESTARTSYS)
-                return restart_syscall();
-        else
-                return rc;
+        return rc;
 }
 
 /**
@@ -608,9 +618,6 @@ static int fcoe_transport_destroy(const char *buffer, struct kernel_param *kp)
         struct net_device *netdev = NULL;
         struct fcoe_transport *ft = NULL;
 
-        if (!mutex_trylock(&ft_mutex))
-                return restart_syscall();
-
 #ifdef CONFIG_LIBFCOE_MODULE
         /*
          * Make sure the module has been initialized, and is not about to be
@@ -621,6 +628,8 @@ static int fcoe_transport_destroy(const char *buffer, struct kernel_param *kp)
                 goto out_nodev;
 #endif
 
+        mutex_lock(&ft_mutex);
+
         netdev = fcoe_if_to_netdev(buffer);
         if (!netdev) {
                 LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buffer);
@@ -645,11 +654,7 @@ out_putdev:
         dev_put(netdev);
 out_nodev:
         mutex_unlock(&ft_mutex);
-
-        if (rc == -ERESTARTSYS)
-                return restart_syscall();
-        else
-                return rc;
+        return rc;
 }
 
 /**
@@ -667,9 +672,6 @@ static int fcoe_transport_disable(const char *buffer, struct kernel_param *kp)
         struct net_device *netdev = NULL;
         struct fcoe_transport *ft = NULL;
 
-        if (!mutex_trylock(&ft_mutex))
-                return restart_syscall();
-
 #ifdef CONFIG_LIBFCOE_MODULE
         /*
          * Make sure the module has been initialized, and is not about to be
@@ -680,6 +682,8 @@ static int fcoe_transport_disable(const char *buffer, struct kernel_param *kp)
                 goto out_nodev;
 #endif
 
+        mutex_lock(&ft_mutex);
+
         netdev = fcoe_if_to_netdev(buffer);
         if (!netdev)
                 goto out_nodev;
@@ -716,9 +720,6 @@ static int fcoe_transport_enable(const char *buffer, struct kernel_param *kp)
         struct net_device *netdev = NULL;
         struct fcoe_transport *ft = NULL;
 
-        if (!mutex_trylock(&ft_mutex))
-                return restart_syscall();
-
 #ifdef CONFIG_LIBFCOE_MODULE
         /*
          * Make sure the module has been initialized, and is not about to be
@@ -729,6 +730,8 @@ static int fcoe_transport_enable(const char *buffer, struct kernel_param *kp)
                 goto out_nodev;
 #endif
 
+        mutex_lock(&ft_mutex);
+
         netdev = fcoe_if_to_netdev(buffer);
         if (!netdev)
                 goto out_nodev;
@@ -743,10 +746,7 @@ out_putdev:
         dev_put(netdev);
 out_nodev:
         mutex_unlock(&ft_mutex);
-        if (rc == -ERESTARTSYS)
-                return restart_syscall();
-        else
-                return rc;
+        return rc;
 }
 
 /**
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index 415ad4fb50d4..c6c0434d8034 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -273,7 +273,7 @@ static ssize_t host_show_transport_mode(struct device *dev,
                         "performant" : "simple");
 }
 
-/* List of controllers which cannot be reset on kexec with reset_devices */
+/* List of controllers which cannot be hard reset on kexec with reset_devices */
 static u32 unresettable_controller[] = {
         0x324a103C, /* Smart Array P712m */
         0x324b103C, /* SmartArray P711m */
@@ -291,16 +291,45 @@ static u32 unresettable_controller[] = {
         0x409D0E11, /* Smart Array 6400 EM */
 };
 
-static int ctlr_is_resettable(struct ctlr_info *h)
+/* List of controllers which cannot even be soft reset */
+static u32 soft_unresettable_controller[] = {
+        /* Exclude 640x boards.  These are two pci devices in one slot
+         * which share a battery backed cache module.  One controls the
+         * cache, the other accesses the cache through the one that controls
+         * it.  If we reset the one controlling the cache, the other will
+         * likely not be happy.  Just forbid resetting this conjoined mess.
+         * The 640x isn't really supported by hpsa anyway.
+         */
+        0x409C0E11, /* Smart Array 6400 */
+        0x409D0E11, /* Smart Array 6400 EM */
+};
+
+static int ctlr_is_hard_resettable(u32 board_id)
 {
         int i;
 
         for (i = 0; i < ARRAY_SIZE(unresettable_controller); i++)
-                if (unresettable_controller[i] == h->board_id)
+                if (unresettable_controller[i] == board_id)
+                        return 0;
+        return 1;
+}
+
+static int ctlr_is_soft_resettable(u32 board_id)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(soft_unresettable_controller); i++)
+                if (soft_unresettable_controller[i] == board_id)
                         return 0;
         return 1;
 }
 
+static int ctlr_is_resettable(u32 board_id)
+{
+        return ctlr_is_hard_resettable(board_id) ||
+                ctlr_is_soft_resettable(board_id);
+}
+
 static ssize_t host_show_resettable(struct device *dev,
         struct device_attribute *attr, char *buf)
 {
@@ -308,7 +337,7 @@ static ssize_t host_show_resettable(struct device *dev,
         struct Scsi_Host *shost = class_to_shost(dev);
 
         h = shost_to_hba(shost);
-        return snprintf(buf, 20, "%d\n", ctlr_is_resettable(h));
+        return snprintf(buf, 20, "%d\n", ctlr_is_resettable(h->board_id));
 }
 
 static inline int is_logical_dev_addr_mode(unsigned char scsi3addr[])
@@ -929,13 +958,6 @@ static void hpsa_slave_destroy(struct scsi_device *sdev)
         /* nothing to do. */
 }
 
-static void hpsa_scsi_setup(struct ctlr_info *h)
-{
-        h->ndevices = 0;
-        h->scsi_host = NULL;
-        spin_lock_init(&h->devlock);
-}
-
 static void hpsa_free_sg_chain_blocks(struct ctlr_info *h)
 {
         int i;
@@ -1006,8 +1028,7 @@ static void hpsa_unmap_sg_chain_block(struct ctlr_info *h,
         pci_unmap_single(h->pdev, temp64.val, chain_sg->Len, PCI_DMA_TODEVICE);
 }
 
-static void complete_scsi_command(struct CommandList *cp,
-        int timeout, u32 tag)
+static void complete_scsi_command(struct CommandList *cp)
 {
         struct scsi_cmnd *cmd;
         struct ctlr_info *h;
@@ -1308,7 +1329,7 @@ static void hpsa_scsi_do_simple_cmd_with_retry(struct ctlr_info *h,
         int retry_count = 0;
 
         do {
-                memset(c->err_info, 0, sizeof(c->err_info));
+                memset(c->err_info, 0, sizeof(*c->err_info));
                 hpsa_scsi_do_simple_cmd_core(h, c);
                 retry_count++;
         } while (check_for_unit_attention(h, c) && retry_count <= 3);
@@ -1570,6 +1591,7 @@ static unsigned char *msa2xxx_model[] = {
         "MSA2024",
         "MSA2312",
         "MSA2324",
+        "P2000 G3 SAS",
         NULL,
 };
 
@@ -2751,6 +2773,26 @@ static int hpsa_ioctl(struct scsi_device *dev, int cmd, void *arg)
         }
 }
 
+static int __devinit hpsa_send_host_reset(struct ctlr_info *h,
+        unsigned char *scsi3addr, u8 reset_type)
+{
+        struct CommandList *c;
+
+        c = cmd_alloc(h);
+        if (!c)
+                return -ENOMEM;
+        fill_cmd(c, HPSA_DEVICE_RESET_MSG, h, NULL, 0, 0,
+                RAID_CTLR_LUNID, TYPE_MSG);
+        c->Request.CDB[1] = reset_type; /* fill_cmd defaults to target reset */
+        c->waiting = NULL;
+        enqueue_cmd_and_start_io(h, c);
+        /* Don't wait for completion, the reset won't complete.  Don't free
+         * the command either.  This is the last command we will send before
+         * re-initializing everything, so it doesn't matter and won't leak.
+         */
+        return 0;
+}
+
 static void fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
         void *buff, size_t size, u8 page_code, unsigned char *scsi3addr,
         int cmd_type)
@@ -2828,7 +2870,8 @@ static void fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
                         c->Request.Type.Attribute = ATTR_SIMPLE;
                         c->Request.Type.Direction = XFER_NONE;
                         c->Request.Timeout = 0; /* Don't time out */
-                        c->Request.CDB[0] =  0x01; /* RESET_MSG is 0x01 */
+                        memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
+                        c->Request.CDB[0] =  cmd;
                         c->Request.CDB[1] = 0x03;  /* Reset target above */
                         /* If bytes 4-7 are zero, it means reset the */
                         /* LunID device */
@@ -2936,7 +2979,7 @@ static inline void finish_cmd(struct CommandList *c, u32 raw_tag)
 {
         removeQ(c);
         if (likely(c->cmd_type == CMD_SCSI))
-                complete_scsi_command(c, 0, raw_tag);
+                complete_scsi_command(c);
         else if (c->cmd_type == CMD_IOCTL_PEND)
                 complete(c->waiting);
 }
@@ -2994,6 +3037,63 @@ static inline u32 process_nonindexed_cmd(struct ctlr_info *h,
         return next_command(h);
 }
 
+/* Some controllers, like p400, will give us one interrupt
+ * after a soft reset, even if we turned interrupts off.
+ * Only need to check for this in the hpsa_xxx_discard_completions
+ * functions.
+ */
+static int ignore_bogus_interrupt(struct ctlr_info *h)
+{
+        if (likely(!reset_devices))
+                return 0;
+
+        if (likely(h->interrupts_enabled))
+                return 0;
+
+        dev_info(&h->pdev->dev, "Received interrupt while interrupts disabled "
+                "(known firmware bug.)  Ignoring.\n");
+
+        return 1;
+}
+
+static irqreturn_t hpsa_intx_discard_completions(int irq, void *dev_id)
+{
+        struct ctlr_info *h = dev_id;
+        unsigned long flags;
+        u32 raw_tag;
+
+        if (ignore_bogus_interrupt(h))
+                return IRQ_NONE;
+
+        if (interrupt_not_for_us(h))
+                return IRQ_NONE;
+        spin_lock_irqsave(&h->lock, flags);
+        while (interrupt_pending(h)) {
+                raw_tag = get_next_completion(h);
+                while (raw_tag != FIFO_EMPTY)
+                        raw_tag = next_command(h);
+        }
+        spin_unlock_irqrestore(&h->lock, flags);
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t hpsa_msix_discard_completions(int irq, void *dev_id)
+{
+        struct ctlr_info *h = dev_id;
+        unsigned long flags;
+        u32 raw_tag;
+
+        if (ignore_bogus_interrupt(h))
+                return IRQ_NONE;
+
+        spin_lock_irqsave(&h->lock, flags);
+        raw_tag = get_next_completion(h);
+        while (raw_tag != FIFO_EMPTY)
+                raw_tag = next_command(h);
+        spin_unlock_irqrestore(&h->lock, flags);
+        return IRQ_HANDLED;
+}
+
 static irqreturn_t do_hpsa_intr_intx(int irq, void *dev_id)
 {
         struct ctlr_info *h = dev_id;
@@ -3132,11 +3232,10 @@ static __devinit int hpsa_message(struct pci_dev *pdev, unsigned char opcode,
         return 0;
 }
 
-#define hpsa_soft_reset_controller(p) hpsa_message(p, 1, 0)
 #define hpsa_noop(p) hpsa_message(p, 3, 0)
 
 static int hpsa_controller_hard_reset(struct pci_dev *pdev,
-        void * __iomem vaddr, bool use_doorbell)
+        void * __iomem vaddr, u32 use_doorbell)
 {
         u16 pmcsr;
         int pos;
@@ -3147,8 +3246,7 @@ static int hpsa_controller_hard_reset(struct pci_dev *pdev,
                  * other way using the doorbell register.
                  */
                 dev_info(&pdev->dev, "using doorbell to reset controller\n");
-                writel(DOORBELL_CTLR_RESET, vaddr + SA5_DOORBELL);
-                msleep(1000);
+                writel(use_doorbell, vaddr + SA5_DOORBELL);
         } else { /* Try to do it the PCI power state way */
 
                 /* Quoting from the Open CISS Specification: "The Power
@@ -3179,12 +3277,63 @@ static int hpsa_controller_hard_reset(struct pci_dev *pdev,
                 pmcsr &= ~PCI_PM_CTRL_STATE_MASK;
                 pmcsr |= PCI_D0;
                 pci_write_config_word(pdev, pos + PCI_PM_CTRL, pmcsr);
-
-                msleep(500);
         }
         return 0;
 }
 
+static __devinit void init_driver_version(char *driver_version, int len)
+{
+        memset(driver_version, 0, len);
+        strncpy(driver_version, "hpsa " HPSA_DRIVER_VERSION, len - 1);
+}
+
+static __devinit int write_driver_ver_to_cfgtable(
+        struct CfgTable __iomem *cfgtable)
+{
+        char *driver_version;
+        int i, size = sizeof(cfgtable->driver_version);
+
+        driver_version = kmalloc(size, GFP_KERNEL);
+        if (!driver_version)
+                return -ENOMEM;
+
+        init_driver_version(driver_version, size);
+        for (i = 0; i < size; i++)
+                writeb(driver_version[i], &cfgtable->driver_version[i]);
+        kfree(driver_version);
+        return 0;
+}
+
+static __devinit void read_driver_ver_from_cfgtable(
+        struct CfgTable __iomem *cfgtable, unsigned char *driver_ver)
+{
+        int i;
+
+        for (i = 0; i < sizeof(cfgtable->driver_version); i++)
+                driver_ver[i] = readb(&cfgtable->driver_version[i]);
+}
+
+static __devinit int controller_reset_failed(
+        struct CfgTable __iomem *cfgtable)
+{
+
+        char *driver_ver, *old_driver_ver;
+        int rc, size = sizeof(cfgtable->driver_version);
+
+        old_driver_ver = kmalloc(2 * size, GFP_KERNEL);
+        if (!old_driver_ver)
+                return -ENOMEM;
+        driver_ver = old_driver_ver + size;
+
+        /* After a reset, the 32 bytes of "driver version" in the cfgtable
+         * should have been changed, otherwise we know the reset failed.
+         */
+        init_driver_version(old_driver_ver, size);
+        read_driver_ver_from_cfgtable(cfgtable, driver_ver);
+        rc = !memcmp(driver_ver, old_driver_ver, size);
+        kfree(old_driver_ver);
+        return rc;
+}
 /* This does a hard reset of the controller using PCI power management
  * states or the using the doorbell register.
  */
@@ -3195,10 +3344,10 @@ static __devinit int hpsa_kdump_hard_reset_controller(struct pci_dev *pdev)
         u64 cfg_base_addr_index;
         void __iomem *vaddr;
         unsigned long paddr;
-        u32 misc_fw_support, active_transport;
+        u32 misc_fw_support;
         int rc;
         struct CfgTable __iomem *cfgtable;
-        bool use_doorbell;
+        u32 use_doorbell;
         u32 board_id;
         u16 command_register;
 
@@ -3215,20 +3364,15 @@ static __devinit int hpsa_kdump_hard_reset_controller(struct pci_dev *pdev)
          * using the doorbell register.
          */
 
-        /* Exclude 640x boards.  These are two pci devices in one slot
-         * which share a battery backed cache module.  One controls the
-         * cache, the other accesses the cache through the one that controls
-         * it.  If we reset the one controlling the cache, the other will
-         * likely not be happy.  Just forbid resetting this conjoined mess.
-         * The 640x isn't really supported by hpsa anyway.
-         */
         rc = hpsa_lookup_board_id(pdev, &board_id);
-        if (rc < 0) {
+        if (rc < 0 || !ctlr_is_resettable(board_id)) {
                 dev_warn(&pdev->dev, "Not resetting device.\n");
                 return -ENODEV;
         }
-        if (board_id == 0x409C0E11 || board_id == 0x409D0E11)
-                return -ENOTSUPP;
+
+        /* if controller is soft- but not hard resettable... */
+        if (!ctlr_is_hard_resettable(board_id))
+                return -ENOTSUPP; /* try soft reset later. */
 
         /* Save the PCI command register */
         pci_read_config_word(pdev, 4, &command_register);
@@ -3257,10 +3401,28 @@ static __devinit int hpsa_kdump_hard_reset_controller(struct pci_dev *pdev)
                 rc = -ENOMEM;
                 goto unmap_vaddr;
         }
+        rc = write_driver_ver_to_cfgtable(cfgtable);
+        if (rc)
+                goto unmap_vaddr;
 
-        /* If reset via doorbell register is supported, use that. */
+        /* If reset via doorbell register is supported, use that.
+         * There are two such methods.  Favor the newest method.
+         */
         misc_fw_support = readl(&cfgtable->misc_fw_support);
-        use_doorbell = misc_fw_support & MISC_FW_DOORBELL_RESET;
+        use_doorbell = misc_fw_support & MISC_FW_DOORBELL_RESET2;
+        if (use_doorbell) {
+                use_doorbell = DOORBELL_CTLR_RESET2;
+        } else {
+                use_doorbell = misc_fw_support & MISC_FW_DOORBELL_RESET;
+                if (use_doorbell) {
+                        dev_warn(&pdev->dev, "Controller claims that "
+                                "'Bit 2 doorbell reset' is "
+                                "supported, but not 'bit 5 doorbell reset'.  "
+                                "Firmware update is recommended.\n");
+                        rc = -ENOTSUPP; /* try soft reset */
+                        goto unmap_cfgtable;
+                }
+        }
 
         rc = hpsa_controller_hard_reset(pdev, vaddr, use_doorbell);
         if (rc)
@@ -3279,30 +3441,32 @@ static __devinit int hpsa_kdump_hard_reset_controller(struct pci_dev *pdev)
         msleep(HPSA_POST_RESET_PAUSE_MSECS);
 
         /* Wait for board to become not ready, then ready. */
-        dev_info(&pdev->dev, "Waiting for board to become ready.\n");
+        dev_info(&pdev->dev, "Waiting for board to reset.\n");
         rc = hpsa_wait_for_board_state(pdev, vaddr, BOARD_NOT_READY);
-        if (rc)
+        if (rc) {
                 dev_warn(&pdev->dev,
-                        "failed waiting for board to become not ready\n");
+                        "failed waiting for board to reset."
+                        " Will try soft reset.\n");
+                rc = -ENOTSUPP; /* Not expected, but try soft reset later */
+                goto unmap_cfgtable;
+        }
         rc = hpsa_wait_for_board_state(pdev, vaddr, BOARD_READY);
         if (rc) {
                 dev_warn(&pdev->dev,
-                        "failed waiting for board to become ready\n");
+                        "failed waiting for board to become ready "
+                        "after hard reset\n");
                 goto unmap_cfgtable;
         }
-        dev_info(&pdev->dev, "board ready.\n");
 
-        /* Controller should be in simple mode at this point.  If it's not,
-         * It means we're on one of those controllers which doesn't support
-         * the doorbell reset method and on which the PCI power management reset
-         * method doesn't work (P800, for example.)
-         * In those cases, don't try to proceed, as it generally doesn't work.
-         */
-        active_transport = readl(&cfgtable->TransportActive);
-        if (active_transport & PERFORMANT_MODE) {
-                dev_warn(&pdev->dev, "Unable to successfully reset controller,"
-                        " Ignoring controller.\n");
-                rc = -ENODEV;
+        rc = controller_reset_failed(vaddr);
+        if (rc < 0)
+                goto unmap_cfgtable;
+        if (rc) {
+                dev_warn(&pdev->dev, "Unable to successfully reset "
+                        "controller. Will try soft reset.\n");
+                rc = -ENOTSUPP;
+        } else {
+                dev_info(&pdev->dev, "board ready after hard reset.\n");
         }
 
 unmap_cfgtable:
@@ -3543,6 +3707,9 @@ static int __devinit hpsa_find_cfgtables(struct ctlr_info *h)
                        cfg_base_addr_index) + cfg_offset, sizeof(*h->cfgtable));
         if (!h->cfgtable)
                 return -ENOMEM;
+        rc = write_driver_ver_to_cfgtable(h->cfgtable);
+        if (rc)
+                return rc;
         /* Find performant mode table. */
         trans_offset = readl(&h->cfgtable->TransMethodOffset);
         h->transtable = remap_pci_mem(pci_resource_start(h->pdev,
@@ -3777,11 +3944,12 @@ static __devinit int hpsa_init_reset_devices(struct pci_dev *pdev)
          * due to concerns about shared bbwc between 6402/6404 pair.
          */
         if (rc == -ENOTSUPP)
-                return 0; /* just try to do the kdump anyhow. */
+                return rc; /* just try to do the kdump anyhow. */
         if (rc)
                 return -ENODEV;
 
         /* Now try to get the controller to respond to a no-op */
+        dev_warn(&pdev->dev, "Waiting for controller to respond to no-op\n");
         for (i = 0; i < HPSA_POST_RESET_NOOP_RETRIES; i++) {
                 if (hpsa_noop(pdev) == 0)
                         break;
@@ -3792,18 +3960,133 @@ static __devinit int hpsa_init_reset_devices(struct pci_dev *pdev)
         return 0;
 }
 
+static __devinit int hpsa_allocate_cmd_pool(struct ctlr_info *h)
+{
+        h->cmd_pool_bits = kzalloc(
+                DIV_ROUND_UP(h->nr_cmds, BITS_PER_LONG) *
+                sizeof(unsigned long), GFP_KERNEL);
+        h->cmd_pool = pci_alloc_consistent(h->pdev,
+                    h->nr_cmds * sizeof(*h->cmd_pool),
+                    &(h->cmd_pool_dhandle));
+        h->errinfo_pool = pci_alloc_consistent(h->pdev,
+                    h->nr_cmds * sizeof(*h->errinfo_pool),
+                    &(h->errinfo_pool_dhandle));
+        if ((h->cmd_pool_bits == NULL)
+            || (h->cmd_pool == NULL)
+            || (h->errinfo_pool == NULL)) {
+                dev_err(&h->pdev->dev, "out of memory in %s", __func__);
+                return -ENOMEM;
+        }
+        return 0;
+}
+
+static void hpsa_free_cmd_pool(struct ctlr_info *h)
+{
+        kfree(h->cmd_pool_bits);
+        if (h->cmd_pool)
+                pci_free_consistent(h->pdev,
+                            h->nr_cmds * sizeof(struct CommandList),
+                            h->cmd_pool, h->cmd_pool_dhandle);
+        if (h->errinfo_pool)
+                pci_free_consistent(h->pdev,
+                            h->nr_cmds * sizeof(struct ErrorInfo),
+                            h->errinfo_pool,
+                            h->errinfo_pool_dhandle);
+}
+
+static int hpsa_request_irq(struct ctlr_info *h,
+        irqreturn_t (*msixhandler)(int, void *),
+        irqreturn_t (*intxhandler)(int, void *))
+{
+        int rc;
+
+        if (h->msix_vector || h->msi_vector)
+                rc = request_irq(h->intr[h->intr_mode], msixhandler,
+                                IRQF_DISABLED, h->devname, h);
+        else
+                rc = request_irq(h->intr[h->intr_mode], intxhandler,
+                                IRQF_DISABLED, h->devname, h);
+        if (rc) {
+                dev_err(&h->pdev->dev, "unable to get irq %d for %s\n",
+                       h->intr[h->intr_mode], h->devname);
+                return -ENODEV;
+        }
+        return 0;
+}
+
+static int __devinit hpsa_kdump_soft_reset(struct ctlr_info *h)
+{
+        if (hpsa_send_host_reset(h, RAID_CTLR_LUNID,
+                HPSA_RESET_TYPE_CONTROLLER)) {
+                dev_warn(&h->pdev->dev, "Resetting array controller failed.\n");
+                return -EIO;
+        }
+
+        dev_info(&h->pdev->dev, "Waiting for board to soft reset.\n");
+        if (hpsa_wait_for_board_state(h->pdev, h->vaddr, BOARD_NOT_READY)) {
+                dev_warn(&h->pdev->dev, "Soft reset had no effect.\n");
+                return -1;
+        }
+
+        dev_info(&h->pdev->dev, "Board reset, awaiting READY status.\n");
+        if (hpsa_wait_for_board_state(h->pdev, h->vaddr, BOARD_READY)) {
+                dev_warn(&h->pdev->dev, "Board failed to become ready "
+                        "after soft reset.\n");
+                return -1;
+        }
+
+        return 0;
+}
+
+static void hpsa_undo_allocations_after_kdump_soft_reset(struct ctlr_info *h)
+{
+        free_irq(h->intr[h->intr_mode], h);
+#ifdef CONFIG_PCI_MSI
+        if (h->msix_vector)
+                pci_disable_msix(h->pdev);
+        else if (h->msi_vector)
+                pci_disable_msi(h->pdev);
+#endif /* CONFIG_PCI_MSI */
+        hpsa_free_sg_chain_blocks(h);
+        hpsa_free_cmd_pool(h);
+        kfree(h->blockFetchTable);
+        pci_free_consistent(h->pdev, h->reply_pool_size,
+                h->reply_pool, h->reply_pool_dhandle);
+        if (h->vaddr)
+                iounmap(h->vaddr);
+        if (h->transtable)
+                iounmap(h->transtable);
+        if (h->cfgtable)
+                iounmap(h->cfgtable);
+        pci_release_regions(h->pdev);
+        kfree(h);
+}
+
 static int __devinit hpsa_init_one(struct pci_dev *pdev,
                                     const struct pci_device_id *ent)
 {
         int dac, rc;
         struct ctlr_info *h;
+        int try_soft_reset = 0;
+        unsigned long flags;
 
         if (number_of_controllers == 0)
                 printk(KERN_INFO DRIVER_NAME "\n");
 
         rc = hpsa_init_reset_devices(pdev);
-        if (rc)
-                return rc;
+        if (rc) {
+                if (rc != -ENOTSUPP)
+                        return rc;
+                /* If the reset fails in a particular way (it has no way to do
+                 * a proper hard reset, so returns -ENOTSUPP) we can try to do
+                 * a soft reset once we get the controller configured up to the
+                 * point that it can accept a command.
+                 */
+                try_soft_reset = 1;
+                rc = 0;
+        }
+
+reinit_after_soft_reset:
 
         /* Command structures must be aligned on a 32-byte boundary because
          * the 5 lower bits of the address are used by the hardware. and by
@@ -3847,54 +4130,82 @@ static int __devinit hpsa_init_one(struct pci_dev *pdev,
         /* make sure the board interrupts are off */
         h->access.set_intr_mask(h, HPSA_INTR_OFF);
 
-        if (h->msix_vector || h->msi_vector)
-                rc = request_irq(h->intr[h->intr_mode], do_hpsa_intr_msi,
-                                IRQF_DISABLED, h->devname, h);
-        else
-                rc = request_irq(h->intr[h->intr_mode], do_hpsa_intr_intx,
-                                IRQF_DISABLED, h->devname, h);
-        if (rc) {
-                dev_err(&pdev->dev, "unable to get irq %d for %s\n",
-                       h->intr[h->intr_mode], h->devname);
+        if (hpsa_request_irq(h, do_hpsa_intr_msi, do_hpsa_intr_intx))
                 goto clean2;
-        }
-
         dev_info(&pdev->dev, "%s: <0x%x> at IRQ %d%s using DAC\n",
                h->devname, pdev->device,
                h->intr[h->intr_mode], dac ? "" : " not");
-
-        h->cmd_pool_bits =
-            kmalloc(((h->nr_cmds + BITS_PER_LONG -
-                      1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL);
-        h->cmd_pool = pci_alloc_consistent(h->pdev,
-                    h->nr_cmds * sizeof(*h->cmd_pool),
-                    &(h->cmd_pool_dhandle));
-        h->errinfo_pool = pci_alloc_consistent(h->pdev,
-                    h->nr_cmds * sizeof(*h->errinfo_pool),
-                    &(h->errinfo_pool_dhandle));
-        if ((h->cmd_pool_bits == NULL)
-            || (h->cmd_pool == NULL)
-            || (h->errinfo_pool == NULL)) {
-                dev_err(&pdev->dev, "out of memory");
-                rc = -ENOMEM;
+        if (hpsa_allocate_cmd_pool(h))
                 goto clean4;
-        }
         if (hpsa_allocate_sg_chain_blocks(h))
                 goto clean4;
         init_waitqueue_head(&h->scan_wait_queue);
         h->scan_finished = 1; /* no scan currently in progress */
 
         pci_set_drvdata(pdev, h);
-        memset(h->cmd_pool_bits, 0,
-               ((h->nr_cmds + BITS_PER_LONG -
-                 1) / BITS_PER_LONG) * sizeof(unsigned long));
+        h->ndevices = 0;
+        h->scsi_host = NULL;
+        spin_lock_init(&h->devlock);
+        hpsa_put_ctlr_into_performant_mode(h);
+
+        /* At this point, the controller is ready to take commands.
+         * Now, if reset_devices and the hard reset didn't work, try
+         * the soft reset and see if that works.
+         */
+        if (try_soft_reset) {
+
+                /* This is kind of gross.  We may or may not get a completion
+                 * from the soft reset command, and if we do, then the value
+                 * from the fifo may or may not be valid.  So, we wait 10 secs
+                 * after the reset throwing away any completions we get during
+                 * that time.  Unregister the interrupt handler and register
+                 * fake ones to scoop up any residual completions.
+                 */
+                spin_lock_irqsave(&h->lock, flags);
+                h->access.set_intr_mask(h, HPSA_INTR_OFF);
+                spin_unlock_irqrestore(&h->lock, flags);
+                free_irq(h->intr[h->intr_mode], h);
+                rc = hpsa_request_irq(h, hpsa_msix_discard_completions,
+                                        hpsa_intx_discard_completions);
+                if (rc) {
+                        dev_warn(&h->pdev->dev, "Failed to request_irq after "
+                                "soft reset.\n");
+                        goto clean4;
+                }
+
+                rc = hpsa_kdump_soft_reset(h);
+                if (rc)
+                        /* Neither hard nor soft reset worked, we're hosed. */
+                        goto clean4;
+
+                dev_info(&h->pdev->dev, "Board READY.\n");
+                dev_info(&h->pdev->dev,
+                        "Waiting for stale completions to drain.\n");
+                h->access.set_intr_mask(h, HPSA_INTR_ON);
+                msleep(10000);
+                h->access.set_intr_mask(h, HPSA_INTR_OFF);
+
+                rc = controller_reset_failed(h->cfgtable);
+                if (rc)
+                        dev_info(&h->pdev->dev,
+                                "Soft reset appears to have failed.\n");
+
+                /* since the controller's reset, we have to go back and re-init
+                 * everything.  Easiest to just forget what we've done and do it
+                 * all over again.
+                 */
+                hpsa_undo_allocations_after_kdump_soft_reset(h);
+                try_soft_reset = 0;
+                if (rc)
+                        /* don't go to clean4, we already unallocated */
+                        return -ENODEV;
 
-        hpsa_scsi_setup(h);
+                goto reinit_after_soft_reset;
+        }
 
         /* Turn the interrupts on so we can service requests */
         h->access.set_intr_mask(h, HPSA_INTR_ON);
 
-        hpsa_put_ctlr_into_performant_mode(h);
         hpsa_hba_inquiry(h);
         hpsa_register_scsi(h);  /* hook ourselves into SCSI subsystem */
         h->busy_initializing = 0;
@@ -3902,16 +4213,7 @@ static int __devinit hpsa_init_one(struct pci_dev *pdev,
 
 clean4:
         hpsa_free_sg_chain_blocks(h);
-        kfree(h->cmd_pool_bits);
-        if (h->cmd_pool)
-                pci_free_consistent(h->pdev,
-                            h->nr_cmds * sizeof(struct CommandList),
-                            h->cmd_pool, h->cmd_pool_dhandle);
-        if (h->errinfo_pool)
-                pci_free_consistent(h->pdev,
-                            h->nr_cmds * sizeof(struct ErrorInfo),
-                            h->errinfo_pool,
-                            h->errinfo_pool_dhandle);
+        hpsa_free_cmd_pool(h);
         free_irq(h->intr[h->intr_mode], h);
 clean2:
 clean1:
diff --git a/drivers/scsi/hpsa.h b/drivers/scsi/hpsa.h
index 621a1530054a..6d8dcd4dd06b 100644
--- a/drivers/scsi/hpsa.h
+++ b/drivers/scsi/hpsa.h
@@ -127,10 +127,12 @@ struct ctlr_info {
 };
 #define HPSA_ABORT_MSG 0
 #define HPSA_DEVICE_RESET_MSG 1
-#define HPSA_BUS_RESET_MSG 2
-#define HPSA_HOST_RESET_MSG 3
+#define HPSA_RESET_TYPE_CONTROLLER 0x00
+#define HPSA_RESET_TYPE_BUS 0x01
+#define HPSA_RESET_TYPE_TARGET 0x03
+#define HPSA_RESET_TYPE_LUN 0x04
 #define HPSA_MSG_SEND_RETRY_LIMIT 10
-#define HPSA_MSG_SEND_RETRY_INTERVAL_MSECS 1000
+#define HPSA_MSG_SEND_RETRY_INTERVAL_MSECS (10000)
 
 /* Maximum time in seconds driver will wait for command completions
  * when polling before giving up.
@@ -155,7 +157,7 @@ struct ctlr_info {
  * HPSA_BOARD_READY_ITERATIONS are derived from those.
  */
 #define HPSA_BOARD_READY_WAIT_SECS (120)
-#define HPSA_BOARD_NOT_READY_WAIT_SECS (10)
+#define HPSA_BOARD_NOT_READY_WAIT_SECS (100)
 #define HPSA_BOARD_READY_POLL_INTERVAL_MSECS (100)
 #define HPSA_BOARD_READY_POLL_INTERVAL \
         ((HPSA_BOARD_READY_POLL_INTERVAL_MSECS * HZ) / 1000)
@@ -212,6 +214,7 @@ static void SA5_submit_command(struct ctlr_info *h,
         dev_dbg(&h->pdev->dev, "Sending %x, tag = %x\n", c->busaddr,
                 c->Header.Tag.lower);
         writel(c->busaddr, h->vaddr + SA5_REQUEST_PORT_OFFSET);
+        (void) readl(h->vaddr + SA5_REQUEST_PORT_OFFSET);
         h->commands_outstanding++;
         if (h->commands_outstanding > h->max_outstanding)
                 h->max_outstanding = h->commands_outstanding;
@@ -227,10 +230,12 @@ static void SA5_intr_mask(struct ctlr_info *h, unsigned long val)
         if (val) { /* Turn interrupts on */
                 h->interrupts_enabled = 1;
                 writel(0, h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
+                (void) readl(h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
         } else { /* Turn them off */
                 h->interrupts_enabled = 0;
                 writel(SA5_INTR_OFF,
                         h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
+                (void) readl(h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
         }
 }
 
@@ -239,10 +244,12 @@ static void SA5_performant_intr_mask(struct ctlr_info *h, unsigned long val)
         if (val) { /* turn on interrupts */
                 h->interrupts_enabled = 1;
                 writel(0, h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
+                (void) readl(h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
         } else {
                 h->interrupts_enabled = 0;
                 writel(SA5_PERF_INTR_OFF,
                         h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
+                (void) readl(h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
         }
 }
 
diff --git a/drivers/scsi/hpsa_cmd.h b/drivers/scsi/hpsa_cmd.h
index 18464900e761..55d741b019db 100644
--- a/drivers/scsi/hpsa_cmd.h
+++ b/drivers/scsi/hpsa_cmd.h
@@ -101,6 +101,7 @@
 #define CFGTBL_ChangeReq        0x00000001l
 #define CFGTBL_AccCmds          0x00000001l
 #define DOORBELL_CTLR_RESET     0x00000004l
+#define DOORBELL_CTLR_RESET2    0x00000020l
 
 #define CFGTBL_Trans_Simple     0x00000002l
 #define CFGTBL_Trans_Performant 0x00000004l
@@ -256,14 +257,6 @@ struct ErrorInfo {
 #define CMD_IOCTL_PEND  0x01
 #define CMD_SCSI        0x03
 
-/* This structure needs to be divisible by 32 for new
- * indexing method and performant mode.
- */
-#define PAD32 32
-#define PAD64DIFF 0
-#define USEEXTRA ((sizeof(void *) - 4)/4)
-#define PADSIZE (PAD32 + PAD64DIFF * USEEXTRA)
-
 #define DIRECT_LOOKUP_SHIFT 5
 #define DIRECT_LOOKUP_BIT 0x10
 #define DIRECT_LOOKUP_MASK (~((1 << DIRECT_LOOKUP_SHIFT) - 1))
@@ -345,6 +338,8 @@ struct CfgTable {
         u8              reserved[0x78 - 0x58];
         u32             misc_fw_support; /* offset 0x78 */
 #define                 MISC_FW_DOORBELL_RESET (0x02)
+#define                 MISC_FW_DOORBELL_RESET2 (0x010)
+        u8              driver_version[32];
 };
 
 #define NUM_BLOCKFETCH_ENTRIES 8
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index 041958453e2a..3d391dc3f11f 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -1849,8 +1849,7 @@ static void ibmvscsi_do_work(struct ibmvscsi_host_data *hostdata)
                 rc = ibmvscsi_ops->reset_crq_queue(&hostdata->queue, hostdata);
                 if (!rc)
                         rc = ibmvscsi_ops->send_crq(hostdata, 0xC001000000000000LL, 0);
-                if (!rc)
-                        rc = vio_enable_interrupts(to_vio_dev(hostdata->dev));
+                vio_enable_interrupts(to_vio_dev(hostdata->dev));
         } else if (hostdata->reenable_crq) {
                 smp_rmb();
                 action = "enable";
diff --git a/drivers/scsi/in2000.c b/drivers/scsi/in2000.c
index 6568aab745a0..92109b126391 100644
--- a/drivers/scsi/in2000.c
+++ b/drivers/scsi/in2000.c
@@ -343,7 +343,7 @@ static int in2000_queuecommand_lck(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
         instance = cmd->device->host;
         hostdata = (struct IN2000_hostdata *) instance->hostdata;
 
-        DB(DB_QUEUE_COMMAND, scmd_printk(KERN_DEBUG, cmd, "Q-%02x-%ld(", cmd->cmnd[0], cmd->serial_number))
+        DB(DB_QUEUE_COMMAND, scmd_printk(KERN_DEBUG, cmd, "Q-%02x(", cmd->cmnd[0]))
 
 /* Set up a few fields in the Scsi_Cmnd structure for our own use:
  *  - host_scribble is the pointer to the next cmd in the input queue
@@ -427,7 +427,7 @@ static int in2000_queuecommand_lck(Scsi_Cmnd * cmd, void (*done) (Scsi_Cmnd *))
 
         in2000_execute(cmd->device->host);
 
-        DB(DB_QUEUE_COMMAND, printk(")Q-%ld ", cmd->serial_number))
+        DB(DB_QUEUE_COMMAND, printk(")Q "))
             return 0;
 }
 
@@ -705,7 +705,7 @@ static void in2000_execute(struct Scsi_Host *instance)
          * to search the input_Q again...
          */
 
-        DB(DB_EXECUTE, printk("%s%ld)EX-2 ", (cmd->SCp.phase) ? "d:" : "", cmd->serial_number))
+        DB(DB_EXECUTE, printk("%s)EX-2 ", (cmd->SCp.phase) ? "d:" : ""))
 
 }
 
@@ -1149,7 +1149,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
         case CSR_XFER_DONE | PHS_COMMAND:
         case CSR_UNEXP | PHS_COMMAND:
         case CSR_SRV_REQ | PHS_COMMAND:
-                DB(DB_INTR, printk("CMND-%02x,%ld", cmd->cmnd[0], cmd->serial_number))
+                DB(DB_INTR, printk("CMND-%02x", cmd->cmnd[0]))
                     transfer_pio(cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR, hostdata);
                 hostdata->state = S_CONNECTED;
                 break;
@@ -1191,7 +1191,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
                 switch (msg) {
 
                 case COMMAND_COMPLETE:
-                        DB(DB_INTR, printk("CCMP-%ld", cmd->serial_number))
+                        DB(DB_INTR, printk("CCMP"))
                             write_3393_cmd(hostdata, WD_CMD_NEGATE_ACK);
                         hostdata->state = S_PRE_CMP_DISC;
                         break;
@@ -1329,7 +1329,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
 
                 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
                 if (phs == 0x60) {
-                        DB(DB_INTR, printk("SX-DONE-%ld", cmd->serial_number))
+                        DB(DB_INTR, printk("SX-DONE"))
                             cmd->SCp.Message = COMMAND_COMPLETE;
                         lun = read_3393(hostdata, WD_TARGET_LUN);
                         DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun))
@@ -1350,7 +1350,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
 
                         in2000_execute(instance);
                 } else {
-                        printk("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE phase!!---", asr, sr, phs, cmd->serial_number);
+                        printk("%02x:%02x:%02x: Unknown SEL_XFER_DONE phase!!---", asr, sr, phs);
                 }
                 break;
 
@@ -1417,7 +1417,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
                         spin_unlock_irqrestore(instance->host_lock, flags);
                         return IRQ_HANDLED;
                 }
-                DB(DB_INTR, printk("UNEXP_DISC-%ld", cmd->serial_number))
+                DB(DB_INTR, printk("UNEXP_DISC"))
                     hostdata->connected = NULL;
                 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
                 hostdata->state = S_UNCONNECTED;
@@ -1442,7 +1442,7 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
  */
 
                 write_3393(hostdata, WD_SOURCE_ID, SRCID_ER);
-                DB(DB_INTR, printk("DISC-%ld", cmd->serial_number))
+                DB(DB_INTR, printk("DISC"))
                     if (cmd == NULL) {
                         printk(" - Already disconnected! ");
                         hostdata->state = S_UNCONNECTED;
@@ -1575,7 +1575,6 @@ static irqreturn_t in2000_intr(int irqnum, void *dev_id)
                 } else
                         hostdata->state = S_CONNECTED;
 
-                DB(DB_INTR, printk("-%ld", cmd->serial_number))
                     break;
 
         default:
@@ -1704,7 +1703,7 @@ static int __in2000_abort(Scsi_Cmnd * cmd)
                                 prev->host_scribble = cmd->host_scribble;
                         cmd->host_scribble = NULL;
                         cmd->result = DID_ABORT << 16;
-                        printk(KERN_WARNING "scsi%d: Abort - removing command %ld from input_Q. ", instance->host_no, cmd->serial_number);
+                        printk(KERN_WARNING "scsi%d: Abort - removing command from input_Q. ", instance->host_no);
                         cmd->scsi_done(cmd);
                         return SUCCESS;
                 }
@@ -1725,7 +1724,7 @@ static int __in2000_abort(Scsi_Cmnd * cmd)
 
         if (hostdata->connected == cmd) {
 
-                printk(KERN_WARNING "scsi%d: Aborting connected command %ld - ", instance->host_no, cmd->serial_number);
+                printk(KERN_WARNING "scsi%d: Aborting connected command - ", instance->host_no);
 
                 printk("sending wd33c93 ABORT command - ");
                 write_3393(hostdata, WD_CONTROL, CTRL_IDI | CTRL_EDI | CTRL_POLLED);
@@ -2270,7 +2269,7 @@ static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start,
                 strcat(bp, "\nconnected:     ");
                 if (hd->connected) {
                         cmd = (Scsi_Cmnd *) hd->connected;
-                        sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+                        sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
                         strcat(bp, tbuf);
                 }
         }
@@ -2278,7 +2277,7 @@ static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start,
                 strcat(bp, "\ninput_Q:       ");
                 cmd = (Scsi_Cmnd *) hd->input_Q;
                 while (cmd) {
-                        sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+                        sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
                         strcat(bp, tbuf);
                         cmd = (Scsi_Cmnd *) cmd->host_scribble;
                 }
@@ -2287,7 +2286,7 @@ static int in2000_proc_info(struct Scsi_Host *instance, char *buf, char **start,
                 strcat(bp, "\ndisconnected_Q:");
                 cmd = (Scsi_Cmnd *) hd->disconnected_Q;
                 while (cmd) {
-                        sprintf(tbuf, " %ld-%d:%d(%02x)", cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+                        sprintf(tbuf, " %d:%d(%02x)", cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
                         strcat(bp, tbuf);
                         cmd = (Scsi_Cmnd *) cmd->host_scribble;
                 }
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 0621238fac4a..12868ca46110 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -60,6 +60,7 @@
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
+#include <linux/vmalloc.h>
 #include <linux/ioport.h>
 #include <linux/delay.h>
 #include <linux/pci.h>
@@ -2717,13 +2718,18 @@ static int ipr_sdt_copy(struct ipr_ioa_cfg *ioa_cfg,
                         unsigned long pci_address, u32 length)
 {
         int bytes_copied = 0;
-        int cur_len, rc, rem_len, rem_page_len;
+        int cur_len, rc, rem_len, rem_page_len, max_dump_size;
         __be32 *page;
         unsigned long lock_flags = 0;
         struct ipr_ioa_dump *ioa_dump = &ioa_cfg->dump->ioa_dump;
 
+        if (ioa_cfg->sis64)
+                max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
+        else
+                max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
+
         while (bytes_copied < length &&
-               (ioa_dump->hdr.len + bytes_copied) < IPR_MAX_IOA_DUMP_SIZE) {
+               (ioa_dump->hdr.len + bytes_copied) < max_dump_size) {
                 if (ioa_dump->page_offset >= PAGE_SIZE ||
                     ioa_dump->page_offset == 0) {
                         page = (__be32 *)__get_free_page(GFP_ATOMIC);
@@ -2885,8 +2891,8 @@ static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
         unsigned long lock_flags = 0;
         struct ipr_driver_dump *driver_dump = &dump->driver_dump;
         struct ipr_ioa_dump *ioa_dump = &dump->ioa_dump;
-        u32 num_entries, start_off, end_off;
-        u32 bytes_to_copy, bytes_copied, rc;
+        u32 num_entries, max_num_entries, start_off, end_off;
+        u32 max_dump_size, bytes_to_copy, bytes_copied, rc;
         struct ipr_sdt *sdt;
         int valid = 1;
         int i;
@@ -2947,8 +2953,18 @@ static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
          on entries in this table */
         sdt = &ioa_dump->sdt;
 
+        if (ioa_cfg->sis64) {
+                max_num_entries = IPR_FMT3_NUM_SDT_ENTRIES;
+                max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
+        } else {
+                max_num_entries = IPR_FMT2_NUM_SDT_ENTRIES;
+                max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
+        }
+
+        bytes_to_copy = offsetof(struct ipr_sdt, entry) +
+                        (max_num_entries * sizeof(struct ipr_sdt_entry));
         rc = ipr_get_ldump_data_section(ioa_cfg, start_addr, (__be32 *)sdt,
-                                        sizeof(struct ipr_sdt) / sizeof(__be32));
+                                        bytes_to_copy / sizeof(__be32));
 
         /* Smart Dump table is ready to use and the first entry is valid */
         if (rc || ((be32_to_cpu(sdt->hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
@@ -2964,13 +2980,20 @@ static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
 
         num_entries = be32_to_cpu(sdt->hdr.num_entries_used);
 
-        if (num_entries > IPR_NUM_SDT_ENTRIES)
-                num_entries = IPR_NUM_SDT_ENTRIES;
+        if (num_entries > max_num_entries)
+                num_entries = max_num_entries;
+
+        /* Update dump length to the actual data to be copied */
+        dump->driver_dump.hdr.len += sizeof(struct ipr_sdt_header);
+        if (ioa_cfg->sis64)
+                dump->driver_dump.hdr.len += num_entries * sizeof(struct ipr_sdt_entry);
+        else
+                dump->driver_dump.hdr.len += max_num_entries * sizeof(struct ipr_sdt_entry);
 
         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
 
         for (i = 0; i < num_entries; i++) {
-                if (ioa_dump->hdr.len > IPR_MAX_IOA_DUMP_SIZE) {
+                if (ioa_dump->hdr.len > max_dump_size) {
                         driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
                         break;
                 }
@@ -2989,7 +3012,7 @@ static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
                                         valid = 0;
                         }
                         if (valid) {
-                                if (bytes_to_copy > IPR_MAX_IOA_DUMP_SIZE) {
+                                if (bytes_to_copy > max_dump_size) {
                                         sdt->entry[i].flags &= ~IPR_SDT_VALID_ENTRY;
                                         continue;
                                 }
@@ -3044,6 +3067,7 @@ static void ipr_release_dump(struct kref *kref)
         for (i = 0; i < dump->ioa_dump.next_page_index; i++)
                 free_page((unsigned long) dump->ioa_dump.ioa_data[i]);
 
+        vfree(dump->ioa_dump.ioa_data);
         kfree(dump);
         LEAVE;
 }
@@ -3835,7 +3859,7 @@ static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
         struct ipr_dump *dump;
         unsigned long lock_flags = 0;
         char *src;
-        int len;
+        int len, sdt_end;
         size_t rc = count;
 
         if (!capable(CAP_SYS_ADMIN))
@@ -3875,9 +3899,17 @@ static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
 
         off -= sizeof(dump->driver_dump);
 
-        if (count && off < offsetof(struct ipr_ioa_dump, ioa_data)) {
-                if (off + count > offsetof(struct ipr_ioa_dump, ioa_data))
-                        len = offsetof(struct ipr_ioa_dump, ioa_data) - off;
+        if (ioa_cfg->sis64)
+                sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
+                          (be32_to_cpu(dump->ioa_dump.sdt.hdr.num_entries_used) *
+                           sizeof(struct ipr_sdt_entry));
+        else
+                sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
+                          (IPR_FMT2_NUM_SDT_ENTRIES * sizeof(struct ipr_sdt_entry));
+
+        if (count && off < sdt_end) {
+                if (off + count > sdt_end)
+                        len = sdt_end - off;
                 else
                         len = count;
                 src = (u8 *)&dump->ioa_dump + off;
@@ -3887,7 +3919,7 @@ static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
                 count -= len;
         }
 
-        off -= offsetof(struct ipr_ioa_dump, ioa_data);
+        off -= sdt_end;
 
         while (count) {
                 if ((off & PAGE_MASK) != ((off + count) & PAGE_MASK))
@@ -3916,6 +3948,7 @@ static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
 static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
 {
         struct ipr_dump *dump;
+        __be32 **ioa_data;
         unsigned long lock_flags = 0;
 
         dump = kzalloc(sizeof(struct ipr_dump), GFP_KERNEL);
@@ -3925,6 +3958,19 @@ static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
                 return -ENOMEM;
         }
 
+        if (ioa_cfg->sis64)
+                ioa_data = vmalloc(IPR_FMT3_MAX_NUM_DUMP_PAGES * sizeof(__be32 *));
+        else
+                ioa_data = vmalloc(IPR_FMT2_MAX_NUM_DUMP_PAGES * sizeof(__be32 *));
+
+        if (!ioa_data) {
+                ipr_err("Dump memory allocation failed\n");
+                kfree(dump);
+                return -ENOMEM;
+        }
+
+        dump->ioa_dump.ioa_data = ioa_data;
+
         kref_init(&dump->kref);
         dump->ioa_cfg = ioa_cfg;
 
@@ -3932,6 +3978,7 @@ static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
 
         if (INACTIVE != ioa_cfg->sdt_state) {
                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+                vfree(dump->ioa_dump.ioa_data);
                 kfree(dump);
                 return 0;
         }
@@ -4953,9 +5000,35 @@ static int ipr_eh_abort(struct scsi_cmnd * scsi_cmd)
  *      IRQ_NONE / IRQ_HANDLED
  **/
 static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
-                                              volatile u32 int_reg)
+                                              u32 int_reg)
 {
         irqreturn_t rc = IRQ_HANDLED;
+        u32 int_mask_reg;
+
+        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
+        int_reg &= ~int_mask_reg;
+
+        /* If an interrupt on the adapter did not occur, ignore it.
+         * Or in the case of SIS 64, check for a stage change interrupt.
+         */
+        if ((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0) {
+                if (ioa_cfg->sis64) {
+                        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
+                        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
+                        if (int_reg & IPR_PCII_IPL_STAGE_CHANGE) {
+
+                                /* clear stage change */
+                                writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_reg);
+                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
+                                list_del(&ioa_cfg->reset_cmd->queue);
+                                del_timer(&ioa_cfg->reset_cmd->timer);
+                                ipr_reset_ioa_job(ioa_cfg->reset_cmd);
+                                return IRQ_HANDLED;
+                        }
+                }
+
+                return IRQ_NONE;
+        }
 
         if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
                 /* Mask the interrupt */
@@ -4968,6 +5041,13 @@ static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
                 list_del(&ioa_cfg->reset_cmd->queue);
                 del_timer(&ioa_cfg->reset_cmd->timer);
                 ipr_reset_ioa_job(ioa_cfg->reset_cmd);
+        } else if ((int_reg & IPR_PCII_HRRQ_UPDATED) == int_reg) {
+                if (ipr_debug && printk_ratelimit())
+                        dev_err(&ioa_cfg->pdev->dev,
+                                "Spurious interrupt detected. 0x%08X\n", int_reg);
+                writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg32);
+                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
+                return IRQ_NONE;
         } else {
                 if (int_reg & IPR_PCII_IOA_UNIT_CHECKED)
                         ioa_cfg->ioa_unit_checked = 1;
@@ -5016,10 +5096,11 @@ static irqreturn_t ipr_isr(int irq, void *devp)
 {
         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)devp;
         unsigned long lock_flags = 0;
-        volatile u32 int_reg, int_mask_reg;
+        u32 int_reg = 0;
         u32 ioasc;
         u16 cmd_index;
         int num_hrrq = 0;
+        int irq_none = 0;
         struct ipr_cmnd *ipr_cmd;
         irqreturn_t rc = IRQ_NONE;
 
@@ -5031,33 +5112,6 @@ static irqreturn_t ipr_isr(int irq, void *devp)
                 return IRQ_NONE;
         }
 
-        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
-        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32) & ~int_mask_reg;
-
-        /* If an interrupt on the adapter did not occur, ignore it.
-         * Or in the case of SIS 64, check for a stage change interrupt.
-         */
-        if (unlikely((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0)) {
-                if (ioa_cfg->sis64) {
-                        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
-                        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
-                        if (int_reg & IPR_PCII_IPL_STAGE_CHANGE) {
-
-                                /* clear stage change */
-                                writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_reg);
-                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
-                                list_del(&ioa_cfg->reset_cmd->queue);
-                                del_timer(&ioa_cfg->reset_cmd->timer);
-                                ipr_reset_ioa_job(ioa_cfg->reset_cmd);
-                                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-                                return IRQ_HANDLED;
-                        }
-                }
-
-                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-                return IRQ_NONE;
-        }
-
         while (1) {
                 ipr_cmd = NULL;
 
@@ -5097,7 +5151,7 @@ static irqreturn_t ipr_isr(int irq, void *devp)
                         /* Clear the PCI interrupt */
                         do {
                                 writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg32);
-                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32) & ~int_mask_reg;
+                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
                         } while (int_reg & IPR_PCII_HRRQ_UPDATED &&
                                         num_hrrq++ < IPR_MAX_HRRQ_RETRIES);
 
@@ -5107,6 +5161,9 @@ static irqreturn_t ipr_isr(int irq, void *devp)
                                 return IRQ_HANDLED;
                         }
 
+                } else if (rc == IRQ_NONE && irq_none == 0) {
+                        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
+                        irq_none++;
                 } else
                         break;
         }
@@ -5143,7 +5200,8 @@ static int ipr_build_ioadl64(struct ipr_ioa_cfg *ioa_cfg,
 
         nseg = scsi_dma_map(scsi_cmd);
         if (nseg < 0) {
-                dev_err(&ioa_cfg->pdev->dev, "pci_map_sg failed!\n");
+                if (printk_ratelimit())
+                        dev_err(&ioa_cfg->pdev->dev, "pci_map_sg failed!\n");
                 return -1;
         }
 
@@ -5773,7 +5831,8 @@ static int ipr_queuecommand_lck(struct scsi_cmnd *scsi_cmd,
                 }
 
                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
-                ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST;
+                if (ipr_is_gscsi(res))
+                        ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST;
                 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_ALIGNED_BFR;
                 ioarcb->cmd_pkt.flags_lo |= ipr_get_task_attributes(scsi_cmd);
         }
@@ -7516,7 +7575,7 @@ static int ipr_reset_get_unit_check_job(struct ipr_cmnd *ipr_cmd)
 static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
-        volatile u32 int_reg;
+        u32 int_reg;
 
         ENTER;
         ioa_cfg->pdev->state_saved = true;
@@ -7555,7 +7614,10 @@ static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
                 ipr_cmd->job_step = ipr_reset_enable_ioa;
 
                 if (GET_DUMP == ioa_cfg->sdt_state) {
-                        ipr_reset_start_timer(ipr_cmd, IPR_DUMP_TIMEOUT);
+                        if (ioa_cfg->sis64)
+                                ipr_reset_start_timer(ipr_cmd, IPR_SIS64_DUMP_TIMEOUT);
+                        else
+                                ipr_reset_start_timer(ipr_cmd, IPR_SIS32_DUMP_TIMEOUT);
                         ipr_cmd->job_step = ipr_reset_wait_for_dump;
                         schedule_work(&ioa_cfg->work_q);
                         return IPR_RC_JOB_RETURN;
diff --git a/drivers/scsi/ipr.h b/drivers/scsi/ipr.h
index 13f425fb8851..f93f8637c5a1 100644
--- a/drivers/scsi/ipr.h
+++ b/drivers/scsi/ipr.h
@@ -38,8 +38,8 @@
 /*
  * Literals
  */
-#define IPR_DRIVER_VERSION "2.5.1"
-#define IPR_DRIVER_DATE "(August 10, 2010)"
+#define IPR_DRIVER_VERSION "2.5.2"
+#define IPR_DRIVER_DATE "(April 27, 2011)"
 
 /*
  * IPR_MAX_CMD_PER_LUN: This defines the maximum number of outstanding
@@ -217,7 +217,8 @@
 #define IPR_CHECK_FOR_RESET_TIMEOUT             (HZ / 10)
 #define IPR_WAIT_FOR_BIST_TIMEOUT               (2 * HZ)
 #define IPR_PCI_RESET_TIMEOUT                   (HZ / 2)
-#define IPR_DUMP_TIMEOUT                        (15 * HZ)
+#define IPR_SIS32_DUMP_TIMEOUT                  (15 * HZ)
+#define IPR_SIS64_DUMP_TIMEOUT                  (40 * HZ)
 #define IPR_DUMP_DELAY_SECONDS                  4
 #define IPR_DUMP_DELAY_TIMEOUT                  (IPR_DUMP_DELAY_SECONDS * HZ)
 
@@ -285,9 +286,12 @@ IPR_PCII_NO_HOST_RRQ | IPR_PCII_IOARRIN_LOST | IPR_PCII_MMIO_ERROR)
 /*
  * Dump literals
  */
-#define IPR_MAX_IOA_DUMP_SIZE                           (4 * 1024 * 1024)
-#define IPR_NUM_SDT_ENTRIES                             511
-#define IPR_MAX_NUM_DUMP_PAGES  ((IPR_MAX_IOA_DUMP_SIZE / PAGE_SIZE) + 1)
+#define IPR_FMT2_MAX_IOA_DUMP_SIZE                      (4 * 1024 * 1024)
+#define IPR_FMT3_MAX_IOA_DUMP_SIZE                      (32 * 1024 * 1024)
+#define IPR_FMT2_NUM_SDT_ENTRIES                        511
+#define IPR_FMT3_NUM_SDT_ENTRIES                        0xFFF
+#define IPR_FMT2_MAX_NUM_DUMP_PAGES     ((IPR_FMT2_MAX_IOA_DUMP_SIZE / PAGE_SIZE) + 1)
+#define IPR_FMT3_MAX_NUM_DUMP_PAGES     ((IPR_FMT3_MAX_IOA_DUMP_SIZE / PAGE_SIZE) + 1)
 
 /*
  * Misc literals
@@ -474,7 +478,7 @@ struct ipr_cmd_pkt {
 
         u8 flags_lo;
 #define IPR_FLAGS_LO_ALIGNED_BFR                0x20
-#define IPR_FLAGS_LO_DELAY_AFTER_RST    0x10
+#define IPR_FLAGS_LO_DELAY_AFTER_RST            0x10
 #define IPR_FLAGS_LO_UNTAGGED_TASK              0x00
 #define IPR_FLAGS_LO_SIMPLE_TASK                0x02
 #define IPR_FLAGS_LO_ORDERED_TASK               0x04
@@ -1164,7 +1168,7 @@ struct ipr_sdt_header {
 
 struct ipr_sdt {
         struct ipr_sdt_header hdr;
-        struct ipr_sdt_entry entry[IPR_NUM_SDT_ENTRIES];
+        struct ipr_sdt_entry entry[IPR_FMT3_NUM_SDT_ENTRIES];
 }__attribute__((packed, aligned (4)));
 
 struct ipr_uc_sdt {
@@ -1608,7 +1612,7 @@ struct ipr_driver_dump {
 struct ipr_ioa_dump {
         struct ipr_dump_entry_header hdr;
         struct ipr_sdt sdt;
-        __be32 *ioa_data[IPR_MAX_NUM_DUMP_PAGES];
+        __be32 **ioa_data;
         u32 reserved;
         u32 next_page_index;
         u32 page_offset;
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index 5b799a37ad09..2a3a4720a771 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -57,9 +57,6 @@ static struct kmem_cache *scsi_pkt_cachep;
 #define FC_SRB_READ             (1 << 1)
 #define FC_SRB_WRITE            (1 << 0)
 
-/* constant added to e_d_tov timeout to get rec_tov value */
-#define REC_TOV_CONST           1
-
 /*
  * The SCp.ptr should be tested and set under the scsi_pkt_queue lock
  */
@@ -248,7 +245,7 @@ static inline void fc_fcp_unlock_pkt(struct fc_fcp_pkt *fsp)
 /**
  * fc_fcp_timer_set() - Start a timer for a fcp_pkt
  * @fsp:   The FCP packet to start a timer for
- * @delay: The timeout period for the timer
+ * @delay: The timeout period in jiffies
  */
 static void fc_fcp_timer_set(struct fc_fcp_pkt *fsp, unsigned long delay)
 {
@@ -335,22 +332,23 @@ static void fc_fcp_ddp_done(struct fc_fcp_pkt *fsp)
 /**
  * fc_fcp_can_queue_ramp_up() - increases can_queue
  * @lport: lport to ramp up can_queue
- *
- * Locking notes: Called with Scsi_Host lock held
  */
 static void fc_fcp_can_queue_ramp_up(struct fc_lport *lport)
 {
         struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
+        unsigned long flags;
         int can_queue;
 
+        spin_lock_irqsave(lport->host->host_lock, flags);
+
         if (si->last_can_queue_ramp_up_time &&
             (time_before(jiffies, si->last_can_queue_ramp_up_time +
                          FC_CAN_QUEUE_PERIOD)))
-                return;
+                goto unlock;
 
         if (time_before(jiffies, si->last_can_queue_ramp_down_time +
                         FC_CAN_QUEUE_PERIOD))
-                return;
+                goto unlock;
 
         si->last_can_queue_ramp_up_time = jiffies;
 
@@ -362,6 +360,9 @@ static void fc_fcp_can_queue_ramp_up(struct fc_lport *lport)
         lport->host->can_queue = can_queue;
         shost_printk(KERN_ERR, lport->host, "libfc: increased "
                      "can_queue to %d.\n", can_queue);
+
+unlock:
+        spin_unlock_irqrestore(lport->host->host_lock, flags);
 }
 
 /**
@@ -373,18 +374,19 @@ static void fc_fcp_can_queue_ramp_up(struct fc_lport *lport)
  * commands complete or timeout, then try again with a reduced
  * can_queue. Eventually we will hit the point where we run
  * on all reserved structs.
- *
- * Locking notes: Called with Scsi_Host lock held
  */
 static void fc_fcp_can_queue_ramp_down(struct fc_lport *lport)
 {
         struct fc_fcp_internal *si = fc_get_scsi_internal(lport);
+        unsigned long flags;
         int can_queue;
 
+        spin_lock_irqsave(lport->host->host_lock, flags);
+
         if (si->last_can_queue_ramp_down_time &&
             (time_before(jiffies, si->last_can_queue_ramp_down_time +
                          FC_CAN_QUEUE_PERIOD)))
-                return;
+                goto unlock;
 
         si->last_can_queue_ramp_down_time = jiffies;
 
@@ -395,6 +397,9 @@ static void fc_fcp_can_queue_ramp_down(struct fc_lport *lport)
         lport->host->can_queue = can_queue;
         shost_printk(KERN_ERR, lport->host, "libfc: Could not allocate frame.\n"
                      "Reducing can_queue to %d.\n", can_queue);
+
+unlock:
+        spin_unlock_irqrestore(lport->host->host_lock, flags);
 }
 
 /*
@@ -409,16 +414,13 @@ static inline struct fc_frame *fc_fcp_frame_alloc(struct fc_lport *lport,
                                                   size_t len)
 {
         struct fc_frame *fp;
-        unsigned long flags;
 
         fp = fc_frame_alloc(lport, len);
         if (likely(fp))
                 return fp;
 
         /* error case */
-        spin_lock_irqsave(lport->host->host_lock, flags);
         fc_fcp_can_queue_ramp_down(lport);
-        spin_unlock_irqrestore(lport->host->host_lock, flags);
         return NULL;
 }
 
@@ -1093,16 +1095,14 @@ static int fc_fcp_pkt_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp)
 /**
  * get_fsp_rec_tov() - Helper function to get REC_TOV
  * @fsp: the FCP packet
+ *
+ * Returns rec tov in jiffies as rpriv->e_d_tov + 1 second
  */
 static inline unsigned int get_fsp_rec_tov(struct fc_fcp_pkt *fsp)
 {
-        struct fc_rport *rport;
-        struct fc_rport_libfc_priv *rpriv;
-
-        rport = fsp->rport;
-        rpriv = rport->dd_data;
+        struct fc_rport_libfc_priv *rpriv = fsp->rport->dd_data;
 
-        return rpriv->e_d_tov + REC_TOV_CONST;
+        return msecs_to_jiffies(rpriv->e_d_tov) + HZ;
 }
 
 /**
@@ -1122,7 +1122,6 @@ static int fc_fcp_cmd_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
         struct fc_rport_libfc_priv *rpriv;
         const size_t len = sizeof(fsp->cdb_cmd);
         int rc = 0;
-        unsigned int rec_tov;
 
         if (fc_fcp_lock_pkt(fsp))
                 return 0;
@@ -1153,12 +1152,9 @@ static int fc_fcp_cmd_send(struct fc_lport *lport, struct fc_fcp_pkt *fsp,
         fsp->seq_ptr = seq;
         fc_fcp_pkt_hold(fsp);   /* hold for fc_fcp_pkt_destroy */
 
-        rec_tov = get_fsp_rec_tov(fsp);
-
         setup_timer(&fsp->timer, fc_fcp_timeout, (unsigned long)fsp);
-
         if (rpriv->flags & FC_RP_FLAGS_REC_SUPPORTED)
-                fc_fcp_timer_set(fsp, rec_tov);
+                fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
 
 unlock:
         fc_fcp_unlock_pkt(fsp);
@@ -1235,16 +1231,14 @@ static void fc_lun_reset_send(unsigned long data)
 {
         struct fc_fcp_pkt *fsp = (struct fc_fcp_pkt *)data;
         struct fc_lport *lport = fsp->lp;
-        unsigned int rec_tov;
 
         if (lport->tt.fcp_cmd_send(lport, fsp, fc_tm_done)) {
                 if (fsp->recov_retry++ >= FC_MAX_RECOV_RETRY)
                         return;
                 if (fc_fcp_lock_pkt(fsp))
                         return;
-                rec_tov = get_fsp_rec_tov(fsp);
                 setup_timer(&fsp->timer, fc_lun_reset_send, (unsigned long)fsp);
-                fc_fcp_timer_set(fsp, rec_tov);
+                fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
                 fc_fcp_unlock_pkt(fsp);
         }
 }
@@ -1536,12 +1530,11 @@ static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
                         }
                         fc_fcp_srr(fsp, r_ctl, offset);
                 } else if (e_stat & ESB_ST_SEQ_INIT) {
-                        unsigned int rec_tov = get_fsp_rec_tov(fsp);
                         /*
                          * The remote port has the initiative, so just
                          * keep waiting for it to complete.
                          */
-                        fc_fcp_timer_set(fsp, rec_tov);
+                        fc_fcp_timer_set(fsp,  get_fsp_rec_tov(fsp));
                 } else {
 
                         /*
@@ -1705,7 +1698,6 @@ static void fc_fcp_srr_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
 {
         struct fc_fcp_pkt *fsp = arg;
         struct fc_frame_header *fh;
-        unsigned int rec_tov;
 
         if (IS_ERR(fp)) {
                 fc_fcp_srr_error(fsp, fp);
@@ -1732,8 +1724,7 @@ static void fc_fcp_srr_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
         switch (fc_frame_payload_op(fp)) {
         case ELS_LS_ACC:
                 fsp->recov_retry = 0;
-                rec_tov = get_fsp_rec_tov(fsp);
-                fc_fcp_timer_set(fsp, rec_tov);
+                fc_fcp_timer_set(fsp, get_fsp_rec_tov(fsp));
                 break;
         case ELS_LS_RJT:
         default:
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index 906bbcad0e2d..389ab80aef0a 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -1590,7 +1590,6 @@ void fc_lport_enter_flogi(struct fc_lport *lport)
  */
 int fc_lport_config(struct fc_lport *lport)
 {
-        INIT_LIST_HEAD(&lport->ema_list);
         INIT_DELAYED_WORK(&lport->retry_work, fc_lport_timeout);
         mutex_init(&lport->lp_mutex);
 
diff --git a/drivers/scsi/lpfc/lpfc.h b/drivers/scsi/lpfc/lpfc.h
index 60e98a62f308..02d53d89534f 100644
--- a/drivers/scsi/lpfc/lpfc.h
+++ b/drivers/scsi/lpfc/lpfc.h
@@ -805,6 +805,8 @@ struct lpfc_hba {
         struct dentry *idiag_root;
         struct dentry *idiag_pci_cfg;
         struct dentry *idiag_que_info;
+        struct dentry *idiag_que_acc;
+        struct dentry *idiag_drb_acc;
 #endif
 
         /* Used for deferred freeing of ELS data buffers */
diff --git a/drivers/scsi/lpfc/lpfc_bsg.c b/drivers/scsi/lpfc/lpfc_bsg.c
index 77b2871d96b7..37e2a1272f86 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.c
+++ b/drivers/scsi/lpfc/lpfc_bsg.c
@@ -2426,6 +2426,7 @@ lpfc_bsg_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
 {
         struct bsg_job_data *dd_data;
         struct fc_bsg_job *job;
+        struct lpfc_mbx_nembed_cmd *nembed_sge;
         uint32_t size;
         unsigned long flags;
         uint8_t *to;
@@ -2469,9 +2470,8 @@ lpfc_bsg_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
                         memcpy(to, from, size);
                 } else if ((phba->sli_rev == LPFC_SLI_REV4) &&
                         (pmboxq->u.mb.mbxCommand == MBX_SLI4_CONFIG)) {
-                        struct lpfc_mbx_nembed_cmd *nembed_sge =
-                                (struct lpfc_mbx_nembed_cmd *)
-                                &pmboxq->u.mb.un.varWords[0];
+                        nembed_sge = (struct lpfc_mbx_nembed_cmd *)
+                                        &pmboxq->u.mb.un.varWords[0];
 
                         from = (uint8_t *)dd_data->context_un.mbox.dmp->dma.
                                                 virt;
@@ -2496,16 +2496,18 @@ lpfc_bsg_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
                                         job->reply_payload.sg_cnt,
                                         from, size);
                 job->reply->result = 0;
-
+                /* need to hold the lock until we set job->dd_data to NULL
+                 * to hold off the timeout handler returning to the mid-layer
+                 * while we are still processing the job.
+                 */
                 job->dd_data = NULL;
+                dd_data->context_un.mbox.set_job = NULL;
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
                 job->job_done(job);
+        } else {
+                dd_data->context_un.mbox.set_job = NULL;
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
         }
-        dd_data->context_un.mbox.set_job = NULL;
-        /* need to hold the lock until we call job done to hold off
-         * the timeout handler returning to the midlayer while
-         * we are stillprocessing the job
-         */
-        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
 
         kfree(dd_data->context_un.mbox.mb);
         mempool_free(dd_data->context_un.mbox.pmboxq, phba->mbox_mem_pool);
@@ -2644,6 +2646,11 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
         struct ulp_bde64 *rxbpl = NULL;
         struct dfc_mbox_req *mbox_req = (struct dfc_mbox_req *)
                 job->request->rqst_data.h_vendor.vendor_cmd;
+        struct READ_EVENT_LOG_VAR *rdEventLog;
+        uint32_t transmit_length, receive_length, mode;
+        struct lpfc_mbx_nembed_cmd *nembed_sge;
+        struct mbox_header *header;
+        struct ulp_bde64 *bde;
         uint8_t *ext = NULL;
         int rc = 0;
         uint8_t *from;
@@ -2651,9 +2658,16 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
         /* in case no data is transferred */
         job->reply->reply_payload_rcv_len = 0;
 
+        /* sanity check to protect driver */
+        if (job->reply_payload.payload_len > BSG_MBOX_SIZE ||
+            job->request_payload.payload_len > BSG_MBOX_SIZE) {
+                rc = -ERANGE;
+                goto job_done;
+        }
+
         /* check if requested extended data lengths are valid */
-        if ((mbox_req->inExtWLen > MAILBOX_EXT_SIZE) ||
-                (mbox_req->outExtWLen > MAILBOX_EXT_SIZE)) {
+        if ((mbox_req->inExtWLen > BSG_MBOX_SIZE/sizeof(uint32_t)) ||
+            (mbox_req->outExtWLen > BSG_MBOX_SIZE/sizeof(uint32_t))) {
                 rc = -ERANGE;
                 goto job_done;
         }
@@ -2744,8 +2758,8 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
          * use ours
          */
         if (pmb->mbxCommand == MBX_RUN_BIU_DIAG64) {
-                uint32_t transmit_length = pmb->un.varWords[1];
-                uint32_t receive_length = pmb->un.varWords[4];
+                transmit_length = pmb->un.varWords[1];
+                receive_length = pmb->un.varWords[4];
                 /* transmit length cannot be greater than receive length or
                  * mailbox extension size
                  */
@@ -2795,10 +2809,9 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                 from += sizeof(MAILBOX_t);
                 memcpy((uint8_t *)dmp->dma.virt, from, transmit_length);
         } else if (pmb->mbxCommand == MBX_READ_EVENT_LOG) {
-                struct READ_EVENT_LOG_VAR *rdEventLog =
-                        &pmb->un.varRdEventLog ;
-                uint32_t receive_length = rdEventLog->rcv_bde64.tus.f.bdeSize;
-                uint32_t mode =  bf_get(lpfc_event_log, rdEventLog);
+                rdEventLog = &pmb->un.varRdEventLog;
+                receive_length = rdEventLog->rcv_bde64.tus.f.bdeSize;
+                mode = bf_get(lpfc_event_log, rdEventLog);
 
                 /* receive length cannot be greater than mailbox
                  * extension size
@@ -2843,7 +2856,7 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                         /* rebuild the command for sli4 using our own buffers
                         * like we do for biu diags
                         */
-                        uint32_t receive_length = pmb->un.varWords[2];
+                        receive_length = pmb->un.varWords[2];
                         /* receive length cannot be greater than mailbox
                          * extension size
                          */
@@ -2879,8 +2892,7 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                         pmb->un.varWords[4] = putPaddrHigh(dmp->dma.phys);
                 } else if ((pmb->mbxCommand == MBX_UPDATE_CFG) &&
                         pmb->un.varUpdateCfg.co) {
-                        struct ulp_bde64 *bde =
-                                (struct ulp_bde64 *)&pmb->un.varWords[4];
+                        bde = (struct ulp_bde64 *)&pmb->un.varWords[4];
 
                         /* bde size cannot be greater than mailbox ext size */
                         if (bde->tus.f.bdeSize > MAILBOX_EXT_SIZE) {
@@ -2921,10 +2933,6 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                         memcpy((uint8_t *)dmp->dma.virt, from,
                                 bde->tus.f.bdeSize);
                 } else if (pmb->mbxCommand == MBX_SLI4_CONFIG) {
-                        struct lpfc_mbx_nembed_cmd *nembed_sge;
-                        struct mbox_header *header;
-                        uint32_t receive_length;
-
                         /* rebuild the command for sli4 using our own buffers
                         * like we do for biu diags
                         */
@@ -3386,6 +3394,7 @@ no_dd_data:
         job->dd_data = NULL;
         return rc;
 }
+
 /**
  * lpfc_bsg_hst_vendor - process a vendor-specific fc_bsg_job
  * @job: fc_bsg_job to handle
diff --git a/drivers/scsi/lpfc/lpfc_bsg.h b/drivers/scsi/lpfc/lpfc_bsg.h
index a2c33e7c9152..b542aca6f5ae 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.h
+++ b/drivers/scsi/lpfc/lpfc_bsg.h
@@ -109,3 +109,133 @@ struct menlo_response {
         uint32_t xri; /* return the xri of the iocb exchange */
 };
 
+/*
+ * macros and data structures for handling sli-config mailbox command
+ * pass-through support, this header file is shared between user and
+ * kernel spaces, note the set of macros are duplicates from lpfc_hw4.h,
+ * with macro names prefixed with bsg_, as the macros defined in
+ * lpfc_hw4.h are not accessible from user space.
+ */
+
+/* Macros to deal with bit fields. Each bit field must have 3 #defines
+ * associated with it (_SHIFT, _MASK, and _WORD).
+ * EG. For a bit field that is in the 7th bit of the "field4" field of a
+ * structure and is 2 bits in size the following #defines must exist:
+ *      struct temp {
+ *              uint32_t        field1;
+ *              uint32_t        field2;
+ *              uint32_t        field3;
+ *              uint32_t        field4;
+ *      #define example_bit_field_SHIFT         7
+ *      #define example_bit_field_MASK          0x03
+ *      #define example_bit_field_WORD          field4
+ *              uint32_t        field5;
+ *      };
+ * Then the macros below may be used to get or set the value of that field.
+ * EG. To get the value of the bit field from the above example:
+ *      struct temp t1;
+ *      value = bsg_bf_get(example_bit_field, &t1);
+ * And then to set that bit field:
+ *      bsg_bf_set(example_bit_field, &t1, 2);
+ * Or clear that bit field:
+ *      bsg_bf_set(example_bit_field, &t1, 0);
+ */
+#define bsg_bf_get_le32(name, ptr) \
+        ((le32_to_cpu((ptr)->name##_WORD) >> name##_SHIFT) & name##_MASK)
+#define bsg_bf_get(name, ptr) \
+        (((ptr)->name##_WORD >> name##_SHIFT) & name##_MASK)
+#define bsg_bf_set_le32(name, ptr, value) \
+        ((ptr)->name##_WORD = cpu_to_le32(((((value) & \
+        name##_MASK) << name##_SHIFT) | (le32_to_cpu((ptr)->name##_WORD) & \
+        ~(name##_MASK << name##_SHIFT)))))
+#define bsg_bf_set(name, ptr, value) \
+        ((ptr)->name##_WORD = ((((value) & name##_MASK) << name##_SHIFT) | \
+        ((ptr)->name##_WORD & ~(name##_MASK << name##_SHIFT))))
+
+/*
+ * The sli_config structure specified here is based on the following
+ * restriction:
+ *
+ * -- SLI_CONFIG EMB=0, carrying MSEs, will carry subcommands without
+ *    carrying HBD.
+ * -- SLI_CONFIG EMB=1, not carrying MSE, will carry subcommands with or
+ *    without carrying HBDs.
+ */
+
+struct lpfc_sli_config_mse {
+        uint32_t pa_lo;
+        uint32_t pa_hi;
+        uint32_t buf_len;
+#define lpfc_mbox_sli_config_mse_len_SHIFT      0
+#define lpfc_mbox_sli_config_mse_len_MASK       0xffffff
+#define lpfc_mbox_sli_config_mse_len_WORD       buf_len
+};
+
+struct lpfc_sli_config_subcmd_hbd {
+        uint32_t buf_len;
+#define lpfc_mbox_sli_config_ecmn_hbd_len_SHIFT 0
+#define lpfc_mbox_sli_config_ecmn_hbd_len_MASK  0xffffff
+#define lpfc_mbox_sli_config_ecmn_hbd_len_WORD  buf_len
+        uint32_t pa_lo;
+        uint32_t pa_hi;
+};
+
+struct lpfc_sli_config_hdr {
+        uint32_t word1;
+#define lpfc_mbox_hdr_emb_SHIFT         0
+#define lpfc_mbox_hdr_emb_MASK          0x00000001
+#define lpfc_mbox_hdr_emb_WORD          word1
+#define lpfc_mbox_hdr_mse_cnt_SHIFT     3
+#define lpfc_mbox_hdr_mse_cnt_MASK      0x0000001f
+#define lpfc_mbox_hdr_mse_cnt_WORD      word1
+        uint32_t payload_length;
+        uint32_t tag_lo;
+        uint32_t tag_hi;
+        uint32_t reserved5;
+};
+
+struct lpfc_sli_config_generic {
+        struct lpfc_sli_config_hdr      sli_config_hdr;
+#define LPFC_MBX_SLI_CONFIG_MAX_MSE     19
+        struct lpfc_sli_config_mse      mse[LPFC_MBX_SLI_CONFIG_MAX_MSE];
+};
+
+struct lpfc_sli_config_subcmnd {
+        struct lpfc_sli_config_hdr      sli_config_hdr;
+        uint32_t word6;
+#define lpfc_subcmnd_opcode_SHIFT       0
+#define lpfc_subcmnd_opcode_MASK        0xff
+#define lpfc_subcmnd_opcode_WORD        word6
+#define lpfc_subcmnd_subsys_SHIFT       8
+#define lpfc_subcmnd_subsys_MASK        0xff
+#define lpfc_subcmnd_subsys_WORD        word6
+        uint32_t timeout;
+        uint32_t request_length;
+        uint32_t word9;
+#define lpfc_subcmnd_version_SHIFT      0
+#define lpfc_subcmnd_version_MASK       0xff
+#define lpfc_subcmnd_version_WORD       word9
+        uint32_t word10;
+#define lpfc_subcmnd_ask_rd_len_SHIFT   0
+#define lpfc_subcmnd_ask_rd_len_MASK    0xffffff
+#define lpfc_subcmnd_ask_rd_len_WORD    word10
+        uint32_t rd_offset;
+        uint32_t obj_name[26];
+        uint32_t hbd_count;
+#define LPFC_MBX_SLI_CONFIG_MAX_HBD     10
+        struct lpfc_sli_config_subcmd_hbd   hbd[LPFC_MBX_SLI_CONFIG_MAX_HBD];
+};
+
+struct lpfc_sli_config_mbox {
+        uint32_t word0;
+#define lpfc_mqe_status_SHIFT           16
+#define lpfc_mqe_status_MASK            0x0000FFFF
+#define lpfc_mqe_status_WORD            word0
+#define lpfc_mqe_command_SHIFT          8
+#define lpfc_mqe_command_MASK           0x000000FF
+#define lpfc_mqe_command_WORD           word0
+        union {
+                struct lpfc_sli_config_generic  sli_config_generic;
+                struct lpfc_sli_config_subcmnd  sli_config_subcmnd;
+        } un;
+};
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.c b/drivers/scsi/lpfc/lpfc_debugfs.c
index 3d967741c708..c93fca058603 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.c
+++ b/drivers/scsi/lpfc/lpfc_debugfs.c
@@ -1119,172 +1119,14 @@ lpfc_debugfs_dumpDataDif_release(struct inode *inode, struct file *file)
 }
 
 /*
+ * ---------------------------------
  * iDiag debugfs file access methods
- */
-
-/*
- * iDiag PCI config space register access methods:
- *
- * The PCI config space register accessees of read, write, read-modify-write
- * for set bits, and read-modify-write for clear bits to SLI4 PCI functions
- * are provided. In the proper SLI4 PCI function's debugfs iDiag directory,
- *
- *      /sys/kernel/debug/lpfc/fn<#>/iDiag
- *
- * the access is through the debugfs entry pciCfg:
- *
- * 1. For PCI config space register read access, there are two read methods:
- *    A) read a single PCI config space register in the size of a byte
- *    (8 bits), a word (16 bits), or a dword (32 bits); or B) browse through
- *    the 4K extended PCI config space.
- *
- *    A) Read a single PCI config space register consists of two steps:
- *
- *    Step-1: Set up PCI config space register read command, the command
- *    syntax is,
- *
- *        echo 1 <where> <count> > pciCfg
- *
- *    where, 1 is the iDiag command for PCI config space read, <where> is the
- *    offset from the beginning of the device's PCI config space to read from,
- *    and <count> is the size of PCI config space register data to read back,
- *    it will be 1 for reading a byte (8 bits), 2 for reading a word (16 bits
- *    or 2 bytes), or 4 for reading a dword (32 bits or 4 bytes).
- *
- *    Setp-2: Perform the debugfs read operation to execute the idiag command
- *    set up in Step-1,
- *
- *        cat pciCfg
- *
- *    Examples:
- *    To read PCI device's vendor-id and device-id from PCI config space,
- *
- *        echo 1 0 4 > pciCfg
- *        cat pciCfg
- *
- *    To read PCI device's currnt command from config space,
- *
- *        echo 1 4 2 > pciCfg
- *        cat pciCfg
- *
- *    B) Browse through the entire 4K extended PCI config space also consists
- *    of two steps:
- *
- *    Step-1: Set up PCI config space register browsing command, the command
- *    syntax is,
- *
- *        echo 1 0 4096 > pciCfg
- *
- *    where, 1 is the iDiag command for PCI config space read, 0 must be used
- *    as the offset for PCI config space register browse, and 4096 must be
- *    used as the count for PCI config space register browse.
- *
- *    Step-2: Repeately issue the debugfs read operation to browse through
- *    the entire PCI config space registers:
- *
- *        cat pciCfg
- *        cat pciCfg
- *        cat pciCfg
- *        ...
- *
- *    When browsing to the end of the 4K PCI config space, the browse method
- *    shall wrap around to start reading from beginning again, and again...
- *
- * 2. For PCI config space register write access, it supports a single PCI
- *    config space register write in the size of a byte (8 bits), a word
- *    (16 bits), or a dword (32 bits). The command syntax is,
- *
- *        echo 2 <where> <count> <value> > pciCfg
- *
- *    where, 2 is the iDiag command for PCI config space write, <where> is
- *    the offset from the beginning of the device's PCI config space to write
- *    into, <count> is the size of data to write into the PCI config space,
- *    it will be 1 for writing a byte (8 bits), 2 for writing a word (16 bits
- *    or 2 bytes), or 4 for writing a dword (32 bits or 4 bytes), and <value>
- *    is the data to be written into the PCI config space register at the
- *    offset.
- *
- *    Examples:
- *    To disable PCI device's interrupt assertion,
- *
- *    1) Read in device's PCI config space register command field <cmd>:
- *
- *           echo 1 4 2 > pciCfg
- *           cat pciCfg
- *
- *    2) Set bit 10 (Interrupt Disable bit) in the <cmd>:
- *
- *           <cmd> = <cmd> | (1 < 10)
- *
- *    3) Write the modified command back:
- *
- *           echo 2 4 2 <cmd> > pciCfg
- *
- * 3. For PCI config space register set bits access, it supports a single PCI
- *    config space register set bits in the size of a byte (8 bits), a word
- *    (16 bits), or a dword (32 bits). The command syntax is,
- *
- *        echo 3 <where> <count> <bitmask> > pciCfg
- *
- *    where, 3 is the iDiag command for PCI config space set bits, <where> is
- *    the offset from the beginning of the device's PCI config space to set
- *    bits into, <count> is the size of the bitmask to set into the PCI config
- *    space, it will be 1 for setting a byte (8 bits), 2 for setting a word
- *    (16 bits or 2 bytes), or 4 for setting a dword (32 bits or 4 bytes), and
- *    <bitmask> is the bitmask, indicating the bits to be set into the PCI
- *    config space register at the offset. The logic performed to the content
- *    of the PCI config space register, regval, is,
- *
- *        regval |= <bitmask>
- *
- * 4. For PCI config space register clear bits access, it supports a single
- *    PCI config space register clear bits in the size of a byte (8 bits),
- *    a word (16 bits), or a dword (32 bits). The command syntax is,
- *
- *        echo 4 <where> <count> <bitmask> > pciCfg
- *
- *    where, 4 is the iDiag command for PCI config space clear bits, <where>
- *    is the offset from the beginning of the device's PCI config space to
- *    clear bits from, <count> is the size of the bitmask to set into the PCI
- *    config space, it will be 1 for setting a byte (8 bits), 2 for setting
- *    a word(16 bits or 2 bytes), or 4 for setting a dword (32 bits or 4
- *    bytes), and <bitmask> is the bitmask, indicating the bits to be cleared
- *    from the PCI config space register at the offset. the logic performed
- *    to the content of the PCI config space register, regval, is,
- *
- *        regval &= ~<bitmask>
- *
- * Note, for all single register read, write, set bits, or clear bits access,
- * the offset (<where>) must be aligned with the size of the data:
- *
- * For data size of byte (8 bits), the offset must be aligned to the byte
- * boundary; for data size of word (16 bits), the offset must be aligned
- * to the word boundary; while for data size of dword (32 bits), the offset
- * must be aligned to the dword boundary. Otherwise, the interface will
- * return the error:
+ * ---------------------------------
  *
- *     "-bash: echo: write error: Invalid argument".
+ * All access methods are through the proper SLI4 PCI function's debugfs
+ * iDiag directory:
  *
- * For example:
- *
- *     echo 1 2 4 > pciCfg
- *     -bash: echo: write error: Invalid argument
- *
- * Note also, all of the numbers in the command fields for all read, write,
- * set bits, and clear bits PCI config space register command fields can be
- * either decimal or hex.
- *
- * For example,
- *     echo 1 0 4096 > pciCfg
- *
- * will be the same as
- *     echo 1 0 0x1000 > pciCfg
- *
- * And,
- *     echo 2 155 1 10 > pciCfg
- *
- * will be
- *     echo 2 0x9b 1 0xa > pciCfg
+ *     /sys/kernel/debug/lpfc/fn<#>/iDiag
  */
 
 /**
@@ -1331,10 +1173,10 @@ static int lpfc_idiag_cmd_get(const char __user *buf, size_t nbytes,
         for (i = 0; i < LPFC_IDIAG_CMD_DATA_SIZE; i++) {
                 step_str = strsep(&pbuf, "\t ");
                 if (!step_str)
-                        return 0;
+                        return i;
                 idiag_cmd->data[i] = simple_strtol(step_str, NULL, 0);
         }
-        return 0;
+        return i;
 }
 
 /**
@@ -1403,7 +1245,7 @@ lpfc_idiag_release(struct inode *inode, struct file *file)
  * Description:
  * This routine frees the buffer that was allocated when the debugfs file
  * was opened. It also reset the fields in the idiag command struct in the
- * case the command is not continuous browsing of the data structure.
+ * case of command for write operation.
  *
  * Returns:
  * This function returns zero.
@@ -1413,18 +1255,20 @@ lpfc_idiag_cmd_release(struct inode *inode, struct file *file)
 {
         struct lpfc_debug *debug = file->private_data;
 
-        /* Read PCI config register, if not read all, clear command fields */
-        if ((debug->op == LPFC_IDIAG_OP_RD) &&
-            (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_RD))
-                if ((idiag.cmd.data[1] == sizeof(uint8_t)) ||
-                    (idiag.cmd.data[1] == sizeof(uint16_t)) ||
-                    (idiag.cmd.data[1] == sizeof(uint32_t)))
+        if (debug->op == LPFC_IDIAG_OP_WR) {
+                switch (idiag.cmd.opcode) {
+                case LPFC_IDIAG_CMD_PCICFG_WR:
+                case LPFC_IDIAG_CMD_PCICFG_ST:
+                case LPFC_IDIAG_CMD_PCICFG_CL:
+                case LPFC_IDIAG_CMD_QUEACC_WR:
+                case LPFC_IDIAG_CMD_QUEACC_ST:
+                case LPFC_IDIAG_CMD_QUEACC_CL:
                         memset(&idiag, 0, sizeof(idiag));
-
-        /* Write PCI config register, clear command fields */
-        if ((debug->op == LPFC_IDIAG_OP_WR) &&
-            (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR))
-                memset(&idiag, 0, sizeof(idiag));
+                        break;
+                default:
+                        break;
+                }
+        }
 
         /* Free the buffers to the file operation */
         kfree(debug->buffer);
@@ -1504,7 +1348,7 @@ lpfc_idiag_pcicfg_read(struct file *file, char __user *buf, size_t nbytes,
                 len += snprintf(pbuffer+len, LPFC_PCI_CFG_SIZE-len,
                                 "%03x: %08x\n", where, u32val);
                 break;
-        case LPFC_PCI_CFG_SIZE: /* browse all */
+        case LPFC_PCI_CFG_BROWSE: /* browse all */
                 goto pcicfg_browse;
                 break;
         default:
@@ -1586,16 +1430,21 @@ lpfc_idiag_pcicfg_write(struct file *file, const char __user *buf,
         debug->op = LPFC_IDIAG_OP_WR;
 
         rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
-        if (rc)
+        if (rc < 0)
                 return rc;
 
         if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_RD) {
+                /* Sanity check on PCI config read command line arguments */
+                if (rc != LPFC_PCI_CFG_RD_CMD_ARG)
+                        goto error_out;
                 /* Read command from PCI config space, set up command fields */
                 where = idiag.cmd.data[0];
                 count = idiag.cmd.data[1];
-                if (count == LPFC_PCI_CFG_SIZE) {
-                        if (where != 0)
+                if (count == LPFC_PCI_CFG_BROWSE) {
+                        if (where % sizeof(uint32_t))
                                 goto error_out;
+                        /* Starting offset to browse */
+                        idiag.offset.last_rd = where;
                 } else if ((count != sizeof(uint8_t)) &&
                            (count != sizeof(uint16_t)) &&
                            (count != sizeof(uint32_t)))
@@ -1621,6 +1470,9 @@ lpfc_idiag_pcicfg_write(struct file *file, const char __user *buf,
         } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_WR ||
                    idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_ST ||
                    idiag.cmd.opcode == LPFC_IDIAG_CMD_PCICFG_CL) {
+                /* Sanity check on PCI config write command line arguments */
+                if (rc != LPFC_PCI_CFG_WR_CMD_ARG)
+                        goto error_out;
                 /* Write command to PCI config space, read-modify-write */
                 where = idiag.cmd.data[0];
                 count = idiag.cmd.data[1];
@@ -1753,10 +1605,12 @@ lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes,
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
                         "Slow-path EQ information:\n");
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\tID [%02d], EQE-COUNT [%04d], "
-                        "HOST-INDEX [%04x], PORT-INDEX [%04x]\n\n",
+                        "\tEQID[%02d], "
+                        "QE-COUNT[%04d], QE-SIZE[%04d], "
+                        "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n",
                         phba->sli4_hba.sp_eq->queue_id,
                         phba->sli4_hba.sp_eq->entry_count,
+                        phba->sli4_hba.sp_eq->entry_size,
                         phba->sli4_hba.sp_eq->host_index,
                         phba->sli4_hba.sp_eq->hba_index);
 
@@ -1765,10 +1619,12 @@ lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes,
                         "Fast-path EQ information:\n");
         for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++) {
                 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                                "\tID [%02d], EQE-COUNT [%04d], "
-                                "HOST-INDEX [%04x], PORT-INDEX [%04x]\n",
+                                "\tEQID[%02d], "
+                                "QE-COUNT[%04d], QE-SIZE[%04d], "
+                                "HOST-INDEX[%04d], PORT-INDEX[%04d]\n",
                                 phba->sli4_hba.fp_eq[fcp_qidx]->queue_id,
                                 phba->sli4_hba.fp_eq[fcp_qidx]->entry_count,
+                                phba->sli4_hba.fp_eq[fcp_qidx]->entry_size,
                                 phba->sli4_hba.fp_eq[fcp_qidx]->host_index,
                                 phba->sli4_hba.fp_eq[fcp_qidx]->hba_index);
         }
@@ -1776,89 +1632,101 @@ lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes,
 
         /* Get mailbox complete queue information */
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "Mailbox CQ information:\n");
+                        "Slow-path MBX CQ information:\n");
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\t\tAssociated EQ-ID [%02d]:\n",
+                        "Associated EQID[%02d]:\n",
                         phba->sli4_hba.mbx_cq->assoc_qid);
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\tID [%02d], CQE-COUNT [%04d], "
-                        "HOST-INDEX [%04x], PORT-INDEX [%04x]\n\n",
+                        "\tCQID[%02d], "
+                        "QE-COUNT[%04d], QE-SIZE[%04d], "
+                        "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n",
                         phba->sli4_hba.mbx_cq->queue_id,
                         phba->sli4_hba.mbx_cq->entry_count,
+                        phba->sli4_hba.mbx_cq->entry_size,
                         phba->sli4_hba.mbx_cq->host_index,
                         phba->sli4_hba.mbx_cq->hba_index);
 
         /* Get slow-path complete queue information */
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "Slow-path CQ information:\n");
+                        "Slow-path ELS CQ information:\n");
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\t\tAssociated EQ-ID [%02d]:\n",
+                        "Associated EQID[%02d]:\n",
                         phba->sli4_hba.els_cq->assoc_qid);
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\tID [%02d], CQE-COUNT [%04d], "
-                        "HOST-INDEX [%04x], PORT-INDEX [%04x]\n\n",
+                        "\tCQID [%02d], "
+                        "QE-COUNT[%04d], QE-SIZE[%04d], "
+                        "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n",
                         phba->sli4_hba.els_cq->queue_id,
                         phba->sli4_hba.els_cq->entry_count,
+                        phba->sli4_hba.els_cq->entry_size,
                         phba->sli4_hba.els_cq->host_index,
                         phba->sli4_hba.els_cq->hba_index);
 
         /* Get fast-path complete queue information */
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "Fast-path CQ information:\n");
+                        "Fast-path FCP CQ information:\n");
         for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++) {
                 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                                "\t\tAssociated EQ-ID [%02d]:\n",
+                                "Associated EQID[%02d]:\n",
                                 phba->sli4_hba.fcp_cq[fcp_qidx]->assoc_qid);
                 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                "\tID [%02d], EQE-COUNT [%04d], "
-                "HOST-INDEX [%04x], PORT-INDEX [%04x]\n",
-                phba->sli4_hba.fcp_cq[fcp_qidx]->queue_id,
-                phba->sli4_hba.fcp_cq[fcp_qidx]->entry_count,
-                phba->sli4_hba.fcp_cq[fcp_qidx]->host_index,
-                phba->sli4_hba.fcp_cq[fcp_qidx]->hba_index);
+                                "\tCQID[%02d], "
+                                "QE-COUNT[%04d], QE-SIZE[%04d], "
+                                "HOST-INDEX[%04d], PORT-INDEX[%04d]\n",
+                                phba->sli4_hba.fcp_cq[fcp_qidx]->queue_id,
+                                phba->sli4_hba.fcp_cq[fcp_qidx]->entry_count,
+                                phba->sli4_hba.fcp_cq[fcp_qidx]->entry_size,
+                                phba->sli4_hba.fcp_cq[fcp_qidx]->host_index,
+                                phba->sli4_hba.fcp_cq[fcp_qidx]->hba_index);
         }
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, "\n");
 
         /* Get mailbox queue information */
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "Mailbox MQ information:\n");
+                        "Slow-path MBX MQ information:\n");
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\t\tAssociated CQ-ID [%02d]:\n",
+                        "Associated CQID[%02d]:\n",
                         phba->sli4_hba.mbx_wq->assoc_qid);
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\tID [%02d], MQE-COUNT [%04d], "
-                        "HOST-INDEX [%04x], PORT-INDEX [%04x]\n\n",
+                        "\tWQID[%02d], "
+                        "QE-COUNT[%04d], QE-SIZE[%04d], "
+                        "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n",
                         phba->sli4_hba.mbx_wq->queue_id,
                         phba->sli4_hba.mbx_wq->entry_count,
+                        phba->sli4_hba.mbx_wq->entry_size,
                         phba->sli4_hba.mbx_wq->host_index,
                         phba->sli4_hba.mbx_wq->hba_index);
 
         /* Get slow-path work queue information */
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "Slow-path WQ information:\n");
+                        "Slow-path ELS WQ information:\n");
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\t\tAssociated CQ-ID [%02d]:\n",
+                        "Associated CQID[%02d]:\n",
                         phba->sli4_hba.els_wq->assoc_qid);
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\tID [%02d], WQE-COUNT [%04d], "
-                        "HOST-INDEX [%04x], PORT-INDEX [%04x]\n\n",
+                        "\tWQID[%02d], "
+                        "QE-COUNT[%04d], QE-SIZE[%04d], "
+                        "HOST-INDEX[%04d], PORT-INDEX[%04d]\n\n",
                         phba->sli4_hba.els_wq->queue_id,
                         phba->sli4_hba.els_wq->entry_count,
+                        phba->sli4_hba.els_wq->entry_size,
                         phba->sli4_hba.els_wq->host_index,
                         phba->sli4_hba.els_wq->hba_index);
 
         /* Get fast-path work queue information */
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "Fast-path WQ information:\n");
+                        "Fast-path FCP WQ information:\n");
         for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_wq_count; fcp_qidx++) {
                 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                                "\t\tAssociated CQ-ID [%02d]:\n",
+                                "Associated CQID[%02d]:\n",
                                 phba->sli4_hba.fcp_wq[fcp_qidx]->assoc_qid);
                 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                                "\tID [%02d], WQE-COUNT [%04d], "
-                                "HOST-INDEX [%04x], PORT-INDEX [%04x]\n",
+                                "\tWQID[%02d], "
+                                "QE-COUNT[%04d], WQE-SIZE[%04d], "
+                                "HOST-INDEX[%04d], PORT-INDEX[%04d]\n",
                                 phba->sli4_hba.fcp_wq[fcp_qidx]->queue_id,
                                 phba->sli4_hba.fcp_wq[fcp_qidx]->entry_count,
+                                phba->sli4_hba.fcp_wq[fcp_qidx]->entry_size,
                                 phba->sli4_hba.fcp_wq[fcp_qidx]->host_index,
                                 phba->sli4_hba.fcp_wq[fcp_qidx]->hba_index);
         }
@@ -1868,26 +1736,597 @@ lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes,
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
                         "Slow-path RQ information:\n");
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\t\tAssociated CQ-ID [%02d]:\n",
+                        "Associated CQID[%02d]:\n",
                         phba->sli4_hba.hdr_rq->assoc_qid);
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\tID [%02d], RHQE-COUNT [%04d], "
-                        "HOST-INDEX [%04x], PORT-INDEX [%04x]\n",
+                        "\tHQID[%02d], "
+                        "QE-COUNT[%04d], QE-SIZE[%04d], "
+                        "HOST-INDEX[%04d], PORT-INDEX[%04d]\n",
                         phba->sli4_hba.hdr_rq->queue_id,
                         phba->sli4_hba.hdr_rq->entry_count,
+                        phba->sli4_hba.hdr_rq->entry_size,
                         phba->sli4_hba.hdr_rq->host_index,
                         phba->sli4_hba.hdr_rq->hba_index);
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
-                        "\tID [%02d], RDQE-COUNT [%04d], "
-                        "HOST-INDEX [%04x], PORT-INDEX [%04x]\n",
+                        "\tDQID[%02d], "
+                        "QE-COUNT[%04d], QE-SIZE[%04d], "
+                        "HOST-INDEX[%04d], PORT-INDEX[%04d]\n",
                         phba->sli4_hba.dat_rq->queue_id,
                         phba->sli4_hba.dat_rq->entry_count,
+                        phba->sli4_hba.dat_rq->entry_size,
                         phba->sli4_hba.dat_rq->host_index,
                         phba->sli4_hba.dat_rq->hba_index);
 
         return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
 }
 
+/**
+ * lpfc_idiag_que_param_check - queue access command parameter sanity check
+ * @q: The pointer to queue structure.
+ * @index: The index into a queue entry.
+ * @count: The number of queue entries to access.
+ *
+ * Description:
+ * The routine performs sanity check on device queue access method commands.
+ *
+ * Returns:
+ * This function returns -EINVAL when fails the sanity check, otherwise, it
+ * returns 0.
+ **/
+static int
+lpfc_idiag_que_param_check(struct lpfc_queue *q, int index, int count)
+{
+        /* Only support single entry read or browsing */
+        if ((count != 1) && (count != LPFC_QUE_ACC_BROWSE))
+                return -EINVAL;
+        if (index > q->entry_count - 1)
+                return -EINVAL;
+        return 0;
+}
+
+/**
+ * lpfc_idiag_queacc_read_qe - read a single entry from the given queue index
+ * @pbuffer: The pointer to buffer to copy the read data into.
+ * @pque: The pointer to the queue to be read.
+ * @index: The index into the queue entry.
+ *
+ * Description:
+ * This routine reads out a single entry from the given queue's index location
+ * and copies it into the buffer provided.
+ *
+ * Returns:
+ * This function returns 0 when it fails, otherwise, it returns the length of
+ * the data read into the buffer provided.
+ **/
+static int
+lpfc_idiag_queacc_read_qe(char *pbuffer, int len, struct lpfc_queue *pque,
+                          uint32_t index)
+{
+        int offset, esize;
+        uint32_t *pentry;
+
+        if (!pbuffer || !pque)
+                return 0;
+
+        esize = pque->entry_size;
+        len += snprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len,
+                        "QE-INDEX[%04d]:\n", index);
+
+        offset = 0;
+        pentry = pque->qe[index].address;
+        while (esize > 0) {
+                len += snprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len,
+                                "%08x ", *pentry);
+                pentry++;
+                offset += sizeof(uint32_t);
+                esize -= sizeof(uint32_t);
+                if (esize > 0 && !(offset % (4 * sizeof(uint32_t))))
+                        len += snprintf(pbuffer+len,
+                                        LPFC_QUE_ACC_BUF_SIZE-len, "\n");
+        }
+        len += snprintf(pbuffer+len, LPFC_QUE_ACC_BUF_SIZE-len, "\n");
+
+        return len;
+}
+
+/**
+ * lpfc_idiag_queacc_read - idiag debugfs read port queue
+ * @file: The file pointer to read from.
+ * @buf: The buffer to copy the data to.
+ * @nbytes: The number of bytes to read.
+ * @ppos: The position in the file to start reading from.
+ *
+ * Description:
+ * This routine reads data from the @phba device queue memory according to the
+ * idiag command, and copies to user @buf. Depending on the queue dump read
+ * command setup, it does either a single queue entry read or browing through
+ * all entries of the queue.
+ *
+ * Returns:
+ * This function returns the amount of data that was read (this could be less
+ * than @nbytes if the end of the file was reached) or a negative error value.
+ **/
+static ssize_t
+lpfc_idiag_queacc_read(struct file *file, char __user *buf, size_t nbytes,
+                       loff_t *ppos)
+{
+        struct lpfc_debug *debug = file->private_data;
+        uint32_t last_index, index, count;
+        struct lpfc_queue *pque = NULL;
+        char *pbuffer;
+        int len = 0;
+
+        /* This is a user read operation */
+        debug->op = LPFC_IDIAG_OP_RD;
+
+        if (!debug->buffer)
+                debug->buffer = kmalloc(LPFC_QUE_ACC_BUF_SIZE, GFP_KERNEL);
+        if (!debug->buffer)
+                return 0;
+        pbuffer = debug->buffer;
+
+        if (*ppos)
+                return 0;
+
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) {
+                index = idiag.cmd.data[2];
+                count = idiag.cmd.data[3];
+                pque = (struct lpfc_queue *)idiag.ptr_private;
+        } else
+                return 0;
+
+        /* Browse the queue starting from index */
+        if (count == LPFC_QUE_ACC_BROWSE)
+                goto que_browse;
+
+        /* Read a single entry from the queue */
+        len = lpfc_idiag_queacc_read_qe(pbuffer, len, pque, index);
+
+        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
+
+que_browse:
+
+        /* Browse all entries from the queue */
+        last_index = idiag.offset.last_rd;
+        index = last_index;
+
+        while (len < LPFC_QUE_ACC_SIZE - pque->entry_size) {
+                len = lpfc_idiag_queacc_read_qe(pbuffer, len, pque, index);
+                index++;
+                if (index > pque->entry_count - 1)
+                        break;
+        }
+
+        /* Set up the offset for next portion of pci cfg read */
+        if (index > pque->entry_count - 1)
+                index = 0;
+        idiag.offset.last_rd = index;
+
+        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
+}
+
+/**
+ * lpfc_idiag_queacc_write - Syntax check and set up idiag queacc commands
+ * @file: The file pointer to read from.
+ * @buf: The buffer to copy the user data from.
+ * @nbytes: The number of bytes to get.
+ * @ppos: The position in the file to start reading from.
+ *
+ * This routine get the debugfs idiag command struct from user space and then
+ * perform the syntax check for port queue read (dump) or write (set) command
+ * accordingly. In the case of port queue read command, it sets up the command
+ * in the idiag command struct for the following debugfs read operation. In
+ * the case of port queue write operation, it executes the write operation
+ * into the port queue entry accordingly.
+ *
+ * It returns the @nbytges passing in from debugfs user space when successful.
+ * In case of error conditions, it returns proper error code back to the user
+ * space.
+ **/
+static ssize_t
+lpfc_idiag_queacc_write(struct file *file, const char __user *buf,
+                        size_t nbytes, loff_t *ppos)
+{
+        struct lpfc_debug *debug = file->private_data;
+        struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
+        uint32_t qidx, quetp, queid, index, count, offset, value;
+        uint32_t *pentry;
+        struct lpfc_queue *pque;
+        int rc;
+
+        /* This is a user write operation */
+        debug->op = LPFC_IDIAG_OP_WR;
+
+        rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
+        if (rc < 0)
+                return rc;
+
+        /* Get and sanity check on command feilds */
+        quetp  = idiag.cmd.data[0];
+        queid  = idiag.cmd.data[1];
+        index  = idiag.cmd.data[2];
+        count  = idiag.cmd.data[3];
+        offset = idiag.cmd.data[4];
+        value  = idiag.cmd.data[5];
+
+        /* Sanity check on command line arguments */
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL) {
+                if (rc != LPFC_QUE_ACC_WR_CMD_ARG)
+                        goto error_out;
+                if (count != 1)
+                        goto error_out;
+        } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) {
+                if (rc != LPFC_QUE_ACC_RD_CMD_ARG)
+                        goto error_out;
+        } else
+                goto error_out;
+
+        switch (quetp) {
+        case LPFC_IDIAG_EQ:
+                /* Slow-path event queue */
+                if (phba->sli4_hba.sp_eq->queue_id == queid) {
+                        /* Sanity check */
+                        rc = lpfc_idiag_que_param_check(
+                                        phba->sli4_hba.sp_eq, index, count);
+                        if (rc)
+                                goto error_out;
+                        idiag.ptr_private = phba->sli4_hba.sp_eq;
+                        goto pass_check;
+                }
+                /* Fast-path event queue */
+                for (qidx = 0; qidx < phba->cfg_fcp_eq_count; qidx++) {
+                        if (phba->sli4_hba.fp_eq[qidx]->queue_id == queid) {
+                                /* Sanity check */
+                                rc = lpfc_idiag_que_param_check(
+                                                phba->sli4_hba.fp_eq[qidx],
+                                                index, count);
+                                if (rc)
+                                        goto error_out;
+                                idiag.ptr_private = phba->sli4_hba.fp_eq[qidx];
+                                goto pass_check;
+                        }
+                }
+                goto error_out;
+                break;
+        case LPFC_IDIAG_CQ:
+                /* MBX complete queue */
+                if (phba->sli4_hba.mbx_cq->queue_id == queid) {
+                        /* Sanity check */
+                        rc = lpfc_idiag_que_param_check(
+                                        phba->sli4_hba.mbx_cq, index, count);
+                        if (rc)
+                                goto error_out;
+                        idiag.ptr_private = phba->sli4_hba.mbx_cq;
+                        goto pass_check;
+                }
+                /* ELS complete queue */
+                if (phba->sli4_hba.els_cq->queue_id == queid) {
+                        /* Sanity check */
+                        rc = lpfc_idiag_que_param_check(
+                                        phba->sli4_hba.els_cq, index, count);
+                        if (rc)
+                                goto error_out;
+                        idiag.ptr_private = phba->sli4_hba.els_cq;
+                        goto pass_check;
+                }
+                /* FCP complete queue */
+                for (qidx = 0; qidx < phba->cfg_fcp_eq_count; qidx++) {
+                        if (phba->sli4_hba.fcp_cq[qidx]->queue_id == queid) {
+                                /* Sanity check */
+                                rc = lpfc_idiag_que_param_check(
+                                                phba->sli4_hba.fcp_cq[qidx],
+                                                index, count);
+                                if (rc)
+                                        goto error_out;
+                                idiag.ptr_private =
+                                                phba->sli4_hba.fcp_cq[qidx];
+                                goto pass_check;
+                        }
+                }
+                goto error_out;
+                break;
+        case LPFC_IDIAG_MQ:
+                /* MBX work queue */
+                if (phba->sli4_hba.mbx_wq->queue_id == queid) {
+                        /* Sanity check */
+                        rc = lpfc_idiag_que_param_check(
+                                        phba->sli4_hba.mbx_wq, index, count);
+                        if (rc)
+                                goto error_out;
+                        idiag.ptr_private = phba->sli4_hba.mbx_wq;
+                        goto pass_check;
+                }
+                break;
+        case LPFC_IDIAG_WQ:
+                /* ELS work queue */
+                if (phba->sli4_hba.els_wq->queue_id == queid) {
+                        /* Sanity check */
+                        rc = lpfc_idiag_que_param_check(
+                                        phba->sli4_hba.els_wq, index, count);
+                        if (rc)
+                                goto error_out;
+                        idiag.ptr_private = phba->sli4_hba.els_wq;
+                        goto pass_check;
+                }
+                /* FCP work queue */
+                for (qidx = 0; qidx < phba->cfg_fcp_wq_count; qidx++) {
+                        if (phba->sli4_hba.fcp_wq[qidx]->queue_id == queid) {
+                                /* Sanity check */
+                                rc = lpfc_idiag_que_param_check(
+                                                phba->sli4_hba.fcp_wq[qidx],
+                                                index, count);
+                                if (rc)
+                                        goto error_out;
+                                idiag.ptr_private =
+                                        phba->sli4_hba.fcp_wq[qidx];
+                                goto pass_check;
+                        }
+                }
+                goto error_out;
+                break;
+        case LPFC_IDIAG_RQ:
+                /* HDR queue */
+                if (phba->sli4_hba.hdr_rq->queue_id == queid) {
+                        /* Sanity check */
+                        rc = lpfc_idiag_que_param_check(
+                                        phba->sli4_hba.hdr_rq, index, count);
+                        if (rc)
+                                goto error_out;
+                        idiag.ptr_private = phba->sli4_hba.hdr_rq;
+                        goto pass_check;
+                }
+                /* DAT queue */
+                if (phba->sli4_hba.dat_rq->queue_id == queid) {
+                        /* Sanity check */
+                        rc = lpfc_idiag_que_param_check(
+                                        phba->sli4_hba.dat_rq, index, count);
+                        if (rc)
+                                goto error_out;
+                        idiag.ptr_private = phba->sli4_hba.dat_rq;
+                        goto pass_check;
+                }
+                goto error_out;
+                break;
+        default:
+                goto error_out;
+                break;
+        }
+
+pass_check:
+
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_RD) {
+                if (count == LPFC_QUE_ACC_BROWSE)
+                        idiag.offset.last_rd = index;
+        }
+
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL) {
+                /* Additional sanity checks on write operation */
+                pque = (struct lpfc_queue *)idiag.ptr_private;
+                if (offset > pque->entry_size/sizeof(uint32_t) - 1)
+                        goto error_out;
+                pentry = pque->qe[index].address;
+                pentry += offset;
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_WR)
+                        *pentry = value;
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_ST)
+                        *pentry |= value;
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_QUEACC_CL)
+                        *pentry &= ~value;
+        }
+        return nbytes;
+
+error_out:
+        /* Clean out command structure on command error out */
+        memset(&idiag, 0, sizeof(idiag));
+        return -EINVAL;
+}
+
+/**
+ * lpfc_idiag_drbacc_read_reg - idiag debugfs read a doorbell register
+ * @phba: The pointer to hba structure.
+ * @pbuffer: The pointer to the buffer to copy the data to.
+ * @len: The lenght of bytes to copied.
+ * @drbregid: The id to doorbell registers.
+ *
+ * Description:
+ * This routine reads a doorbell register and copies its content to the
+ * user buffer pointed to by @pbuffer.
+ *
+ * Returns:
+ * This function returns the amount of data that was copied into @pbuffer.
+ **/
+static int
+lpfc_idiag_drbacc_read_reg(struct lpfc_hba *phba, char *pbuffer,
+                           int len, uint32_t drbregid)
+{
+
+        if (!pbuffer)
+                return 0;
+
+        switch (drbregid) {
+        case LPFC_DRB_EQCQ:
+                len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
+                                "EQCQ-DRB-REG: 0x%08x\n",
+                                readl(phba->sli4_hba.EQCQDBregaddr));
+                break;
+        case LPFC_DRB_MQ:
+                len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
+                                "MQ-DRB-REG:   0x%08x\n",
+                                readl(phba->sli4_hba.MQDBregaddr));
+                break;
+        case LPFC_DRB_WQ:
+                len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
+                                "WQ-DRB-REG:   0x%08x\n",
+                                readl(phba->sli4_hba.WQDBregaddr));
+                break;
+        case LPFC_DRB_RQ:
+                len += snprintf(pbuffer+len, LPFC_DRB_ACC_BUF_SIZE-len,
+                                "RQ-DRB-REG:   0x%08x\n",
+                                readl(phba->sli4_hba.RQDBregaddr));
+                break;
+        default:
+                break;
+        }
+
+        return len;
+}
+
+/**
+ * lpfc_idiag_drbacc_read - idiag debugfs read port doorbell
+ * @file: The file pointer to read from.
+ * @buf: The buffer to copy the data to.
+ * @nbytes: The number of bytes to read.
+ * @ppos: The position in the file to start reading from.
+ *
+ * Description:
+ * This routine reads data from the @phba device doorbell register according
+ * to the idiag command, and copies to user @buf. Depending on the doorbell
+ * register read command setup, it does either a single doorbell register
+ * read or dump all doorbell registers.
+ *
+ * Returns:
+ * This function returns the amount of data that was read (this could be less
+ * than @nbytes if the end of the file was reached) or a negative error value.
+ **/
+static ssize_t
+lpfc_idiag_drbacc_read(struct file *file, char __user *buf, size_t nbytes,
+                       loff_t *ppos)
+{
+        struct lpfc_debug *debug = file->private_data;
+        struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
+        uint32_t drb_reg_id, i;
+        char *pbuffer;
+        int len = 0;
+
+        /* This is a user read operation */
+        debug->op = LPFC_IDIAG_OP_RD;
+
+        if (!debug->buffer)
+                debug->buffer = kmalloc(LPFC_DRB_ACC_BUF_SIZE, GFP_KERNEL);
+        if (!debug->buffer)
+                return 0;
+        pbuffer = debug->buffer;
+
+        if (*ppos)
+                return 0;
+
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_RD)
+                drb_reg_id = idiag.cmd.data[0];
+        else
+                return 0;
+
+        if (drb_reg_id == LPFC_DRB_ACC_ALL)
+                for (i = 1; i <= LPFC_DRB_MAX; i++)
+                        len = lpfc_idiag_drbacc_read_reg(phba,
+                                                         pbuffer, len, i);
+        else
+                len = lpfc_idiag_drbacc_read_reg(phba,
+                                                 pbuffer, len, drb_reg_id);
+
+        return simple_read_from_buffer(buf, nbytes, ppos, pbuffer, len);
+}
+
+/**
+ * lpfc_idiag_drbacc_write - Syntax check and set up idiag drbacc commands
+ * @file: The file pointer to read from.
+ * @buf: The buffer to copy the user data from.
+ * @nbytes: The number of bytes to get.
+ * @ppos: The position in the file to start reading from.
+ *
+ * This routine get the debugfs idiag command struct from user space and then
+ * perform the syntax check for port doorbell register read (dump) or write
+ * (set) command accordingly. In the case of port queue read command, it sets
+ * up the command in the idiag command struct for the following debugfs read
+ * operation. In the case of port doorbell register write operation, it
+ * executes the write operation into the port doorbell register accordingly.
+ *
+ * It returns the @nbytges passing in from debugfs user space when successful.
+ * In case of error conditions, it returns proper error code back to the user
+ * space.
+ **/
+static ssize_t
+lpfc_idiag_drbacc_write(struct file *file, const char __user *buf,
+                        size_t nbytes, loff_t *ppos)
+{
+        struct lpfc_debug *debug = file->private_data;
+        struct lpfc_hba *phba = (struct lpfc_hba *)debug->i_private;
+        uint32_t drb_reg_id, value, reg_val;
+        void __iomem *drb_reg;
+        int rc;
+
+        /* This is a user write operation */
+        debug->op = LPFC_IDIAG_OP_WR;
+
+        rc = lpfc_idiag_cmd_get(buf, nbytes, &idiag.cmd);
+        if (rc < 0)
+                return rc;
+
+        /* Sanity check on command line arguments */
+        drb_reg_id = idiag.cmd.data[0];
+        value = idiag.cmd.data[1];
+
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) {
+                if (rc != LPFC_DRB_ACC_WR_CMD_ARG)
+                        goto error_out;
+                if (drb_reg_id > LPFC_DRB_MAX)
+                        goto error_out;
+        } else if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_RD) {
+                if (rc != LPFC_DRB_ACC_RD_CMD_ARG)
+                        goto error_out;
+                if ((drb_reg_id > LPFC_DRB_MAX) &&
+                    (drb_reg_id != LPFC_DRB_ACC_ALL))
+                        goto error_out;
+        } else
+                goto error_out;
+
+        /* Perform the write access operation */
+        if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST ||
+            idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) {
+                switch (drb_reg_id) {
+                case LPFC_DRB_EQCQ:
+                        drb_reg = phba->sli4_hba.EQCQDBregaddr;
+                        break;
+                case LPFC_DRB_MQ:
+                        drb_reg = phba->sli4_hba.MQDBregaddr;
+                        break;
+                case LPFC_DRB_WQ:
+                        drb_reg = phba->sli4_hba.WQDBregaddr;
+                        break;
+                case LPFC_DRB_RQ:
+                        drb_reg = phba->sli4_hba.RQDBregaddr;
+                        break;
+                default:
+                        goto error_out;
+                }
+
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_WR)
+                        reg_val = value;
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_ST) {
+                        reg_val = readl(drb_reg);
+                        reg_val |= value;
+                }
+                if (idiag.cmd.opcode == LPFC_IDIAG_CMD_DRBACC_CL) {
+                        reg_val = readl(drb_reg);
+                        reg_val &= ~value;
+                }
+                writel(reg_val, drb_reg);
+                readl(drb_reg); /* flush */
+        }
+        return nbytes;
+
+error_out:
+        /* Clean out command structure on command error out */
+        memset(&idiag, 0, sizeof(idiag));
+        return -EINVAL;
+}
+
 #undef lpfc_debugfs_op_disc_trc
 static const struct file_operations lpfc_debugfs_op_disc_trc = {
         .owner =        THIS_MODULE,
@@ -1986,6 +2425,26 @@ static const struct file_operations lpfc_idiag_op_queInfo = {
         .release =      lpfc_idiag_release,
 };
 
+#undef lpfc_idiag_op_queacc
+static const struct file_operations lpfc_idiag_op_queAcc = {
+        .owner =        THIS_MODULE,
+        .open =         lpfc_idiag_open,
+        .llseek =       lpfc_debugfs_lseek,
+        .read =         lpfc_idiag_queacc_read,
+        .write =        lpfc_idiag_queacc_write,
+        .release =      lpfc_idiag_cmd_release,
+};
+
+#undef lpfc_idiag_op_drbacc
+static const struct file_operations lpfc_idiag_op_drbAcc = {
+        .owner =        THIS_MODULE,
+        .open =         lpfc_idiag_open,
+        .llseek =       lpfc_debugfs_lseek,
+        .read =         lpfc_idiag_drbacc_read,
+        .write =        lpfc_idiag_drbacc_write,
+        .release =      lpfc_idiag_cmd_release,
+};
+
 #endif
 
 /**
@@ -2261,6 +2720,32 @@ lpfc_debugfs_initialize(struct lpfc_vport *vport)
                 }
         }
 
+        /* iDiag access PCI function queue */
+        snprintf(name, sizeof(name), "queAcc");
+        if (!phba->idiag_que_acc) {
+                phba->idiag_que_acc =
+                        debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
+                                phba->idiag_root, phba, &lpfc_idiag_op_queAcc);
+                if (!phba->idiag_que_acc) {
+                        lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
+                                         "2926 Can't create idiag debugfs\n");
+                        goto debug_failed;
+                }
+        }
+
+        /* iDiag access PCI function doorbell registers */
+        snprintf(name, sizeof(name), "drbAcc");
+        if (!phba->idiag_drb_acc) {
+                phba->idiag_drb_acc =
+                        debugfs_create_file(name, S_IFREG|S_IRUGO|S_IWUSR,
+                                phba->idiag_root, phba, &lpfc_idiag_op_drbAcc);
+                if (!phba->idiag_drb_acc) {
+                        lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
+                                         "2927 Can't create idiag debugfs\n");
+                        goto debug_failed;
+                }
+        }
+
 debug_failed:
         return;
 #endif
@@ -2339,6 +2824,16 @@ lpfc_debugfs_terminate(struct lpfc_vport *vport)
                  * iDiag release
                  */
                 if (phba->sli_rev == LPFC_SLI_REV4) {
+                        if (phba->idiag_drb_acc) {
+                                /* iDiag drbAcc */
+                                debugfs_remove(phba->idiag_drb_acc);
+                                phba->idiag_drb_acc = NULL;
+                        }
+                        if (phba->idiag_que_acc) {
+                                /* iDiag queAcc */
+                                debugfs_remove(phba->idiag_que_acc);
+                                phba->idiag_que_acc = NULL;
+                        }
                         if (phba->idiag_que_info) {
                                 /* iDiag queInfo */
                                 debugfs_remove(phba->idiag_que_info);
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.h b/drivers/scsi/lpfc/lpfc_debugfs.h
index 91b9a9427cda..6525a5e62d27 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.h
+++ b/drivers/scsi/lpfc/lpfc_debugfs.h
@@ -39,13 +39,42 @@
 /* hbqinfo output buffer size */
 #define LPFC_HBQINFO_SIZE 8192
 
-/* rdPciConf output buffer size */
+/* pciConf */
+#define LPFC_PCI_CFG_BROWSE 0xffff
+#define LPFC_PCI_CFG_RD_CMD_ARG 2
+#define LPFC_PCI_CFG_WR_CMD_ARG 3
 #define LPFC_PCI_CFG_SIZE 4096
 #define LPFC_PCI_CFG_RD_BUF_SIZE (LPFC_PCI_CFG_SIZE/2)
 #define LPFC_PCI_CFG_RD_SIZE (LPFC_PCI_CFG_SIZE/4)
 
-/* queue info output buffer size */
-#define LPFC_QUE_INFO_GET_BUF_SIZE 2048
+/* queue info */
+#define LPFC_QUE_INFO_GET_BUF_SIZE 4096
+
+/* queue acc */
+#define LPFC_QUE_ACC_BROWSE 0xffff
+#define LPFC_QUE_ACC_RD_CMD_ARG 4
+#define LPFC_QUE_ACC_WR_CMD_ARG 6
+#define LPFC_QUE_ACC_BUF_SIZE 4096
+#define LPFC_QUE_ACC_SIZE (LPFC_QUE_ACC_BUF_SIZE/2)
+
+#define LPFC_IDIAG_EQ 1
+#define LPFC_IDIAG_CQ 2
+#define LPFC_IDIAG_MQ 3
+#define LPFC_IDIAG_WQ 4
+#define LPFC_IDIAG_RQ 5
+
+/* doorbell acc */
+#define LPFC_DRB_ACC_ALL 0xffff
+#define LPFC_DRB_ACC_RD_CMD_ARG 1
+#define LPFC_DRB_ACC_WR_CMD_ARG 2
+#define LPFC_DRB_ACC_BUF_SIZE 256
+
+#define LPFC_DRB_EQCQ 1
+#define LPFC_DRB_MQ   2
+#define LPFC_DRB_WQ   3
+#define LPFC_DRB_RQ   4
+
+#define LPFC_DRB_MAX  4
 
 #define SIZE_U8  sizeof(uint8_t)
 #define SIZE_U16 sizeof(uint16_t)
@@ -73,13 +102,23 @@ struct lpfc_idiag_offset {
         uint32_t last_rd;
 };
 
-#define LPFC_IDIAG_CMD_DATA_SIZE 4
+#define LPFC_IDIAG_CMD_DATA_SIZE 8
 struct lpfc_idiag_cmd {
         uint32_t opcode;
 #define LPFC_IDIAG_CMD_PCICFG_RD 0x00000001
 #define LPFC_IDIAG_CMD_PCICFG_WR 0x00000002
 #define LPFC_IDIAG_CMD_PCICFG_ST 0x00000003
 #define LPFC_IDIAG_CMD_PCICFG_CL 0x00000004
+
+#define LPFC_IDIAG_CMD_QUEACC_RD 0x00000011
+#define LPFC_IDIAG_CMD_QUEACC_WR 0x00000012
+#define LPFC_IDIAG_CMD_QUEACC_ST 0x00000013
+#define LPFC_IDIAG_CMD_QUEACC_CL 0x00000014
+
+#define LPFC_IDIAG_CMD_DRBACC_RD 0x00000021
+#define LPFC_IDIAG_CMD_DRBACC_WR 0x00000022
+#define LPFC_IDIAG_CMD_DRBACC_ST 0x00000023
+#define LPFC_IDIAG_CMD_DRBACC_CL 0x00000024
         uint32_t data[LPFC_IDIAG_CMD_DATA_SIZE];
 };
 
@@ -87,6 +126,7 @@ struct lpfc_idiag {
         uint32_t active;
         struct lpfc_idiag_cmd cmd;
         struct lpfc_idiag_offset offset;
+        void *ptr_private;
 };
 #endif
 
diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
index d34b69f9cdb1..e2c452467c8b 100644
--- a/drivers/scsi/lpfc/lpfc_els.c
+++ b/drivers/scsi/lpfc/lpfc_els.c
@@ -670,6 +670,7 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                          * Driver needs to re-reg VPI in order for f/w
                          * to update the MAC address.
                          */
+                        lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
                         lpfc_register_new_vport(phba, vport, ndlp);
                         return 0;
         }
@@ -869,8 +870,8 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                  */
                 if ((phba->hba_flag & HBA_FIP_SUPPORT) &&
                     (phba->fcf.fcf_flag & FCF_DISCOVERY) &&
-                    (irsp->ulpStatus != IOSTAT_LOCAL_REJECT) &&
-                    (irsp->un.ulpWord[4] != IOERR_SLI_ABORTED)) {
+                    !((irsp->ulpStatus == IOSTAT_LOCAL_REJECT) &&
+                     (irsp->un.ulpWord[4] == IOERR_SLI_ABORTED))) {
                         lpfc_printf_log(phba, KERN_WARNING, LOG_FIP | LOG_ELS,
                                         "2611 FLOGI failed on FCF (x%x), "
                                         "status:x%x/x%x, tmo:x%x, perform "
@@ -1085,14 +1086,15 @@ lpfc_issue_els_flogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         if (sp->cmn.fcphHigh < FC_PH3)
                 sp->cmn.fcphHigh = FC_PH3;
 
-        if  ((phba->sli_rev == LPFC_SLI_REV4) &&
-             (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
-              LPFC_SLI_INTF_IF_TYPE_0)) {
-                elsiocb->iocb.ulpCt_h = ((SLI4_CT_FCFI >> 1) & 1);
-                elsiocb->iocb.ulpCt_l = (SLI4_CT_FCFI & 1);
-                /* FLOGI needs to be 3 for WQE FCFI */
-                /* Set the fcfi to the fcfi we registered with */
-                elsiocb->iocb.ulpContext = phba->fcf.fcfi;
+        if  (phba->sli_rev == LPFC_SLI_REV4) {
+                if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
+                    LPFC_SLI_INTF_IF_TYPE_0) {
+                        elsiocb->iocb.ulpCt_h = ((SLI4_CT_FCFI >> 1) & 1);
+                        elsiocb->iocb.ulpCt_l = (SLI4_CT_FCFI & 1);
+                        /* FLOGI needs to be 3 for WQE FCFI */
+                        /* Set the fcfi to the fcfi we registered with */
+                        elsiocb->iocb.ulpContext = phba->fcf.fcfi;
+                }
         } else if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
                 sp->cmn.request_multiple_Nport = 1;
                 /* For FLOGI, Let FLOGI rsp set the NPortID for VPI 0 */
@@ -4107,13 +4109,13 @@ lpfc_els_clear_rrq(struct lpfc_vport *vport,
         pcmd += sizeof(uint32_t);
         rrq = (struct RRQ *)pcmd;
         rrq->rrq_exchg = be32_to_cpu(rrq->rrq_exchg);
-        rxid = be16_to_cpu(bf_get(rrq_rxid, rrq));
+        rxid = bf_get(rrq_rxid, rrq);
 
         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
                         "2883 Clear RRQ for SID:x%x OXID:x%x RXID:x%x"
                         " x%x x%x\n",
                         be32_to_cpu(bf_get(rrq_did, rrq)),
-                        be16_to_cpu(bf_get(rrq_oxid, rrq)),
+                        bf_get(rrq_oxid, rrq),
                         rxid,
                         iocb->iotag, iocb->iocb.ulpContext);
 
@@ -4121,7 +4123,7 @@ lpfc_els_clear_rrq(struct lpfc_vport *vport,
                 "Clear RRQ:  did:x%x flg:x%x exchg:x%.08x",
                 ndlp->nlp_DID, ndlp->nlp_flag, rrq->rrq_exchg);
         if (vport->fc_myDID == be32_to_cpu(bf_get(rrq_did, rrq)))
-                xri = be16_to_cpu(bf_get(rrq_oxid, rrq));
+                xri = bf_get(rrq_oxid, rrq);
         else
                 xri = rxid;
         prrq = lpfc_get_active_rrq(vport, xri, ndlp->nlp_DID);
@@ -7290,8 +7292,9 @@ lpfc_cmpl_els_npiv_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
         struct lpfc_vport *vport = cmdiocb->vport;
         IOCB_t *irsp;
         struct lpfc_nodelist *ndlp;
-        ndlp = (struct lpfc_nodelist *)cmdiocb->context1;
+        struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 
+        ndlp = (struct lpfc_nodelist *)cmdiocb->context1;
         irsp = &rspiocb->iocb;
         lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_CMD,
                 "LOGO npiv cmpl:  status:x%x/x%x did:x%x",
@@ -7302,6 +7305,19 @@ lpfc_cmpl_els_npiv_logo(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
 
         /* Trigger the release of the ndlp after logo */
         lpfc_nlp_put(ndlp);
+
+        /* NPIV LOGO completes to NPort <nlp_DID> */
+        lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
+                         "2928 NPIV LOGO completes to NPort x%x "
+                         "Data: x%x x%x x%x x%x\n",
+                         ndlp->nlp_DID, irsp->ulpStatus, irsp->un.ulpWord[4],
+                         irsp->ulpTimeout, vport->num_disc_nodes);
+
+        if (irsp->ulpStatus == IOSTAT_SUCCESS) {
+                spin_lock_irq(shost->host_lock);
+                vport->fc_flag &= ~FC_FABRIC;
+                spin_unlock_irq(shost->host_lock);
+        }
 }
 
 /**
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index 301498301a8f..7a35df5e2038 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2009 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2011 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -3569,6 +3569,10 @@ lpfc_register_remote_port(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
                 "rport add:       did:x%x flg:x%x type x%x",
                 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_type);
 
+        /* Don't add the remote port if unloading. */
+        if (vport->load_flag & FC_UNLOADING)
+                return;
+
         ndlp->rport = rport = fc_remote_port_add(shost, 0, &rport_ids);
         if (!rport || !get_device(&rport->dev)) {
                 dev_printk(KERN_WARNING, &phba->pcidev->dev,
diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h
index 8433ac0d9fb4..4dff668ebdad 100644
--- a/drivers/scsi/lpfc/lpfc_hw4.h
+++ b/drivers/scsi/lpfc/lpfc_hw4.h
@@ -1059,6 +1059,11 @@ struct rq_context {
 #define lpfc_rq_context_rqe_size_SHIFT  8               /* Version 1 Only */
 #define lpfc_rq_context_rqe_size_MASK   0x0000000F
 #define lpfc_rq_context_rqe_size_WORD   word0
+#define LPFC_RQE_SIZE_8         2
+#define LPFC_RQE_SIZE_16        3
+#define LPFC_RQE_SIZE_32        4
+#define LPFC_RQE_SIZE_64        5
+#define LPFC_RQE_SIZE_128       6
 #define lpfc_rq_context_page_size_SHIFT 0               /* Version 1 Only */
 #define lpfc_rq_context_page_size_MASK  0x000000FF
 #define lpfc_rq_context_page_size_WORD  word0
@@ -2108,6 +2113,8 @@ struct lpfc_mbx_pc_sli4_params {
 #define sgl_pp_align_WORD                       word12
         uint32_t rsvd_13_63[51];
 };
+#define SLI4_PAGE_ALIGN(addr) (((addr)+((SLI4_PAGE_SIZE)-1)) \
+                               &(~((SLI4_PAGE_SIZE)-1)))
 
 struct lpfc_sli4_parameters {
         uint32_t word0;
@@ -2491,6 +2498,9 @@ struct wqe_common {
 #define wqe_reqtag_SHIFT      0
 #define wqe_reqtag_MASK       0x0000FFFF
 #define wqe_reqtag_WORD       word9
+#define wqe_temp_rpi_SHIFT    16
+#define wqe_temp_rpi_MASK     0x0000FFFF
+#define wqe_temp_rpi_WORD     word9
 #define wqe_rcvoxid_SHIFT     16
 #define wqe_rcvoxid_MASK      0x0000FFFF
 #define wqe_rcvoxid_WORD      word9
@@ -2524,7 +2534,7 @@ struct wqe_common {
 #define wqe_wqes_WORD         word10
 /* Note that this field overlaps above fields */
 #define wqe_wqid_SHIFT        1
-#define wqe_wqid_MASK         0x0000007f
+#define wqe_wqid_MASK         0x00007fff
 #define wqe_wqid_WORD         word10
 #define wqe_pri_SHIFT         16
 #define wqe_pri_MASK          0x00000007
@@ -2621,7 +2631,11 @@ struct xmit_els_rsp64_wqe {
         uint32_t rsvd4;
         struct wqe_did wqe_dest;
         struct wqe_common wqe_com; /* words 6-11 */
-        uint32_t rsvd_12_15[4];
+        uint32_t word12;
+#define wqe_rsp_temp_rpi_SHIFT    0
+#define wqe_rsp_temp_rpi_MASK     0x0000FFFF
+#define wqe_rsp_temp_rpi_WORD     word12
+        uint32_t rsvd_13_15[3];
 };
 
 struct xmit_bls_rsp64_wqe {
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index 505f88443b5c..7dda036a1af3 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -3209,9 +3209,9 @@ lpfc_sli4_async_link_evt(struct lpfc_hba *phba,
         phba->sli4_hba.link_state.logical_speed =
                         bf_get(lpfc_acqe_logical_link_speed, acqe_link);
         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
-                        "2900 Async FCoE Link event - Speed:%dGBit duplex:x%x "
-                        "LA Type:x%x Port Type:%d Port Number:%d Logical "
-                        "speed:%dMbps Fault:%d\n",
+                        "2900 Async FC/FCoE Link event - Speed:%dGBit "
+                        "duplex:x%x LA Type:x%x Port Type:%d Port Number:%d "
+                        "Logical speed:%dMbps Fault:%d\n",
                         phba->sli4_hba.link_state.speed,
                         phba->sli4_hba.link_state.topology,
                         phba->sli4_hba.link_state.status,
@@ -4906,6 +4906,7 @@ lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
         uint16_t rpi_limit, curr_rpi_range;
         struct lpfc_dmabuf *dmabuf;
         struct lpfc_rpi_hdr *rpi_hdr;
+        uint32_t rpi_count;
 
         rpi_limit = phba->sli4_hba.max_cfg_param.rpi_base +
                     phba->sli4_hba.max_cfg_param.max_rpi - 1;
@@ -4920,7 +4921,9 @@ lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
          * and to allow the full max_rpi range per port.
          */
         if ((curr_rpi_range + (LPFC_RPI_HDR_COUNT - 1)) > rpi_limit)
-                return NULL;
+                rpi_count = rpi_limit - curr_rpi_range;
+        else
+                rpi_count = LPFC_RPI_HDR_COUNT;
 
         /*
          * First allocate the protocol header region for the port.  The
@@ -4961,7 +4964,7 @@ lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
          * The next_rpi stores the next module-64 rpi value to post
          * in any subsequent rpi memory region postings.
          */
-        phba->sli4_hba.next_rpi += LPFC_RPI_HDR_COUNT;
+        phba->sli4_hba.next_rpi += rpi_count;
         spin_unlock_irq(&phba->hbalock);
         return rpi_hdr;
 
@@ -7004,7 +7007,8 @@ lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba)
                 lpfc_sli4_bar0_register_memmap(phba, if_type);
         }
 
-        if (pci_resource_start(pdev, 2)) {
+        if ((if_type == LPFC_SLI_INTF_IF_TYPE_0) &&
+            (pci_resource_start(pdev, 2))) {
                 /*
                  * Map SLI4 if type 0 HBA Control Register base to a kernel
                  * virtual address and setup the registers.
@@ -7021,7 +7025,8 @@ lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba)
                 lpfc_sli4_bar1_register_memmap(phba);
         }
 
-        if (pci_resource_start(pdev, 4)) {
+        if ((if_type == LPFC_SLI_INTF_IF_TYPE_0) &&
+            (pci_resource_start(pdev, 4))) {
                 /*
                  * Map SLI4 if type 0 HBA Doorbell Register base to a kernel
                  * virtual address and setup the registers.
diff --git a/drivers/scsi/lpfc/lpfc_mbox.c b/drivers/scsi/lpfc/lpfc_mbox.c
index fbab9734e9b4..e6ce9033f85e 100644
--- a/drivers/scsi/lpfc/lpfc_mbox.c
+++ b/drivers/scsi/lpfc/lpfc_mbox.c
@@ -1736,7 +1736,7 @@ lpfc_sli4_config(struct lpfc_hba *phba, struct lpfcMboxq *mbox,
         }
 
         /* Setup for the none-embedded mbox command */
-        pcount = (PAGE_ALIGN(length))/SLI4_PAGE_SIZE;
+        pcount = (SLI4_PAGE_ALIGN(length))/SLI4_PAGE_SIZE;
         pcount = (pcount > LPFC_SLI4_MBX_SGE_MAX_PAGES) ?
                                 LPFC_SLI4_MBX_SGE_MAX_PAGES : pcount;
         /* Allocate record for keeping SGE virtual addresses */
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index fe7cc84e773b..84e4481b2406 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -3238,9 +3238,8 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
         if (!lpfc_cmd) {
                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
                          "2873 SCSI Layer I/O Abort Request IO CMPL Status "
-                         "x%x ID %d "
-                         "LUN %d snum %#lx\n", ret, cmnd->device->id,
-                         cmnd->device->lun, cmnd->serial_number);
+                         "x%x ID %d LUN %d\n",
+                         ret, cmnd->device->id, cmnd->device->lun);
                 return SUCCESS;
         }
 
@@ -3318,16 +3317,15 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
                                  "0748 abort handler timed out waiting "
                                  "for abort to complete: ret %#x, ID %d, "
-                                 "LUN %d, snum %#lx\n",
-                                 ret, cmnd->device->id, cmnd->device->lun,
-                                 cmnd->serial_number);
+                                 "LUN %d\n",
+                                 ret, cmnd->device->id, cmnd->device->lun);
         }
 
  out:
         lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
                          "0749 SCSI Layer I/O Abort Request Status x%x ID %d "
-                         "LUN %d snum %#lx\n", ret, cmnd->device->id,
-                         cmnd->device->lun, cmnd->serial_number);
+                         "LUN %d\n", ret, cmnd->device->id,
+                         cmnd->device->lun);
         return ret;
 }
 
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index dacabbe0a586..837d272cb2d6 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -4769,8 +4769,7 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         else
                 phba->hba_flag &= ~HBA_FIP_SUPPORT;
 
-        if (phba->sli_rev != LPFC_SLI_REV4 ||
-            !(phba->hba_flag & HBA_FCOE_MODE)) {
+        if (phba->sli_rev != LPFC_SLI_REV4) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
                         "0376 READ_REV Error. SLI Level %d "
                         "FCoE enabled %d\n",
@@ -5018,10 +5017,11 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
                 lpfc_reg_fcfi(phba, mboxq);
                 mboxq->vport = phba->pport;
                 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
-                if (rc == MBX_SUCCESS)
-                        rc = 0;
-                else
+                if (rc != MBX_SUCCESS)
                         goto out_unset_queue;
+                rc = 0;
+                phba->fcf.fcfi = bf_get(lpfc_reg_fcfi_fcfi,
+                                        &mboxq->u.mqe.un.reg_fcfi);
         }
         /*
          * The port is ready, set the host's link state to LINK_DOWN
@@ -6402,6 +6402,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
         uint32_t els_id = LPFC_ELS_ID_DEFAULT;
         int numBdes, i;
         struct ulp_bde64 bde;
+        struct lpfc_nodelist *ndlp;
 
         fip = phba->hba_flag & HBA_FIP_SUPPORT;
         /* The fcp commands will set command type */
@@ -6447,6 +6448,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
 
         switch (iocbq->iocb.ulpCommand) {
         case CMD_ELS_REQUEST64_CR:
+                ndlp = (struct lpfc_nodelist *)iocbq->context1;
                 if (!iocbq->iocb.ulpLe) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "2007 Only Limited Edition cmd Format"
@@ -6472,6 +6474,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                         els_id = ((iocbq->iocb_flag & LPFC_FIP_ELS_ID_MASK)
                                         >> LPFC_FIP_ELS_ID_SHIFT);
                 }
+                bf_set(wqe_temp_rpi, &wqe->els_req.wqe_com, ndlp->nlp_rpi);
                 bf_set(wqe_els_id, &wqe->els_req.wqe_com, els_id);
                 bf_set(wqe_dbde, &wqe->els_req.wqe_com, 1);
                 bf_set(wqe_iod, &wqe->els_req.wqe_com, LPFC_WQE_IOD_READ);
@@ -6604,6 +6607,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 command_type = OTHER_COMMAND;
         break;
         case CMD_XMIT_ELS_RSP64_CX:
+                ndlp = (struct lpfc_nodelist *)iocbq->context1;
                 /* words0-2 BDE memcpy */
                 /* word3 iocb=iotag32 wqe=response_payload_len */
                 wqe->xmit_els_rsp.response_payload_len = xmit_len;
@@ -6626,6 +6630,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 bf_set(wqe_lenloc, &wqe->xmit_els_rsp.wqe_com,
                        LPFC_WQE_LENLOC_WORD3);
                 bf_set(wqe_ebde_cnt, &wqe->xmit_els_rsp.wqe_com, 0);
+                bf_set(wqe_rsp_temp_rpi, &wqe->xmit_els_rsp, ndlp->nlp_rpi);
                 command_type = OTHER_COMMAND;
         break;
         case CMD_CLOSE_XRI_CN:
@@ -10522,8 +10527,8 @@ lpfc_cq_create(struct lpfc_hba *phba, struct lpfc_queue *cq,
         bf_set(lpfc_mbox_hdr_version, &shdr->request,
                phba->sli4_hba.pc_sli4_params.cqv);
         if (phba->sli4_hba.pc_sli4_params.cqv == LPFC_Q_CREATE_VERSION_2) {
-                bf_set(lpfc_mbx_cq_create_page_size, &cq_create->u.request,
-                       (PAGE_SIZE/SLI4_PAGE_SIZE));
+                /* FW only supports 1. Should be PAGE_SIZE/SLI4_PAGE_SIZE */
+                bf_set(lpfc_mbx_cq_create_page_size, &cq_create->u.request, 1);
                 bf_set(lpfc_cq_eq_id_2, &cq_create->u.request.context,
                        eq->queue_id);
         } else {
@@ -10967,6 +10972,12 @@ lpfc_rq_create(struct lpfc_hba *phba, struct lpfc_queue *hrq,
                        &rq_create->u.request.context,
                        hrq->entry_count);
                 rq_create->u.request.context.buffer_size = LPFC_HDR_BUF_SIZE;
+                bf_set(lpfc_rq_context_rqe_size,
+                       &rq_create->u.request.context,
+                       LPFC_RQE_SIZE_8);
+                bf_set(lpfc_rq_context_page_size,
+                       &rq_create->u.request.context,
+                       (PAGE_SIZE/SLI4_PAGE_SIZE));
         } else {
                 switch (hrq->entry_count) {
                 default:
@@ -11042,9 +11053,12 @@ lpfc_rq_create(struct lpfc_hba *phba, struct lpfc_queue *hrq,
                phba->sli4_hba.pc_sli4_params.rqv);
         if (phba->sli4_hba.pc_sli4_params.rqv == LPFC_Q_CREATE_VERSION_1) {
                 bf_set(lpfc_rq_context_rqe_count_1,
-                       &rq_create->u.request.context,
-                       hrq->entry_count);
+                       &rq_create->u.request.context, hrq->entry_count);
                 rq_create->u.request.context.buffer_size = LPFC_DATA_BUF_SIZE;
+                bf_set(lpfc_rq_context_rqe_size, &rq_create->u.request.context,
+                       LPFC_RQE_SIZE_8);
+                bf_set(lpfc_rq_context_page_size, &rq_create->u.request.context,
+                       (PAGE_SIZE/SLI4_PAGE_SIZE));
         } else {
                 switch (drq->entry_count) {
                 default:
diff --git a/drivers/scsi/lpfc/lpfc_version.h b/drivers/scsi/lpfc/lpfc_version.h
index 2404d1d65563..c03921b1232c 100644
--- a/drivers/scsi/lpfc/lpfc_version.h
+++ b/drivers/scsi/lpfc/lpfc_version.h
@@ -18,7 +18,7 @@
  * included with this package.                                     *
  *******************************************************************/
 
-#define LPFC_DRIVER_VERSION "8.3.22"
+#define LPFC_DRIVER_VERSION "8.3.23"
 #define LPFC_DRIVER_NAME                "lpfc"
 #define LPFC_SP_DRIVER_HANDLER_NAME     "lpfc:sp"
 #define LPFC_FP_DRIVER_HANDLER_NAME     "lpfc:fp"
diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index f2684dd09ed0..5c1776406c96 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -1469,8 +1469,8 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
                         if( scb->state & SCB_ABORT ) {
 
                                 printk(KERN_WARNING
-                                "megaraid: aborted cmd %lx[%x] complete.\n",
-                                        scb->cmd->serial_number, scb->idx);
+                                "megaraid: aborted cmd [%x] complete.\n",
+                                        scb->idx);
 
                                 scb->cmd->result = (DID_ABORT << 16);
 
@@ -1488,8 +1488,8 @@ mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
                         if( scb->state & SCB_RESET ) {
 
                                 printk(KERN_WARNING
-                                "megaraid: reset cmd %lx[%x] complete.\n",
-                                        scb->cmd->serial_number, scb->idx);
+                                "megaraid: reset cmd [%x] complete.\n",
+                                        scb->idx);
 
                                 scb->cmd->result = (DID_RESET << 16);
 
@@ -1958,8 +1958,8 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
         struct list_head        *pos, *next;
         scb_t                   *scb;
 
-        printk(KERN_WARNING "megaraid: %s-%lx cmd=%x <c=%d t=%d l=%d>\n",
-             (aor == SCB_ABORT)? "ABORTING":"RESET", cmd->serial_number,
+        printk(KERN_WARNING "megaraid: %s cmd=%x <c=%d t=%d l=%d>\n",
+             (aor == SCB_ABORT)? "ABORTING":"RESET",
              cmd->cmnd[0], cmd->device->channel, 
              cmd->device->id, cmd->device->lun);
 
@@ -1983,9 +1983,9 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
                         if( scb->state & SCB_ISSUED ) {
 
                                 printk(KERN_WARNING
-                                        "megaraid: %s-%lx[%x], fw owner.\n",
+                                        "megaraid: %s[%x], fw owner.\n",
                                         (aor==SCB_ABORT) ? "ABORTING":"RESET",
-                                        cmd->serial_number, scb->idx);
+                                        scb->idx);
 
                                 return FALSE;
                         }
@@ -1996,9 +1996,9 @@ megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
                                  * list
                                  */
                                 printk(KERN_WARNING
-                                        "megaraid: %s-%lx[%x], driver owner.\n",
+                                        "megaraid: %s-[%x], driver owner.\n",
                                         (aor==SCB_ABORT) ? "ABORTING":"RESET",
-                                        cmd->serial_number, scb->idx);
+                                        scb->idx);
 
                                 mega_free_scb(adapter, scb);
 
diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index 1dba32870b4c..2e6619eff3ea 100644
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -2315,8 +2315,8 @@ megaraid_mbox_dpc(unsigned long devp)
                 // Was an abort issued for this command earlier
                 if (scb->state & SCB_ABORT) {
                         con_log(CL_ANN, (KERN_NOTICE
-                        "megaraid: aborted cmd %lx[%x] completed\n",
-                                scp->serial_number, scb->sno));
+                        "megaraid: aborted cmd [%x] completed\n",
+                                scb->sno));
                 }
 
                 /*
@@ -2472,8 +2472,8 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
         raid_dev        = ADAP2RAIDDEV(adapter);
 
         con_log(CL_ANN, (KERN_WARNING
-                "megaraid: aborting-%ld cmd=%x <c=%d t=%d l=%d>\n",
-                scp->serial_number, scp->cmnd[0], SCP2CHANNEL(scp),
+                "megaraid: aborting cmd=%x <c=%d t=%d l=%d>\n",
+                scp->cmnd[0], SCP2CHANNEL(scp),
                 SCP2TARGET(scp), SCP2LUN(scp)));
 
         // If FW has stopped responding, simply return failure
@@ -2496,9 +2496,8 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
                         list_del_init(&scb->list);      // from completed list
 
                         con_log(CL_ANN, (KERN_WARNING
-                        "megaraid: %ld:%d[%d:%d], abort from completed list\n",
-                                scp->serial_number, scb->sno,
-                                scb->dev_channel, scb->dev_target));
+                        "megaraid: %d[%d:%d], abort from completed list\n",
+                                scb->sno, scb->dev_channel, scb->dev_target));
 
                         scp->result = (DID_ABORT << 16);
                         scp->scsi_done(scp);
@@ -2527,9 +2526,8 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
                         ASSERT(!(scb->state & SCB_ISSUED));
 
                         con_log(CL_ANN, (KERN_WARNING
-                                "megaraid abort: %ld[%d:%d], driver owner\n",
-                                scp->serial_number, scb->dev_channel,
-                                scb->dev_target));
+                                "megaraid abort: [%d:%d], driver owner\n",
+                                scb->dev_channel, scb->dev_target));
 
                         scp->result = (DID_ABORT << 16);
                         scp->scsi_done(scp);
@@ -2560,25 +2558,21 @@ megaraid_abort_handler(struct scsi_cmnd *scp)
 
                         if (!(scb->state & SCB_ISSUED)) {
                                 con_log(CL_ANN, (KERN_WARNING
-                                "megaraid abort: %ld%d[%d:%d], invalid state\n",
-                                scp->serial_number, scb->sno, scb->dev_channel,
-                                scb->dev_target));
+                                "megaraid abort: %d[%d:%d], invalid state\n",
+                                scb->sno, scb->dev_channel, scb->dev_target));
                                 BUG();
                         }
                         else {
                                 con_log(CL_ANN, (KERN_WARNING
-                                "megaraid abort: %ld:%d[%d:%d], fw owner\n",
-                                scp->serial_number, scb->sno, scb->dev_channel,
-                                scb->dev_target));
+                                "megaraid abort: %d[%d:%d], fw owner\n",
+                                scb->sno, scb->dev_channel, scb->dev_target));
                         }
                 }
         }
         spin_unlock_irq(&adapter->lock);
 
         if (!found) {
-                con_log(CL_ANN, (KERN_WARNING
-                        "megaraid abort: scsi cmd:%ld, do now own\n",
-                        scp->serial_number));
+                con_log(CL_ANN, (KERN_WARNING "megaraid abort: do now own\n"));
 
                 // FIXME: Should there be a callback for this command?
                 return SUCCESS;
@@ -2649,9 +2643,8 @@ megaraid_reset_handler(struct scsi_cmnd *scp)
                 } else {
                         if (scb->scp == scp) {  // Found command
                                 con_log(CL_ANN, (KERN_WARNING
-                                        "megaraid: %ld:%d[%d:%d], reset from pending list\n",
-                                        scp->serial_number, scb->sno,
-                                        scb->dev_channel, scb->dev_target));
+                                        "megaraid: %d[%d:%d], reset from pending list\n",
+                                        scb->sno, scb->dev_channel, scb->dev_target));
                         } else {
                                 con_log(CL_ANN, (KERN_WARNING
                                 "megaraid: IO packet with %d[%d:%d] being reset\n",
diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 66d4cea4df98..89c623ebadbc 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -1751,10 +1751,9 @@ static int megasas_wait_for_outstanding(struct megasas_instance *instance)
                         list_del_init(&reset_cmd->list);
                         if (reset_cmd->scmd) {
                                 reset_cmd->scmd->result = DID_RESET << 16;
-                                printk(KERN_NOTICE "%d:%p reset [%02x], %#lx\n",
+                                printk(KERN_NOTICE "%d:%p reset [%02x]\n",
                                         reset_index, reset_cmd,
-                                        reset_cmd->scmd->cmnd[0],
-                                        reset_cmd->scmd->serial_number);
+                                        reset_cmd->scmd->cmnd[0]);
 
                                 reset_cmd->scmd->scsi_done(reset_cmd->scmd);
                                 megasas_return_cmd(instance, reset_cmd);
@@ -1879,8 +1878,8 @@ static int megasas_generic_reset(struct scsi_cmnd *scmd)
 
         instance = (struct megasas_instance *)scmd->device->host->hostdata;
 
-        scmd_printk(KERN_NOTICE, scmd, "megasas: RESET -%ld cmd=%x retries=%x\n",
-                 scmd->serial_number, scmd->cmnd[0], scmd->retries);
+        scmd_printk(KERN_NOTICE, scmd, "megasas: RESET cmd=%x retries=%x\n",
+                 scmd->cmnd[0], scmd->retries);
 
         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
                 printk(KERN_ERR "megasas: cannot recover from previous reset "
@@ -2349,9 +2348,9 @@ megasas_issue_pending_cmds_again(struct megasas_instance *instance)
                                                         cmd->frame_phys_addr ,
                                                         0, instance->reg_set);
                 } else if (cmd->scmd) {
-                        printk(KERN_NOTICE "megasas: %p scsi cmd [%02x],%#lx"
+                        printk(KERN_NOTICE "megasas: %p scsi cmd [%02x]"
                         "detected on the internal queue, issue again.\n",
-                        cmd, cmd->scmd->cmnd[0], cmd->scmd->serial_number);
+                        cmd, cmd->scmd->cmnd[0]);
 
                         atomic_inc(&instance->fw_outstanding);
                         instance->instancet->fire_cmd(instance,
diff --git a/drivers/scsi/mesh.c b/drivers/scsi/mesh.c
index 197aa1b3f0f3..494474779532 100644
--- a/drivers/scsi/mesh.c
+++ b/drivers/scsi/mesh.c
@@ -415,8 +415,7 @@ static void mesh_start_cmd(struct mesh_state *ms, struct scsi_cmnd *cmd)
 #if 1
         if (DEBUG_TARGET(cmd)) {
                 int i;
-                printk(KERN_DEBUG "mesh_start: %p ser=%lu tgt=%d cmd=",
-                       cmd, cmd->serial_number, id);
+                printk(KERN_DEBUG "mesh_start: %p tgt=%d cmd=", cmd, id);
                 for (i = 0; i < cmd->cmd_len; ++i)
                         printk(" %x", cmd->cmnd[i]);
                 printk(" use_sg=%d buffer=%p bufflen=%u\n",
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.c b/drivers/scsi/mpt2sas/mpt2sas_base.c
index 3346357031e9..efa0255491c2 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.c
@@ -522,7 +522,8 @@ _base_display_event_data(struct MPT2SAS_ADAPTER *ioc,
                 desc = "Device Status Change";
                 break;
         case MPI2_EVENT_IR_OPERATION_STATUS:
-                desc = "IR Operation Status";
+                if (!ioc->hide_ir_msg)
+                        desc = "IR Operation Status";
                 break;
         case MPI2_EVENT_SAS_DISCOVERY:
         {
@@ -553,16 +554,20 @@ _base_display_event_data(struct MPT2SAS_ADAPTER *ioc,
                 desc = "SAS Enclosure Device Status Change";
                 break;
         case MPI2_EVENT_IR_VOLUME:
-                desc = "IR Volume";
+                if (!ioc->hide_ir_msg)
+                        desc = "IR Volume";
                 break;
         case MPI2_EVENT_IR_PHYSICAL_DISK:
-                desc = "IR Physical Disk";
+                if (!ioc->hide_ir_msg)
+                        desc = "IR Physical Disk";
                 break;
         case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST:
-                desc = "IR Configuration Change List";
+                if (!ioc->hide_ir_msg)
+                        desc = "IR Configuration Change List";
                 break;
         case MPI2_EVENT_LOG_ENTRY_ADDED:
-                desc = "Log Entry Added";
+                if (!ioc->hide_ir_msg)
+                        desc = "Log Entry Added";
                 break;
         }
 
@@ -616,7 +621,10 @@ _base_sas_log_info(struct MPT2SAS_ADAPTER *ioc , u32 log_info)
                 originator_str = "PL";
                 break;
         case 2:
-                originator_str = "IR";
+                if (!ioc->hide_ir_msg)
+                        originator_str = "IR";
+                else
+                        originator_str = "WarpDrive";
                 break;
         }
 
@@ -1508,6 +1516,7 @@ mpt2sas_base_free_smid(struct MPT2SAS_ADAPTER *ioc, u16 smid)
                 }
                 ioc->scsi_lookup[i].cb_idx = 0xFF;
                 ioc->scsi_lookup[i].scmd = NULL;
+                ioc->scsi_lookup[i].direct_io = 0;
                 list_add_tail(&ioc->scsi_lookup[i].tracker_list,
                     &ioc->free_list);
                 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
@@ -1844,10 +1853,12 @@ _base_display_ioc_capabilities(struct MPT2SAS_ADAPTER *ioc)
         printk("), ");
         printk("Capabilities=(");
 
-        if (ioc->facts.IOCCapabilities &
-            MPI2_IOCFACTS_CAPABILITY_INTEGRATED_RAID) {
-                printk("Raid");
-                i++;
+        if (!ioc->hide_ir_msg) {
+                if (ioc->facts.IOCCapabilities &
+                    MPI2_IOCFACTS_CAPABILITY_INTEGRATED_RAID) {
+                        printk("Raid");
+                        i++;
+                }
         }
 
         if (ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR) {
@@ -3680,6 +3691,7 @@ _base_make_ioc_operational(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
         u32 reply_address;
         u16 smid;
         struct _tr_list *delayed_tr, *delayed_tr_next;
+        u8 hide_flag;
 
         dinitprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
             __func__));
@@ -3706,6 +3718,7 @@ _base_make_ioc_operational(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
                 ioc->scsi_lookup[i].cb_idx = 0xFF;
                 ioc->scsi_lookup[i].smid = smid;
                 ioc->scsi_lookup[i].scmd = NULL;
+                ioc->scsi_lookup[i].direct_io = 0;
                 list_add_tail(&ioc->scsi_lookup[i].tracker_list,
                     &ioc->free_list);
         }
@@ -3766,6 +3779,15 @@ _base_make_ioc_operational(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
         if (sleep_flag == CAN_SLEEP)
                 _base_static_config_pages(ioc);
 
+        if (ioc->wait_for_port_enable_to_complete && ioc->is_warpdrive) {
+                if (ioc->manu_pg10.OEMIdentifier  == 0x80) {
+                        hide_flag = (u8) (ioc->manu_pg10.OEMSpecificFlags0 &
+                            MFG_PAGE10_HIDE_SSDS_MASK);
+                        if (hide_flag != MFG_PAGE10_HIDE_SSDS_MASK)
+                                ioc->mfg_pg10_hide_flag = hide_flag;
+                }
+        }
+
         if (ioc->wait_for_port_enable_to_complete) {
                 if (diag_buffer_enable != 0)
                         mpt2sas_enable_diag_buffer(ioc, diag_buffer_enable);
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.h b/drivers/scsi/mpt2sas/mpt2sas_base.h
index 500328245f61..2a3c05f6db8b 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.h
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.h
@@ -69,11 +69,11 @@
 #define MPT2SAS_DRIVER_NAME             "mpt2sas"
 #define MPT2SAS_AUTHOR  "LSI Corporation <DL-MPTFusionLinux@lsi.com>"
 #define MPT2SAS_DESCRIPTION     "LSI MPT Fusion SAS 2.0 Device Driver"
-#define MPT2SAS_DRIVER_VERSION          "08.100.00.00"
+#define MPT2SAS_DRIVER_VERSION          "08.100.00.01"
 #define MPT2SAS_MAJOR_VERSION           08
 #define MPT2SAS_MINOR_VERSION           100
 #define MPT2SAS_BUILD_VERSION           00
-#define MPT2SAS_RELEASE_VERSION         00
+#define MPT2SAS_RELEASE_VERSION         01
 
 /*
  * Set MPT2SAS_SG_DEPTH value based on user input.
@@ -189,6 +189,16 @@
 #define MPT2SAS_HP_DAUGHTER_2_4_INTERNAL_SSDID        0x0046
 
 /*
+ *  WarpDrive Specific Log codes
+ */
+
+#define MPT2_WARPDRIVE_LOGENTRY         (0x8002)
+#define MPT2_WARPDRIVE_LC_SSDT          (0x41)
+#define MPT2_WARPDRIVE_LC_SSDLW         (0x43)
+#define MPT2_WARPDRIVE_LC_SSDLF         (0x44)
+#define MPT2_WARPDRIVE_LC_BRMF          (0x4D)
+
+/*
  * per target private data
  */
 #define MPT_TARGET_FLAGS_RAID_COMPONENT 0x01
@@ -199,6 +209,7 @@
  * struct MPT2SAS_TARGET - starget private hostdata
  * @starget: starget object
  * @sas_address: target sas address
+ * @raid_device: raid_device pointer to access volume data
  * @handle: device handle
  * @num_luns: number luns
  * @flags: MPT_TARGET_FLAGS_XXX flags
@@ -208,6 +219,7 @@
 struct MPT2SAS_TARGET {
         struct scsi_target *starget;
         u64     sas_address;
+        struct _raid_device *raid_device;
         u16     handle;
         int     num_luns;
         u32     flags;
@@ -215,6 +227,7 @@ struct MPT2SAS_TARGET {
         u8      tm_busy;
 };
 
+
 /*
  * per device private data
  */
@@ -262,6 +275,12 @@ typedef struct _MPI2_CONFIG_PAGE_MAN_10 {
   MPI2_POINTER PTR_MPI2_CONFIG_PAGE_MAN_10,
   Mpi2ManufacturingPage10_t, MPI2_POINTER pMpi2ManufacturingPage10_t;
 
+#define MFG_PAGE10_HIDE_SSDS_MASK       (0x00000003)
+#define MFG_PAGE10_HIDE_ALL_DISKS       (0x00)
+#define MFG_PAGE10_EXPOSE_ALL_DISKS     (0x01)
+#define MFG_PAGE10_HIDE_IF_VOL_PRESENT  (0x02)
+
+
 struct MPT2SAS_DEVICE {
         struct MPT2SAS_TARGET *sas_target;
         unsigned int    lun;
@@ -341,6 +360,7 @@ struct _sas_device {
  * @sdev: scsi device struct (volumes are single lun)
  * @wwid: unique identifier for the volume
  * @handle: device handle
+ * @block_size: Block size of the volume
  * @id: target id
  * @channel: target channel
  * @volume_type: the raid level
@@ -348,20 +368,33 @@ struct _sas_device {
  * @num_pds: number of hidden raid components
  * @responding: used in _scsih_raid_device_mark_responding
  * @percent_complete: resync percent complete
+ * @direct_io_enabled: Whether direct io to PDs are allowed or not
+ * @stripe_exponent: X where 2powX is the stripe sz in blocks
+ * @max_lba: Maximum number of LBA in the volume
+ * @stripe_sz: Stripe Size of the volume
+ * @device_info: Device info of the volume member disk
+ * @pd_handle: Array of handles of the physical drives for direct I/O in le16
  */
+#define MPT_MAX_WARPDRIVE_PDS           8
 struct _raid_device {
         struct list_head list;
         struct scsi_target *starget;
         struct scsi_device *sdev;
         u64     wwid;
         u16     handle;
+        u16     block_sz;
         int     id;
         int     channel;
         u8      volume_type;
-        u32     device_info;
         u8      num_pds;
         u8      responding;
         u8      percent_complete;
+        u8      direct_io_enabled;
+        u8      stripe_exponent;
+        u64     max_lba;
+        u32     stripe_sz;
+        u32     device_info;
+        u16     pd_handle[MPT_MAX_WARPDRIVE_PDS];
 };
 
 /**
@@ -470,6 +503,7 @@ struct chain_tracker {
  * @smid: system message id
  * @scmd: scsi request pointer
  * @cb_idx: callback index
+ * @direct_io: To indicate whether I/O is direct (WARPDRIVE)
  * @chain_list: list of chains associated to this IO
  * @tracker_list: list of free request (ioc->free_list)
  */
@@ -477,14 +511,14 @@ struct scsiio_tracker {
         u16     smid;
         struct scsi_cmnd *scmd;
         u8      cb_idx;
+        u8      direct_io;
         struct list_head chain_list;
         struct list_head tracker_list;
 };
 
 /**
- * struct request_tracker - misc mf request tracker
+ * struct request_tracker - firmware request tracker
  * @smid: system message id
- * @scmd: scsi request pointer
  * @cb_idx: callback index
  * @tracker_list: list of free request (ioc->free_list)
  */
@@ -832,6 +866,11 @@ struct MPT2SAS_ADAPTER {
         u32             diagnostic_flags[MPI2_DIAG_BUF_TYPE_COUNT];
         u32             ring_buffer_offset;
         u32             ring_buffer_sz;
+        u8              is_warpdrive;
+        u8              hide_ir_msg;
+        u8              mfg_pg10_hide_flag;
+        u8              hide_drives;
+
 };
 
 typedef u8 (*MPT_CALLBACK)(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
diff --git a/drivers/scsi/mpt2sas/mpt2sas_ctl.c b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
index d72f1f2b1392..437c2d94c45a 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_ctl.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
@@ -1041,7 +1041,10 @@ _ctl_getiocinfo(void __user *arg)
             __func__));
 
         memset(&karg, 0 , sizeof(karg));
-        karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2;
+        if (ioc->is_warpdrive)
+                karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2_SSS6200;
+        else
+                karg.adapter_type = MPT2_IOCTL_INTERFACE_SAS2;
         if (ioc->pfacts)
                 karg.port_number = ioc->pfacts[0].PortNumber;
         pci_read_config_byte(ioc->pdev, PCI_CLASS_REVISION, &revision);
diff --git a/drivers/scsi/mpt2sas/mpt2sas_ctl.h b/drivers/scsi/mpt2sas/mpt2sas_ctl.h
index 69916e46e04f..11ff1d5fb8f0 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_ctl.h
+++ b/drivers/scsi/mpt2sas/mpt2sas_ctl.h
@@ -133,6 +133,7 @@ struct mpt2_ioctl_pci_info {
 #define MPT2_IOCTL_INTERFACE_FC_IP      (0x02)
 #define MPT2_IOCTL_INTERFACE_SAS        (0x03)
 #define MPT2_IOCTL_INTERFACE_SAS2       (0x04)
+#define MPT2_IOCTL_INTERFACE_SAS2_SSS6200       (0x05)
 #define MPT2_IOCTL_VERSION_LENGTH       (32)
 
 /**
diff --git a/drivers/scsi/mpt2sas/mpt2sas_scsih.c b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
index d2064a0533ae..f12e02358d6d 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_scsih.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
@@ -233,6 +233,9 @@ static struct pci_device_id scsih_pci_table[] = {
                 PCI_ANY_ID, PCI_ANY_ID },
         { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_3,
                 PCI_ANY_ID, PCI_ANY_ID },
+        /* SSS6200 */
+        { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SSS6200,
+                PCI_ANY_ID, PCI_ANY_ID },
         {0}     /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(pci, scsih_pci_table);
@@ -1256,6 +1259,7 @@ _scsih_target_alloc(struct scsi_target *starget)
                         sas_target_priv_data->handle = raid_device->handle;
                         sas_target_priv_data->sas_address = raid_device->wwid;
                         sas_target_priv_data->flags |= MPT_TARGET_FLAGS_VOLUME;
+                        sas_target_priv_data->raid_device = raid_device;
                         raid_device->starget = starget;
                 }
                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
@@ -1455,7 +1459,10 @@ static int
 _scsih_is_raid(struct device *dev)
 {
         struct scsi_device *sdev = to_scsi_device(dev);
+        struct MPT2SAS_ADAPTER *ioc = shost_priv(sdev->host);
 
+        if (ioc->is_warpdrive)
+                return 0;
         return (sdev->channel == RAID_CHANNEL) ? 1 : 0;
 }
 
@@ -1480,7 +1487,7 @@ _scsih_get_resync(struct device *dev)
             sdev->channel);
         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
 
-        if (!raid_device)
+        if (!raid_device || ioc->is_warpdrive)
                 goto out;
 
         if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
@@ -1640,6 +1647,212 @@ _scsih_get_volume_capabilities(struct MPT2SAS_ADAPTER *ioc,
 
         kfree(vol_pg0);
 }
+/**
+ * _scsih_disable_ddio - Disable direct I/O for all the volumes
+ * @ioc: per adapter object
+ */
+static void
+_scsih_disable_ddio(struct MPT2SAS_ADAPTER *ioc)
+{
+        Mpi2RaidVolPage1_t vol_pg1;
+        Mpi2ConfigReply_t mpi_reply;
+        struct _raid_device *raid_device;
+        u16 handle;
+        u16 ioc_status;
+
+        handle = 0xFFFF;
+        while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
+            &vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
+                ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
+                    MPI2_IOCSTATUS_MASK;
+                if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
+                        break;
+                handle = le16_to_cpu(vol_pg1.DevHandle);
+                raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
+                if (raid_device)
+                        raid_device->direct_io_enabled = 0;
+        }
+        return;
+}
+
+
+/**
+ * _scsih_get_num_volumes - Get number of volumes in the ioc
+ * @ioc: per adapter object
+ */
+static u8
+_scsih_get_num_volumes(struct MPT2SAS_ADAPTER *ioc)
+{
+        Mpi2RaidVolPage1_t vol_pg1;
+        Mpi2ConfigReply_t mpi_reply;
+        u16 handle;
+        u8 vol_cnt = 0;
+        u16 ioc_status;
+
+        handle = 0xFFFF;
+        while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
+            &vol_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) {
+                ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
+                    MPI2_IOCSTATUS_MASK;
+                if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
+                        break;
+                vol_cnt++;
+                handle = le16_to_cpu(vol_pg1.DevHandle);
+        }
+        return vol_cnt;
+}
+
+
+/**
+ * _scsih_init_warpdrive_properties - Set properties for warpdrive direct I/O.
+ * @ioc: per adapter object
+ * @raid_device: the raid_device object
+ */
+static void
+_scsih_init_warpdrive_properties(struct MPT2SAS_ADAPTER *ioc,
+        struct _raid_device *raid_device)
+{
+        Mpi2RaidVolPage0_t *vol_pg0;
+        Mpi2RaidPhysDiskPage0_t pd_pg0;
+        Mpi2ConfigReply_t mpi_reply;
+        u16 sz;
+        u8 num_pds, count;
+        u64 mb = 1024 * 1024;
+        u64 tb_2 = 2 * mb * mb;
+        u64 capacity;
+        u32 stripe_sz;
+        u8 i, stripe_exp;
+
+        if (!ioc->is_warpdrive)
+                return;
+
+        if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_EXPOSE_ALL_DISKS) {
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                    "globally as drives are exposed\n", ioc->name);
+                return;
+        }
+        if (_scsih_get_num_volumes(ioc) > 1) {
+                _scsih_disable_ddio(ioc);
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                    "globally as number of drives > 1\n", ioc->name);
+                return;
+        }
+        if ((mpt2sas_config_get_number_pds(ioc, raid_device->handle,
+            &num_pds)) || !num_pds) {
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                    "Failure in computing number of drives\n", ioc->name);
+                return;
+        }
+
+        sz = offsetof(Mpi2RaidVolPage0_t, PhysDisk) + (num_pds *
+            sizeof(Mpi2RaidVol0PhysDisk_t));
+        vol_pg0 = kzalloc(sz, GFP_KERNEL);
+        if (!vol_pg0) {
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                    "Memory allocation failure for RVPG0\n", ioc->name);
+                return;
+        }
+
+        if ((mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0,
+             MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) {
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                    "Failure in retrieving RVPG0\n", ioc->name);
+                kfree(vol_pg0);
+                return;
+        }
+
+        /*
+         * WARPDRIVE:If number of physical disks in a volume exceeds the max pds
+         * assumed for WARPDRIVE, disable direct I/O
+         */
+        if (num_pds > MPT_MAX_WARPDRIVE_PDS) {
+                printk(MPT2SAS_WARN_FMT "WarpDrive : Direct IO is disabled "
+                    "for the drive with handle(0x%04x): num_mem=%d, "
+                    "max_mem_allowed=%d\n", ioc->name, raid_device->handle,
+                    num_pds, MPT_MAX_WARPDRIVE_PDS);
+                kfree(vol_pg0);
+                return;
+        }
+        for (count = 0; count < num_pds; count++) {
+                if (mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
+                    &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM,
+                    vol_pg0->PhysDisk[count].PhysDiskNum) ||
+                    pd_pg0.DevHandle == MPT2SAS_INVALID_DEVICE_HANDLE) {
+                        printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is "
+                            "disabled for the drive with handle(0x%04x) member"
+                            "handle retrieval failed for member number=%d\n",
+                            ioc->name, raid_device->handle,
+                            vol_pg0->PhysDisk[count].PhysDiskNum);
+                        goto out_error;
+                }
+                raid_device->pd_handle[count] = le16_to_cpu(pd_pg0.DevHandle);
+        }
+
+        /*
+         * Assumption for WD: Direct I/O is not supported if the volume is
+         * not RAID0, if the stripe size is not 64KB, if the block size is
+         * not 512 and if the volume size is >2TB
+         */
+        if (raid_device->volume_type != MPI2_RAID_VOL_TYPE_RAID0 ||
+            le16_to_cpu(vol_pg0->BlockSize) != 512) {
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                    "for the drive with handle(0x%04x): type=%d, "
+                    "s_sz=%uK, blk_size=%u\n", ioc->name,
+                    raid_device->handle, raid_device->volume_type,
+                    le32_to_cpu(vol_pg0->StripeSize)/2,
+                    le16_to_cpu(vol_pg0->BlockSize));
+                goto out_error;
+        }
+
+        capacity = (u64) le16_to_cpu(vol_pg0->BlockSize) *
+            (le64_to_cpu(vol_pg0->MaxLBA) + 1);
+
+        if (capacity > tb_2) {
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                "for the drive with handle(0x%04x) since drive sz > 2TB\n",
+                ioc->name, raid_device->handle);
+                goto out_error;
+        }
+
+        stripe_sz = le32_to_cpu(vol_pg0->StripeSize);
+        stripe_exp = 0;
+        for (i = 0; i < 32; i++) {
+                if (stripe_sz & 1)
+                        break;
+                stripe_exp++;
+                stripe_sz >>= 1;
+        }
+        if (i == 32) {
+                printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is disabled "
+                    "for the drive with handle(0x%04x) invalid stripe sz %uK\n",
+                    ioc->name, raid_device->handle,
+                    le32_to_cpu(vol_pg0->StripeSize)/2);
+                goto out_error;
+        }
+        raid_device->stripe_exponent = stripe_exp;
+        raid_device->direct_io_enabled = 1;
+
+        printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is Enabled for the drive"
+            " with handle(0x%04x)\n", ioc->name, raid_device->handle);
+        /*
+         * WARPDRIVE: Though the following fields are not used for direct IO,
+         * stored for future purpose:
+         */
+        raid_device->max_lba = le64_to_cpu(vol_pg0->MaxLBA);
+        raid_device->stripe_sz = le32_to_cpu(vol_pg0->StripeSize);
+        raid_device->block_sz = le16_to_cpu(vol_pg0->BlockSize);
+
+
+        kfree(vol_pg0);
+        return;
+
+out_error:
+        raid_device->direct_io_enabled = 0;
+        for (count = 0; count < num_pds; count++)
+                raid_device->pd_handle[count] = 0;
+        kfree(vol_pg0);
+        return;
+}
 
 /**
  * _scsih_enable_tlr - setting TLR flags
@@ -1710,6 +1923,11 @@ _scsih_slave_configure(struct scsi_device *sdev)
 
                 _scsih_get_volume_capabilities(ioc, raid_device);
 
+                /*
+                 * WARPDRIVE: Initialize the required data for Direct IO
+                 */
+                _scsih_init_warpdrive_properties(ioc, raid_device);
+
                 /* RAID Queue Depth Support
                  * IS volume = underlying qdepth of drive type, either
                  *    MPT2SAS_SAS_QUEUE_DEPTH or MPT2SAS_SATA_QUEUE_DEPTH
@@ -1757,14 +1975,16 @@ _scsih_slave_configure(struct scsi_device *sdev)
                         break;
                 }
 
-                sdev_printk(KERN_INFO, sdev, "%s: "
-                    "handle(0x%04x), wwid(0x%016llx), pd_count(%d), type(%s)\n",
-                    r_level, raid_device->handle,
-                    (unsigned long long)raid_device->wwid,
-                    raid_device->num_pds, ds);
+                if (!ioc->hide_ir_msg)
+                        sdev_printk(KERN_INFO, sdev, "%s: handle(0x%04x), "
+                            "wwid(0x%016llx), pd_count(%d), type(%s)\n",
+                            r_level, raid_device->handle,
+                            (unsigned long long)raid_device->wwid,
+                            raid_device->num_pds, ds);
                 _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
                 /* raid transport support */
-                _scsih_set_level(sdev, raid_device);
+                if (!ioc->is_warpdrive)
+                        _scsih_set_level(sdev, raid_device);
                 return 0;
         }
 
@@ -2133,8 +2353,7 @@ mpt2sas_scsih_issue_tm(struct MPT2SAS_ADAPTER *ioc, u16 handle, uint channel,
         switch (type) {
         case MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK:
                 scmd_lookup = _scsih_scsi_lookup_get(ioc, smid_task);
-                if (scmd_lookup && (scmd_lookup->serial_number ==
-                    scmd->serial_number))
+                if (scmd_lookup)
                         rc = FAILED;
                 else
                         rc = SUCCESS;
@@ -2182,16 +2401,20 @@ _scsih_tm_display_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd)
         struct MPT2SAS_TARGET *priv_target = starget->hostdata;
         struct _sas_device *sas_device = NULL;
         unsigned long flags;
+        char *device_str = NULL;
 
         if (!priv_target)
                 return;
+        if (ioc->hide_ir_msg)
+                device_str = "WarpDrive";
+        else
+                device_str = "volume";
 
         scsi_print_command(scmd);
         if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
-                starget_printk(KERN_INFO, starget, "volume handle(0x%04x), "
-                    "volume wwid(0x%016llx)\n",
-                    priv_target->handle,
-                    (unsigned long long)priv_target->sas_address);
+                starget_printk(KERN_INFO, starget, "%s handle(0x%04x), "
+                    "%s wwid(0x%016llx)\n", device_str, priv_target->handle,
+                    device_str, (unsigned long long)priv_target->sas_address);
         } else {
                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
                 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
@@ -3130,6 +3353,9 @@ _scsih_check_ir_config_unhide_events(struct MPT2SAS_ADAPTER *ioc,
         a = 0;
         b = 0;
 
+        if (ioc->is_warpdrive)
+                return;
+
         /* Volume Resets for Deleted or Removed */
         element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0];
         for (i = 0; i < event_data->NumElements; i++, element++) {
@@ -3347,6 +3573,105 @@ _scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status)
 }
 
 /**
+ * _scsih_scsi_direct_io_get - returns direct io flag
+ * @ioc: per adapter object
+ * @smid: system request message index
+ *
+ * Returns the smid stored scmd pointer.
+ */
+static inline u8
+_scsih_scsi_direct_io_get(struct MPT2SAS_ADAPTER *ioc, u16 smid)
+{
+        return ioc->scsi_lookup[smid - 1].direct_io;
+}
+
+/**
+ * _scsih_scsi_direct_io_set - sets direct io flag
+ * @ioc: per adapter object
+ * @smid: system request message index
+ * @direct_io: Zero or non-zero value to set in the direct_io flag
+ *
+ * Returns Nothing.
+ */
+static inline void
+_scsih_scsi_direct_io_set(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 direct_io)
+{
+        ioc->scsi_lookup[smid - 1].direct_io = direct_io;
+}
+
+
+/**
+ * _scsih_setup_direct_io - setup MPI request for WARPDRIVE Direct I/O
+ * @ioc: per adapter object
+ * @scmd: pointer to scsi command object
+ * @raid_device: pointer to raid device data structure
+ * @mpi_request: pointer to the SCSI_IO reqest message frame
+ * @smid: system request message index
+ *
+ * Returns nothing
+ */
+static void
+_scsih_setup_direct_io(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
+        struct _raid_device *raid_device, Mpi2SCSIIORequest_t *mpi_request,
+        u16 smid)
+{
+        u32 v_lba, p_lba, stripe_off, stripe_unit, column, io_size;
+        u32 stripe_sz, stripe_exp;
+        u8 num_pds, *cdb_ptr, *tmp_ptr, *lba_ptr1, *lba_ptr2;
+        u8 cdb0 = scmd->cmnd[0];
+
+        /*
+         * Try Direct I/O to RAID memeber disks
+         */
+        if (cdb0 == READ_16 || cdb0 == READ_10 ||
+            cdb0 == WRITE_16 || cdb0 == WRITE_10) {
+                cdb_ptr = mpi_request->CDB.CDB32;
+
+                if ((cdb0 < READ_16) || !(cdb_ptr[2] | cdb_ptr[3] | cdb_ptr[4]
+                        | cdb_ptr[5])) {
+                        io_size = scsi_bufflen(scmd) >> 9;
+                        /* get virtual lba */
+                        lba_ptr1 = lba_ptr2 = (cdb0 < READ_16) ? &cdb_ptr[2] :
+                            &cdb_ptr[6];
+                        tmp_ptr = (u8 *)&v_lba + 3;
+                        *tmp_ptr-- = *lba_ptr1++;
+                        *tmp_ptr-- = *lba_ptr1++;
+                        *tmp_ptr-- = *lba_ptr1++;
+                        *tmp_ptr = *lba_ptr1;
+
+                        if (((u64)v_lba + (u64)io_size - 1) <=
+                            (u32)raid_device->max_lba) {
+                                stripe_sz = raid_device->stripe_sz;
+                                stripe_exp = raid_device->stripe_exponent;
+                                stripe_off = v_lba & (stripe_sz - 1);
+
+                                /* Check whether IO falls within a stripe */
+                                if ((stripe_off + io_size) <= stripe_sz) {
+                                        num_pds = raid_device->num_pds;
+                                        p_lba = v_lba >> stripe_exp;
+                                        stripe_unit = p_lba / num_pds;
+                                        column = p_lba % num_pds;
+                                        p_lba = (stripe_unit << stripe_exp) +
+                                            stripe_off;
+                                        mpi_request->DevHandle =
+                                                cpu_to_le16(raid_device->
+                                                    pd_handle[column]);
+                                        tmp_ptr = (u8 *)&p_lba + 3;
+                                        *lba_ptr2++ = *tmp_ptr--;
+                                        *lba_ptr2++ = *tmp_ptr--;
+                                        *lba_ptr2++ = *tmp_ptr--;
+                                        *lba_ptr2 = *tmp_ptr;
+                                        /*
+                                        * WD: To indicate this I/O is directI/O
+                                        */
+                                        _scsih_scsi_direct_io_set(ioc, smid, 1);
+                                }
+                        }
+                }
+        }
+}
+
+/**
  * _scsih_qcmd - main scsi request entry point
  * @scmd: pointer to scsi command object
  * @done: function pointer to be invoked on completion
@@ -3363,6 +3688,7 @@ _scsih_qcmd_lck(struct scsi_cmnd *scmd, void (*done)(struct scsi_cmnd *))
         struct MPT2SAS_ADAPTER *ioc = shost_priv(scmd->device->host);
         struct MPT2SAS_DEVICE *sas_device_priv_data;
         struct MPT2SAS_TARGET *sas_target_priv_data;
+        struct _raid_device *raid_device;
         Mpi2SCSIIORequest_t *mpi_request;
         u32 mpi_control;
         u16 smid;
@@ -3424,8 +3750,10 @@ _scsih_qcmd_lck(struct scsi_cmnd *scmd, void (*done)(struct scsi_cmnd *))
 
         } else
                 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
-        /* Make sure Device is not raid volume */
-        if (!_scsih_is_raid(&scmd->device->sdev_gendev) &&
+        /* Make sure Device is not raid volume.
+         * We do not expose raid functionality to upper layer for warpdrive.
+         */
+        if (!ioc->is_warpdrive && !_scsih_is_raid(&scmd->device->sdev_gendev) &&
             sas_is_tlr_enabled(scmd->device) && scmd->cmd_len != 32)
                 mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON;
 
@@ -3473,9 +3801,14 @@ _scsih_qcmd_lck(struct scsi_cmnd *scmd, void (*done)(struct scsi_cmnd *))
                 }
         }
 
+        raid_device = sas_target_priv_data->raid_device;
+        if (raid_device && raid_device->direct_io_enabled)
+                _scsih_setup_direct_io(ioc, scmd, raid_device, mpi_request,
+                    smid);
+
         if (likely(mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST))
                 mpt2sas_base_put_smid_scsi_io(ioc, smid,
-                    sas_device_priv_data->sas_target->handle);
+                    le16_to_cpu(mpi_request->DevHandle));
         else
                 mpt2sas_base_put_smid_default(ioc, smid);
         return 0;
@@ -3540,10 +3873,16 @@ _scsih_scsi_ioc_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
         unsigned long flags;
         struct scsi_target *starget = scmd->device->sdev_target;
         struct MPT2SAS_TARGET *priv_target = starget->hostdata;
+        char *device_str = NULL;
 
         if (!priv_target)
                 return;
 
+        if (ioc->hide_ir_msg)
+                device_str = "WarpDrive";
+        else
+                device_str = "volume";
+
         if (log_info == 0x31170000)
                 return;
 
@@ -3660,8 +3999,8 @@ _scsih_scsi_ioc_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
         scsi_print_command(scmd);
 
         if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) {
-                printk(MPT2SAS_WARN_FMT "\tvolume wwid(0x%016llx)\n", ioc->name,
-                    (unsigned long long)priv_target->sas_address);
+                printk(MPT2SAS_WARN_FMT "\t%s wwid(0x%016llx)\n", ioc->name,
+                    device_str, (unsigned long long)priv_target->sas_address);
         } else {
                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
                 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
@@ -3840,6 +4179,20 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
                 scmd->result = DID_NO_CONNECT << 16;
                 goto out;
         }
+        /*
+         * WARPDRIVE: If direct_io is set then it is directIO,
+         * the failed direct I/O should be redirected to volume
+         */
+        if (_scsih_scsi_direct_io_get(ioc, smid)) {
+                _scsih_scsi_direct_io_set(ioc, smid, 0);
+                memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
+                mpi_request->DevHandle =
+                    cpu_to_le16(sas_device_priv_data->sas_target->handle);
+                mpt2sas_base_put_smid_scsi_io(ioc, smid,
+                    sas_device_priv_data->sas_target->handle);
+                return 0;
+        }
+
 
         /* turning off TLR */
         scsi_state = mpi_reply->SCSIState;
@@ -3848,7 +4201,10 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
                     le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF;
         if (!sas_device_priv_data->tlr_snoop_check) {
                 sas_device_priv_data->tlr_snoop_check++;
-        if (!_scsih_is_raid(&scmd->device->sdev_gendev) &&
+        /* Make sure Device is not raid volume.
+         * We do not expose raid functionality to upper layer for warpdrive.
+         */
+        if (!ioc->is_warpdrive && !_scsih_is_raid(&scmd->device->sdev_gendev) &&
                 sas_is_tlr_enabled(scmd->device) &&
                     response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME) {
                         sas_disable_tlr(scmd->device);
@@ -4681,8 +5037,10 @@ _scsih_remove_device(struct MPT2SAS_ADAPTER *ioc,
 
         _scsih_ublock_io_device(ioc, sas_device_backup.handle);
 
-        mpt2sas_transport_port_remove(ioc, sas_device_backup.sas_address,
-            sas_device_backup.sas_address_parent);
+        if (!ioc->hide_drives)
+                mpt2sas_transport_port_remove(ioc,
+                    sas_device_backup.sas_address,
+                    sas_device_backup.sas_address_parent);
 
         printk(MPT2SAS_INFO_FMT "removing handle(0x%04x), sas_addr"
             "(0x%016llx)\n", ioc->name, sas_device_backup.handle,
@@ -5413,6 +5771,7 @@ _scsih_sas_pd_hide(struct MPT2SAS_ADAPTER *ioc,
             &sas_device->volume_wwid);
         set_bit(handle, ioc->pd_handles);
         _scsih_reprobe_target(sas_device->starget, 1);
+
 }
 
 /**
@@ -5591,7 +5950,8 @@ _scsih_sas_ir_config_change_event(struct MPT2SAS_ADAPTER *ioc,
         Mpi2EventDataIrConfigChangeList_t *event_data = fw_event->event_data;
 
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
-        if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
+        if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
+            && !ioc->hide_ir_msg)
                 _scsih_sas_ir_config_change_event_debug(ioc, event_data);
 
 #endif
@@ -5614,16 +5974,20 @@ _scsih_sas_ir_config_change_event(struct MPT2SAS_ADAPTER *ioc,
                                     le16_to_cpu(element->VolDevHandle));
                         break;
                 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED:
-                        _scsih_sas_pd_hide(ioc, element);
+                        if (!ioc->is_warpdrive)
+                                _scsih_sas_pd_hide(ioc, element);
                         break;
                 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED:
-                        _scsih_sas_pd_expose(ioc, element);
+                        if (!ioc->is_warpdrive)
+                                _scsih_sas_pd_expose(ioc, element);
                         break;
                 case MPI2_EVENT_IR_CHANGE_RC_HIDE:
-                        _scsih_sas_pd_add(ioc, element);
+                        if (!ioc->is_warpdrive)
+                                _scsih_sas_pd_add(ioc, element);
                         break;
                 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE:
-                        _scsih_sas_pd_delete(ioc, element);
+                        if (!ioc->is_warpdrive)
+                                _scsih_sas_pd_delete(ioc, element);
                         break;
                 }
         }
@@ -5654,9 +6018,10 @@ _scsih_sas_ir_volume_event(struct MPT2SAS_ADAPTER *ioc,
 
         handle = le16_to_cpu(event_data->VolDevHandle);
         state = le32_to_cpu(event_data->NewValue);
-        dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
-            "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
-            le32_to_cpu(event_data->PreviousValue), state));
+        if (!ioc->hide_ir_msg)
+                dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
+                    "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
+                    le32_to_cpu(event_data->PreviousValue), state));
 
         switch (state) {
         case MPI2_RAID_VOL_STATE_MISSING:
@@ -5736,9 +6101,10 @@ _scsih_sas_ir_physical_disk_event(struct MPT2SAS_ADAPTER *ioc,
         handle = le16_to_cpu(event_data->PhysDiskDevHandle);
         state = le32_to_cpu(event_data->NewValue);
 
-        dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
-            "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
-            le32_to_cpu(event_data->PreviousValue), state));
+        if (!ioc->hide_ir_msg)
+                dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: handle(0x%04x), "
+                    "old(0x%08x), new(0x%08x)\n", ioc->name, __func__,  handle,
+                    le32_to_cpu(event_data->PreviousValue), state));
 
         switch (state) {
         case MPI2_RAID_PD_STATE_ONLINE:
@@ -5747,7 +6113,8 @@ _scsih_sas_ir_physical_disk_event(struct MPT2SAS_ADAPTER *ioc,
         case MPI2_RAID_PD_STATE_OPTIMAL:
         case MPI2_RAID_PD_STATE_HOT_SPARE:
 
-                set_bit(handle, ioc->pd_handles);
+                if (!ioc->is_warpdrive)
+                        set_bit(handle, ioc->pd_handles);
 
                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
                 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
@@ -5851,7 +6218,8 @@ _scsih_sas_ir_operation_status_event(struct MPT2SAS_ADAPTER *ioc,
         u16 handle;
 
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
-        if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
+        if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
+            && !ioc->hide_ir_msg)
                 _scsih_sas_ir_operation_status_event_debug(ioc,
                      event_data);
 #endif
@@ -5910,7 +6278,7 @@ static void
 _scsih_mark_responding_sas_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
     u16 slot, u16 handle)
 {
-        struct MPT2SAS_TARGET *sas_target_priv_data;
+        struct MPT2SAS_TARGET *sas_target_priv_data = NULL;
         struct scsi_target *starget;
         struct _sas_device *sas_device;
         unsigned long flags;
@@ -5918,7 +6286,7 @@ _scsih_mark_responding_sas_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
         spin_lock_irqsave(&ioc->sas_device_lock, flags);
         list_for_each_entry(sas_device, &ioc->sas_device_list, list) {
                 if (sas_device->sas_address == sas_address &&
-                    sas_device->slot == slot && sas_device->starget) {
+                    sas_device->slot == slot) {
                         sas_device->responding = 1;
                         starget = sas_device->starget;
                         if (starget && starget->hostdata) {
@@ -5927,13 +6295,15 @@ _scsih_mark_responding_sas_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
                                 sas_target_priv_data->deleted = 0;
                         } else
                                 sas_target_priv_data = NULL;
-                        starget_printk(KERN_INFO, sas_device->starget,
-                            "handle(0x%04x), sas_addr(0x%016llx), enclosure "
-                            "logical id(0x%016llx), slot(%d)\n", handle,
-                            (unsigned long long)sas_device->sas_address,
-                            (unsigned long long)
-                            sas_device->enclosure_logical_id,
-                            sas_device->slot);
+                        if (starget)
+                                starget_printk(KERN_INFO, starget,
+                                    "handle(0x%04x), sas_addr(0x%016llx), "
+                                    "enclosure logical id(0x%016llx), "
+                                    "slot(%d)\n", handle,
+                                    (unsigned long long)sas_device->sas_address,
+                                    (unsigned long long)
+                                    sas_device->enclosure_logical_id,
+                                    sas_device->slot);
                         if (sas_device->handle == handle)
                                 goto out;
                         printk(KERN_INFO "\thandle changed from(0x%04x)!!!\n",
@@ -6025,6 +6395,12 @@ _scsih_mark_responding_raid_device(struct MPT2SAS_ADAPTER *ioc, u64 wwid,
                         starget_printk(KERN_INFO, raid_device->starget,
                             "handle(0x%04x), wwid(0x%016llx)\n", handle,
                             (unsigned long long)raid_device->wwid);
+                        /*
+                         * WARPDRIVE: The handles of the PDs might have changed
+                         * across the host reset so re-initialize the
+                         * required data for Direct IO
+                         */
+                        _scsih_init_warpdrive_properties(ioc, raid_device);
                         if (raid_device->handle == handle)
                                 goto out;
                         printk(KERN_INFO "\thandle changed from(0x%04x)!!!\n",
@@ -6086,18 +6462,20 @@ _scsih_search_responding_raid_devices(struct MPT2SAS_ADAPTER *ioc)
         }
 
         /* refresh the pd_handles */
-        phys_disk_num = 0xFF;
-        memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
-        while (!(mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
-            &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
-            phys_disk_num))) {
-                ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
-                    MPI2_IOCSTATUS_MASK;
-                if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
-                        break;
-                phys_disk_num = pd_pg0.PhysDiskNum;
-                handle = le16_to_cpu(pd_pg0.DevHandle);
-                set_bit(handle, ioc->pd_handles);
+        if (!ioc->is_warpdrive) {
+                phys_disk_num = 0xFF;
+                memset(ioc->pd_handles, 0, ioc->pd_handles_sz);
+                while (!(mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
+                    &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM,
+                    phys_disk_num))) {
+                        ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
+                            MPI2_IOCSTATUS_MASK;
+                        if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
+                                break;
+                        phys_disk_num = pd_pg0.PhysDiskNum;
+                        handle = le16_to_cpu(pd_pg0.DevHandle);
+                        set_bit(handle, ioc->pd_handles);
+                }
         }
 }
 
@@ -6243,6 +6621,50 @@ _scsih_remove_unresponding_sas_devices(struct MPT2SAS_ADAPTER *ioc)
 }
 
 /**
+ * _scsih_hide_unhide_sas_devices - add/remove device to/from OS
+ * @ioc: per adapter object
+ *
+ * Return nothing.
+ */
+static void
+_scsih_hide_unhide_sas_devices(struct MPT2SAS_ADAPTER *ioc)
+{
+        struct _sas_device *sas_device, *sas_device_next;
+
+        if (!ioc->is_warpdrive || ioc->mfg_pg10_hide_flag !=
+            MFG_PAGE10_HIDE_IF_VOL_PRESENT)
+                return;
+
+        if (ioc->hide_drives) {
+                if (_scsih_get_num_volumes(ioc))
+                        return;
+                ioc->hide_drives = 0;
+                list_for_each_entry_safe(sas_device, sas_device_next,
+                    &ioc->sas_device_list, list) {
+                        if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
+                                sas_device->sas_address_parent)) {
+                                _scsih_sas_device_remove(ioc, sas_device);
+                        } else if (!sas_device->starget) {
+                                mpt2sas_transport_port_remove(ioc,
+                                    sas_device->sas_address,
+                                    sas_device->sas_address_parent);
+                                _scsih_sas_device_remove(ioc, sas_device);
+                        }
+                }
+        } else {
+                if (!_scsih_get_num_volumes(ioc))
+                        return;
+                ioc->hide_drives = 1;
+                list_for_each_entry_safe(sas_device, sas_device_next,
+                    &ioc->sas_device_list, list) {
+                        mpt2sas_transport_port_remove(ioc,
+                            sas_device->sas_address,
+                            sas_device->sas_address_parent);
+                }
+        }
+}
+
+/**
  * mpt2sas_scsih_reset_handler - reset callback handler (for scsih)
  * @ioc: per adapter object
  * @reset_phase: phase
@@ -6326,6 +6748,7 @@ _firmware_event_work(struct work_struct *work)
                         spin_unlock_irqrestore(&ioc->ioc_reset_in_progress_lock,
                             flags);
                 _scsih_remove_unresponding_sas_devices(ioc);
+                _scsih_hide_unhide_sas_devices(ioc);
                 return;
         }
 
@@ -6425,6 +6848,53 @@ mpt2sas_scsih_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index,
                     (Mpi2EventDataIrVolume_t *)
                     mpi_reply->EventData);
                 break;
+        case MPI2_EVENT_LOG_ENTRY_ADDED:
+        {
+                Mpi2EventDataLogEntryAdded_t *log_entry;
+                u32 *log_code;
+
+                if (!ioc->is_warpdrive)
+                        break;
+
+                log_entry = (Mpi2EventDataLogEntryAdded_t *)
+                    mpi_reply->EventData;
+                log_code = (u32 *)log_entry->LogData;
+
+                if (le16_to_cpu(log_entry->LogEntryQualifier)
+                    != MPT2_WARPDRIVE_LOGENTRY)
+                        break;
+
+                switch (le32_to_cpu(*log_code)) {
+                case MPT2_WARPDRIVE_LC_SSDT:
+                        printk(MPT2SAS_WARN_FMT "WarpDrive Warning: "
+                            "IO Throttling has occurred in the WarpDrive "
+                            "subsystem. Check WarpDrive documentation for "
+                            "additional details.\n", ioc->name);
+                        break;
+                case MPT2_WARPDRIVE_LC_SSDLW:
+                        printk(MPT2SAS_WARN_FMT "WarpDrive Warning: "
+                            "Program/Erase Cycles for the WarpDrive subsystem "
+                            "in degraded range. Check WarpDrive documentation "
+                            "for additional details.\n", ioc->name);
+                        break;
+                case MPT2_WARPDRIVE_LC_SSDLF:
+                        printk(MPT2SAS_ERR_FMT "WarpDrive Fatal Error: "
+                            "There are no Program/Erase Cycles for the "
+                            "WarpDrive subsystem. The storage device will be "
+                            "in read-only mode. Check WarpDrive documentation "
+                            "for additional details.\n", ioc->name);
+                        break;
+                case MPT2_WARPDRIVE_LC_BRMF:
+                        printk(MPT2SAS_ERR_FMT "WarpDrive Fatal Error: "
+                            "The Backup Rail Monitor has failed on the "
+                            "WarpDrive subsystem. Check WarpDrive "
+                            "documentation for additional details.\n",
+                            ioc->name);
+                        break;
+                }
+
+                break;
+        }
         case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE:
         case MPI2_EVENT_IR_OPERATION_STATUS:
         case MPI2_EVENT_SAS_DISCOVERY:
@@ -6583,7 +7053,8 @@ _scsih_ir_shutdown(struct MPT2SAS_ADAPTER *ioc)
         mpi_request->Function = MPI2_FUNCTION_RAID_ACTION;
         mpi_request->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED;
 
-        printk(MPT2SAS_INFO_FMT "IR shutdown (sending)\n", ioc->name);
+        if (!ioc->hide_ir_msg)
+                printk(MPT2SAS_INFO_FMT "IR shutdown (sending)\n", ioc->name);
         init_completion(&ioc->scsih_cmds.done);
         mpt2sas_base_put_smid_default(ioc, smid);
         wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ);
@@ -6597,10 +7068,11 @@ _scsih_ir_shutdown(struct MPT2SAS_ADAPTER *ioc)
         if (ioc->scsih_cmds.status & MPT2_CMD_REPLY_VALID) {
                 mpi_reply = ioc->scsih_cmds.reply;
 
-                printk(MPT2SAS_INFO_FMT "IR shutdown (complete): "
-                    "ioc_status(0x%04x), loginfo(0x%08x)\n",
-                    ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
-                    le32_to_cpu(mpi_reply->IOCLogInfo));
+                if (!ioc->hide_ir_msg)
+                        printk(MPT2SAS_INFO_FMT "IR shutdown (complete): "
+                            "ioc_status(0x%04x), loginfo(0x%08x)\n",
+                            ioc->name, le16_to_cpu(mpi_reply->IOCStatus),
+                            le32_to_cpu(mpi_reply->IOCLogInfo));
         }
 
  out:
@@ -6759,6 +7231,9 @@ _scsih_probe_boot_devices(struct MPT2SAS_ADAPTER *ioc)
                 spin_lock_irqsave(&ioc->sas_device_lock, flags);
                 list_move_tail(&sas_device->list, &ioc->sas_device_list);
                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
+
+                if (ioc->hide_drives)
+                        return;
                 if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
                     sas_device->sas_address_parent)) {
                         _scsih_sas_device_remove(ioc, sas_device);
@@ -6812,6 +7287,9 @@ _scsih_probe_sas(struct MPT2SAS_ADAPTER *ioc)
                 list_move_tail(&sas_device->list, &ioc->sas_device_list);
                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 
+                if (ioc->hide_drives)
+                        continue;
+
                 if (!mpt2sas_transport_port_add(ioc, sas_device->handle,
                     sas_device->sas_address_parent)) {
                         _scsih_sas_device_remove(ioc, sas_device);
@@ -6882,6 +7360,11 @@ _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         ioc->id = mpt_ids++;
         sprintf(ioc->name, "%s%d", MPT2SAS_DRIVER_NAME, ioc->id);
         ioc->pdev = pdev;
+        if (id->device == MPI2_MFGPAGE_DEVID_SSS6200) {
+                ioc->is_warpdrive = 1;
+                ioc->hide_ir_msg = 1;
+        } else
+                ioc->mfg_pg10_hide_flag = MFG_PAGE10_EXPOSE_ALL_DISKS;
         ioc->scsi_io_cb_idx = scsi_io_cb_idx;
         ioc->tm_cb_idx = tm_cb_idx;
         ioc->ctl_cb_idx = ctl_cb_idx;
@@ -6947,6 +7430,20 @@ _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         }
 
         ioc->wait_for_port_enable_to_complete = 0;
+        if (ioc->is_warpdrive) {
+                if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_EXPOSE_ALL_DISKS)
+                        ioc->hide_drives = 0;
+                else if (ioc->mfg_pg10_hide_flag ==  MFG_PAGE10_HIDE_ALL_DISKS)
+                        ioc->hide_drives = 1;
+                else {
+                        if (_scsih_get_num_volumes(ioc))
+                                ioc->hide_drives = 1;
+                        else
+                                ioc->hide_drives = 0;
+                }
+        } else
+                ioc->hide_drives = 0;
+
         _scsih_probe_devices(ioc);
         return 0;
 
diff --git a/drivers/scsi/mvsas/Kconfig b/drivers/scsi/mvsas/Kconfig
index 6de7af27e507..c82b012aba37 100644
--- a/drivers/scsi/mvsas/Kconfig
+++ b/drivers/scsi/mvsas/Kconfig
@@ -3,6 +3,7 @@
 #
 # Copyright 2007 Red Hat, Inc.
 # Copyright 2008 Marvell. <kewei@marvell.com>
+# Copyright 2009-20011 Marvell. <yuxiangl@marvell.com>
 #
 # This file is licensed under GPLv2.
 #
diff --git a/drivers/scsi/mvsas/Makefile b/drivers/scsi/mvsas/Makefile
index ffbf759e46f1..87b231a5bd5e 100644
--- a/drivers/scsi/mvsas/Makefile
+++ b/drivers/scsi/mvsas/Makefile
@@ -3,6 +3,7 @@
 #
 # Copyright 2007 Red Hat, Inc.
 # Copyright 2008 Marvell. <kewei@marvell.com>
+# Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
 #
 # This file is licensed under GPLv2.
 #
diff --git a/drivers/scsi/mvsas/mv_64xx.c b/drivers/scsi/mvsas/mv_64xx.c
index afc7f6f3a13e..13c960481391 100644
--- a/drivers/scsi/mvsas/mv_64xx.c
+++ b/drivers/scsi/mvsas/mv_64xx.c
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
diff --git a/drivers/scsi/mvsas/mv_64xx.h b/drivers/scsi/mvsas/mv_64xx.h
index 42e947d9795e..545889bd9753 100644
--- a/drivers/scsi/mvsas/mv_64xx.h
+++ b/drivers/scsi/mvsas/mv_64xx.h
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
diff --git a/drivers/scsi/mvsas/mv_94xx.c b/drivers/scsi/mvsas/mv_94xx.c
index eed4c5c72013..78162c3c36e6 100644
--- a/drivers/scsi/mvsas/mv_94xx.c
+++ b/drivers/scsi/mvsas/mv_94xx.c
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
diff --git a/drivers/scsi/mvsas/mv_94xx.h b/drivers/scsi/mvsas/mv_94xx.h
index 23ed9b164669..8835befe2c0e 100644
--- a/drivers/scsi/mvsas/mv_94xx.h
+++ b/drivers/scsi/mvsas/mv_94xx.h
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
diff --git a/drivers/scsi/mvsas/mv_chips.h b/drivers/scsi/mvsas/mv_chips.h
index a67e1c4172f9..1753a6fc42d0 100644
--- a/drivers/scsi/mvsas/mv_chips.h
+++ b/drivers/scsi/mvsas/mv_chips.h
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
diff --git a/drivers/scsi/mvsas/mv_defs.h b/drivers/scsi/mvsas/mv_defs.h
index 1849da1f030d..bc00c940743c 100644
--- a/drivers/scsi/mvsas/mv_defs.h
+++ b/drivers/scsi/mvsas/mv_defs.h
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
@@ -34,6 +35,8 @@ enum chip_flavors {
         chip_6485,
         chip_9480,
         chip_9180,
+        chip_9445,
+        chip_9485,
         chip_1300,
         chip_1320
 };
diff --git a/drivers/scsi/mvsas/mv_init.c b/drivers/scsi/mvsas/mv_init.c
index 938d045e4180..90b636611cde 100644
--- a/drivers/scsi/mvsas/mv_init.c
+++ b/drivers/scsi/mvsas/mv_init.c
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
@@ -25,13 +26,24 @@
 
 #include "mv_sas.h"
 
+static int lldd_max_execute_num = 1;
+module_param_named(collector, lldd_max_execute_num, int, S_IRUGO);
+MODULE_PARM_DESC(collector, "\n"
+        "\tIf greater than one, tells the SAS Layer to run in Task Collector\n"
+        "\tMode.  If 1 or 0, tells the SAS Layer to run in Direct Mode.\n"
+        "\tThe mvsas SAS LLDD supports both modes.\n"
+        "\tDefault: 1 (Direct Mode).\n");
+
 static struct scsi_transport_template *mvs_stt;
+struct kmem_cache *mvs_task_list_cache;
 static const struct mvs_chip_info mvs_chips[] = {
         [chip_6320] =   { 1, 2, 0x400, 17, 16,  9, &mvs_64xx_dispatch, },
         [chip_6440] =   { 1, 4, 0x400, 17, 16,  9, &mvs_64xx_dispatch, },
         [chip_6485] =   { 1, 8, 0x800, 33, 32, 10, &mvs_64xx_dispatch, },
         [chip_9180] =   { 2, 4, 0x800, 17, 64,  9, &mvs_94xx_dispatch, },
         [chip_9480] =   { 2, 4, 0x800, 17, 64,  9, &mvs_94xx_dispatch, },
+        [chip_9445] =   { 1, 4, 0x800, 17, 64, 11, &mvs_94xx_dispatch, },
+        [chip_9485] =   { 2, 4, 0x800, 17, 64, 11, &mvs_94xx_dispatch, },
         [chip_1300] =   { 1, 4, 0x400, 17, 16,  9, &mvs_64xx_dispatch, },
         [chip_1320] =   { 2, 4, 0x800, 17, 64,  9, &mvs_94xx_dispatch, },
 };
@@ -107,7 +119,6 @@ static void __devinit mvs_phy_init(struct mvs_info *mvi, int phy_id)
 
 static void mvs_free(struct mvs_info *mvi)
 {
-        int i;
         struct mvs_wq *mwq;
         int slot_nr;
 
@@ -119,12 +130,8 @@ static void mvs_free(struct mvs_info *mvi)
         else
                 slot_nr = MVS_SLOTS;
 
-        for (i = 0; i < mvi->tags_num; i++) {
-                struct mvs_slot_info *slot = &mvi->slot_info[i];
-                if (slot->buf)
-                        dma_free_coherent(mvi->dev, MVS_SLOT_BUF_SZ,
-                                          slot->buf, slot->buf_dma);
-        }
+        if (mvi->dma_pool)
+                pci_pool_destroy(mvi->dma_pool);
 
         if (mvi->tx)
                 dma_free_coherent(mvi->dev,
@@ -213,6 +220,7 @@ static irqreturn_t mvs_interrupt(int irq, void *opaque)
 static int __devinit mvs_alloc(struct mvs_info *mvi, struct Scsi_Host *shost)
 {
         int i = 0, slot_nr;
+        char pool_name[32];
 
         if (mvi->flags & MVF_FLAG_SOC)
                 slot_nr = MVS_SOC_SLOTS;
@@ -272,18 +280,14 @@ static int __devinit mvs_alloc(struct mvs_info *mvi, struct Scsi_Host *shost)
         if (!mvi->bulk_buffer)
                 goto err_out;
 #endif
-        for (i = 0; i < slot_nr; i++) {
-                struct mvs_slot_info *slot = &mvi->slot_info[i];
-
-                slot->buf = dma_alloc_coherent(mvi->dev, MVS_SLOT_BUF_SZ,
-                                               &slot->buf_dma, GFP_KERNEL);
-                if (!slot->buf) {
-                        printk(KERN_DEBUG"failed to allocate slot->buf.\n");
+        sprintf(pool_name, "%s%d", "mvs_dma_pool", mvi->id);
+        mvi->dma_pool = pci_pool_create(pool_name, mvi->pdev, MVS_SLOT_BUF_SZ, 16, 0);
+        if (!mvi->dma_pool) {
+                        printk(KERN_DEBUG "failed to create dma pool %s.\n", pool_name);
                         goto err_out;
-                }
-                memset(slot->buf, 0, MVS_SLOT_BUF_SZ);
-                ++mvi->tags_num;
         }
+        mvi->tags_num = slot_nr;
+
         /* Initialize tags */
         mvs_tag_init(mvi);
         return 0;
@@ -484,7 +488,7 @@ static void  __devinit mvs_post_sas_ha_init(struct Scsi_Host *shost,
 
         sha->num_phys = nr_core * chip_info->n_phy;
 
-        sha->lldd_max_execute_num = 1;
+        sha->lldd_max_execute_num = lldd_max_execute_num;
 
         if (mvi->flags & MVF_FLAG_SOC)
                 can_queue = MVS_SOC_CAN_QUEUE;
@@ -670,6 +674,24 @@ static struct pci_device_id __devinitdata mvs_pci_table[] = {
         { PCI_VDEVICE(TTI, 0x2740), chip_9480 },
         { PCI_VDEVICE(TTI, 0x2744), chip_9480 },
         { PCI_VDEVICE(TTI, 0x2760), chip_9480 },
+        {
+                .vendor         = 0x1b4b,
+                .device         = 0x9445,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = 0x9480,
+                .class          = 0,
+                .class_mask     = 0,
+                .driver_data    = chip_9445,
+        },
+        {
+                .vendor         = 0x1b4b,
+                .device         = 0x9485,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = 0x9480,
+                .class          = 0,
+                .class_mask     = 0,
+                .driver_data    = chip_9485,
+        },
 
         { }     /* terminate list */
 };
@@ -690,6 +712,14 @@ static int __init mvs_init(void)
         if (!mvs_stt)
                 return -ENOMEM;
 
+        mvs_task_list_cache = kmem_cache_create("mvs_task_list", sizeof(struct mvs_task_list),
+                                                         0, SLAB_HWCACHE_ALIGN, NULL);
+        if (!mvs_task_list_cache) {
+                rc = -ENOMEM;
+                mv_printk("%s: mvs_task_list_cache alloc failed! \n", __func__);
+                goto err_out;
+        }
+
         rc = pci_register_driver(&mvs_pci_driver);
 
         if (rc)
@@ -706,6 +736,7 @@ static void __exit mvs_exit(void)
 {
         pci_unregister_driver(&mvs_pci_driver);
         sas_release_transport(mvs_stt);
+        kmem_cache_destroy(mvs_task_list_cache);
 }
 
 module_init(mvs_init);
diff --git a/drivers/scsi/mvsas/mv_sas.c b/drivers/scsi/mvsas/mv_sas.c
index adedaa916ecb..0ef27425c447 100644
--- a/drivers/scsi/mvsas/mv_sas.c
+++ b/drivers/scsi/mvsas/mv_sas.c
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
@@ -862,178 +863,286 @@ static int mvs_task_prep_ssp(struct mvs_info *mvi,
 }
 
 #define DEV_IS_GONE(mvi_dev)    ((!mvi_dev || (mvi_dev->dev_type == NO_DEVICE)))
-static int mvs_task_exec(struct sas_task *task, const int num, gfp_t gfp_flags,
-                                struct completion *completion,int is_tmf,
-                                struct mvs_tmf_task *tmf)
+static int mvs_task_prep(struct sas_task *task, struct mvs_info *mvi, int is_tmf,
+                                struct mvs_tmf_task *tmf, int *pass)
 {
         struct domain_device *dev = task->dev;
-        struct mvs_device *mvi_dev = (struct mvs_device *)dev->lldd_dev;
-        struct mvs_info *mvi = mvi_dev->mvi_info;
+        struct mvs_device *mvi_dev = dev->lldd_dev;
         struct mvs_task_exec_info tei;
-        struct sas_task *t = task;
         struct mvs_slot_info *slot;
-        u32 tag = 0xdeadbeef, rc, n_elem = 0;
-        u32 n = num, pass = 0;
-        unsigned long flags = 0,  flags_libsas = 0;
+        u32 tag = 0xdeadbeef, n_elem = 0;
+        int rc = 0;
 
         if (!dev->port) {
-                struct task_status_struct *tsm = &t->task_status;
+                struct task_status_struct *tsm = &task->task_status;
 
                 tsm->resp = SAS_TASK_UNDELIVERED;
                 tsm->stat = SAS_PHY_DOWN;
+                /*
+                 * libsas will use dev->port, should
+                 * not call task_done for sata
+                 */
                 if (dev->dev_type != SATA_DEV)
-                        t->task_done(t);
-                return 0;
+                        task->task_done(task);
+                return rc;
         }
 
-        spin_lock_irqsave(&mvi->lock, flags);
-        do {
-                dev = t->dev;
-                mvi_dev = dev->lldd_dev;
-                if (DEV_IS_GONE(mvi_dev)) {
-                        if (mvi_dev)
-                                mv_dprintk("device %d not ready.\n",
-                                        mvi_dev->device_id);
-                        else
-                                mv_dprintk("device %016llx not ready.\n",
-                                        SAS_ADDR(dev->sas_addr));
+        if (DEV_IS_GONE(mvi_dev)) {
+                if (mvi_dev)
+                        mv_dprintk("device %d not ready.\n",
+                                mvi_dev->device_id);
+                else
+                        mv_dprintk("device %016llx not ready.\n",
+                                SAS_ADDR(dev->sas_addr));
 
                         rc = SAS_PHY_DOWN;
-                        goto out_done;
-                }
+                        return rc;
+        }
+        tei.port = dev->port->lldd_port;
+        if (tei.port && !tei.port->port_attached && !tmf) {
+                if (sas_protocol_ata(task->task_proto)) {
+                        struct task_status_struct *ts = &task->task_status;
+                        mv_dprintk("SATA/STP port %d does not attach"
+                                        "device.\n", dev->port->id);
+                        ts->resp = SAS_TASK_COMPLETE;
+                        ts->stat = SAS_PHY_DOWN;
 
-                if (dev->port->id >= mvi->chip->n_phy)
-                        tei.port = &mvi->port[dev->port->id - mvi->chip->n_phy];
-                else
-                        tei.port = &mvi->port[dev->port->id];
-
-                if (tei.port && !tei.port->port_attached) {
-                        if (sas_protocol_ata(t->task_proto)) {
-                                struct task_status_struct *ts = &t->task_status;
-
-                                mv_dprintk("port %d does not"
-                                        "attached device.\n", dev->port->id);
-                                ts->stat = SAS_PROTO_RESPONSE;
-                                ts->stat = SAS_PHY_DOWN;
-                                spin_unlock_irqrestore(dev->sata_dev.ap->lock,
-                                                       flags_libsas);
-                                spin_unlock_irqrestore(&mvi->lock, flags);
-                                t->task_done(t);
-                                spin_lock_irqsave(&mvi->lock, flags);
-                                spin_lock_irqsave(dev->sata_dev.ap->lock,
-                                                  flags_libsas);
-                                if (n > 1)
-                                        t = list_entry(t->list.next,
-                                                       struct sas_task, list);
-                                continue;
-                        } else {
-                                struct task_status_struct *ts = &t->task_status;
-                                ts->resp = SAS_TASK_UNDELIVERED;
-                                ts->stat = SAS_PHY_DOWN;
-                                t->task_done(t);
-                                if (n > 1)
-                                        t = list_entry(t->list.next,
-                                                        struct sas_task, list);
-                                continue;
-                        }
-                }
+                        task->task_done(task);
 
-                if (!sas_protocol_ata(t->task_proto)) {
-                        if (t->num_scatter) {
-                                n_elem = dma_map_sg(mvi->dev,
-                                                    t->scatter,
-                                                    t->num_scatter,
-                                                    t->data_dir);
-                                if (!n_elem) {
-                                        rc = -ENOMEM;
-                                        goto err_out;
-                                }
-                        }
                 } else {
-                        n_elem = t->num_scatter;
+                        struct task_status_struct *ts = &task->task_status;
+                        mv_dprintk("SAS port %d does not attach"
+                                "device.\n", dev->port->id);
+                        ts->resp = SAS_TASK_UNDELIVERED;
+                        ts->stat = SAS_PHY_DOWN;
+                        task->task_done(task);
                 }
+                return rc;
+        }
 
-                rc = mvs_tag_alloc(mvi, &tag);
-                if (rc)
-                        goto err_out;
+        if (!sas_protocol_ata(task->task_proto)) {
+                if (task->num_scatter) {
+                        n_elem = dma_map_sg(mvi->dev,
+                                            task->scatter,
+                                            task->num_scatter,
+                                            task->data_dir);
+                        if (!n_elem) {
+                                rc = -ENOMEM;
+                                goto prep_out;
+                        }
+                }
+        } else {
+                n_elem = task->num_scatter;
+        }
 
-                slot = &mvi->slot_info[tag];
+        rc = mvs_tag_alloc(mvi, &tag);
+        if (rc)
+                goto err_out;
 
+        slot = &mvi->slot_info[tag];
 
-                t->lldd_task = NULL;
-                slot->n_elem = n_elem;
-                slot->slot_tag = tag;
-                memset(slot->buf, 0, MVS_SLOT_BUF_SZ);
+        task->lldd_task = NULL;
+        slot->n_elem = n_elem;
+        slot->slot_tag = tag;
+
+        slot->buf = pci_pool_alloc(mvi->dma_pool, GFP_ATOMIC, &slot->buf_dma);
+        if (!slot->buf)
+                goto err_out_tag;
+        memset(slot->buf, 0, MVS_SLOT_BUF_SZ);
+
+        tei.task = task;
+        tei.hdr = &mvi->slot[tag];
+        tei.tag = tag;
+        tei.n_elem = n_elem;
+        switch (task->task_proto) {
+        case SAS_PROTOCOL_SMP:
+                rc = mvs_task_prep_smp(mvi, &tei);
+                break;
+        case SAS_PROTOCOL_SSP:
+                rc = mvs_task_prep_ssp(mvi, &tei, is_tmf, tmf);
+                break;
+        case SAS_PROTOCOL_SATA:
+        case SAS_PROTOCOL_STP:
+        case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
+                rc = mvs_task_prep_ata(mvi, &tei);
+                break;
+        default:
+                dev_printk(KERN_ERR, mvi->dev,
+                        "unknown sas_task proto: 0x%x\n",
+                        task->task_proto);
+                rc = -EINVAL;
+                break;
+        }
 
-                tei.task = t;
-                tei.hdr = &mvi->slot[tag];
-                tei.tag = tag;
-                tei.n_elem = n_elem;
-                switch (t->task_proto) {
-                case SAS_PROTOCOL_SMP:
-                        rc = mvs_task_prep_smp(mvi, &tei);
-                        break;
-                case SAS_PROTOCOL_SSP:
-                        rc = mvs_task_prep_ssp(mvi, &tei, is_tmf, tmf);
-                        break;
-                case SAS_PROTOCOL_SATA:
-                case SAS_PROTOCOL_STP:
-                case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
-                        rc = mvs_task_prep_ata(mvi, &tei);
-                        break;
-                default:
-                        dev_printk(KERN_ERR, mvi->dev,
-                                   "unknown sas_task proto: 0x%x\n",
-                                   t->task_proto);
-                        rc = -EINVAL;
-                        break;
-                }
+        if (rc) {
+                mv_dprintk("rc is %x\n", rc);
+                goto err_out_slot_buf;
+        }
+        slot->task = task;
+        slot->port = tei.port;
+        task->lldd_task = slot;
+        list_add_tail(&slot->entry, &tei.port->list);
+        spin_lock(&task->task_state_lock);
+        task->task_state_flags |= SAS_TASK_AT_INITIATOR;
+        spin_unlock(&task->task_state_lock);
 
-                if (rc) {
-                        mv_dprintk("rc is %x\n", rc);
-                        goto err_out_tag;
-                }
-                slot->task = t;
-                slot->port = tei.port;
-                t->lldd_task = slot;
-                list_add_tail(&slot->entry, &tei.port->list);
-                /* TODO: select normal or high priority */
-                spin_lock(&t->task_state_lock);
-                t->task_state_flags |= SAS_TASK_AT_INITIATOR;
-                spin_unlock(&t->task_state_lock);
-
-                mvs_hba_memory_dump(mvi, tag, t->task_proto);
-                mvi_dev->running_req++;
-                ++pass;
-                mvi->tx_prod = (mvi->tx_prod + 1) & (MVS_CHIP_SLOT_SZ - 1);
-                if (n > 1)
-                        t = list_entry(t->list.next, struct sas_task, list);
-                if (likely(pass))
-                        MVS_CHIP_DISP->start_delivery(mvi, (mvi->tx_prod - 1) &
-                                                      (MVS_CHIP_SLOT_SZ - 1));
+        mvs_hba_memory_dump(mvi, tag, task->task_proto);
+        mvi_dev->running_req++;
+        ++(*pass);
+        mvi->tx_prod = (mvi->tx_prod + 1) & (MVS_CHIP_SLOT_SZ - 1);
 
-        } while (--n);
-        rc = 0;
-        goto out_done;
+        return rc;
 
+err_out_slot_buf:
+        pci_pool_free(mvi->dma_pool, slot->buf, slot->buf_dma);
 err_out_tag:
         mvs_tag_free(mvi, tag);
 err_out:
 
-        dev_printk(KERN_ERR, mvi->dev, "mvsas exec failed[%d]!\n", rc);
-        if (!sas_protocol_ata(t->task_proto))
+        dev_printk(KERN_ERR, mvi->dev, "mvsas prep failed[%d]!\n", rc);
+        if (!sas_protocol_ata(task->task_proto))
                 if (n_elem)
-                        dma_unmap_sg(mvi->dev, t->scatter, n_elem,
-                                     t->data_dir);
-out_done:
+                        dma_unmap_sg(mvi->dev, task->scatter, n_elem,
+                                     task->data_dir);
+prep_out:
+        return rc;
+}
+
+static struct mvs_task_list *mvs_task_alloc_list(int *num, gfp_t gfp_flags)
+{
+        struct mvs_task_list *first = NULL;
+
+        for (; *num > 0; --*num) {
+                struct mvs_task_list *mvs_list = kmem_cache_zalloc(mvs_task_list_cache, gfp_flags);
+
+                if (!mvs_list)
+                        break;
+
+                INIT_LIST_HEAD(&mvs_list->list);
+                if (!first)
+                        first = mvs_list;
+                else
+                        list_add_tail(&mvs_list->list, &first->list);
+
+        }
+
+        return first;
+}
+
+static inline void mvs_task_free_list(struct mvs_task_list *mvs_list)
+{
+        LIST_HEAD(list);
+        struct list_head *pos, *a;
+        struct mvs_task_list *mlist = NULL;
+
+        __list_add(&list, mvs_list->list.prev, &mvs_list->list);
+
+        list_for_each_safe(pos, a, &list) {
+                list_del_init(pos);
+                mlist = list_entry(pos, struct mvs_task_list, list);
+                kmem_cache_free(mvs_task_list_cache, mlist);
+        }
+}
+
+static int mvs_task_exec(struct sas_task *task, const int num, gfp_t gfp_flags,
+                                struct completion *completion, int is_tmf,
+                                struct mvs_tmf_task *tmf)
+{
+        struct domain_device *dev = task->dev;
+        struct mvs_info *mvi = NULL;
+        u32 rc = 0;
+        u32 pass = 0;
+        unsigned long flags = 0;
+
+        mvi = ((struct mvs_device *)task->dev->lldd_dev)->mvi_info;
+
+        if ((dev->dev_type == SATA_DEV) && (dev->sata_dev.ap != NULL))
+                spin_unlock_irq(dev->sata_dev.ap->lock);
+
+        spin_lock_irqsave(&mvi->lock, flags);
+        rc = mvs_task_prep(task, mvi, is_tmf, tmf, &pass);
+        if (rc)
+                dev_printk(KERN_ERR, mvi->dev, "mvsas exec failed[%d]!\n", rc);
+
+        if (likely(pass))
+                        MVS_CHIP_DISP->start_delivery(mvi, (mvi->tx_prod - 1) &
+                                (MVS_CHIP_SLOT_SZ - 1));
         spin_unlock_irqrestore(&mvi->lock, flags);
+
+        if ((dev->dev_type == SATA_DEV) && (dev->sata_dev.ap != NULL))
+                spin_lock_irq(dev->sata_dev.ap->lock);
+
+        return rc;
+}
+
+static int mvs_collector_task_exec(struct sas_task *task, const int num, gfp_t gfp_flags,
+                                struct completion *completion, int is_tmf,
+                                struct mvs_tmf_task *tmf)
+{
+        struct domain_device *dev = task->dev;
+        struct mvs_prv_info *mpi = dev->port->ha->lldd_ha;
+        struct mvs_info *mvi = NULL;
+        struct sas_task *t = task;
+        struct mvs_task_list *mvs_list = NULL, *a;
+        LIST_HEAD(q);
+        int pass[2] = {0};
+        u32 rc = 0;
+        u32 n = num;
+        unsigned long flags = 0;
+
+        mvs_list = mvs_task_alloc_list(&n, gfp_flags);
+        if (n) {
+                printk(KERN_ERR "%s: mvs alloc list failed.\n", __func__);
+                rc = -ENOMEM;
+                goto free_list;
+        }
+
+        __list_add(&q, mvs_list->list.prev, &mvs_list->list);
+
+        list_for_each_entry(a, &q, list) {
+                a->task = t;
+                t = list_entry(t->list.next, struct sas_task, list);
+        }
+
+        list_for_each_entry(a, &q , list) {
+
+                t = a->task;
+                mvi = ((struct mvs_device *)t->dev->lldd_dev)->mvi_info;
+
+                spin_lock_irqsave(&mvi->lock, flags);
+                rc = mvs_task_prep(t, mvi, is_tmf, tmf, &pass[mvi->id]);
+                if (rc)
+                        dev_printk(KERN_ERR, mvi->dev, "mvsas exec failed[%d]!\n", rc);
+                spin_unlock_irqrestore(&mvi->lock, flags);
+        }
+
+        if (likely(pass[0]))
+                        MVS_CHIP_DISP->start_delivery(mpi->mvi[0],
+                                (mpi->mvi[0]->tx_prod - 1) & (MVS_CHIP_SLOT_SZ - 1));
+
+        if (likely(pass[1]))
+                        MVS_CHIP_DISP->start_delivery(mpi->mvi[1],
+                                (mpi->mvi[1]->tx_prod - 1) & (MVS_CHIP_SLOT_SZ - 1));
+
+        list_del_init(&q);
+
+free_list:
+        if (mvs_list)
+                mvs_task_free_list(mvs_list);
+
         return rc;
 }
 
 int mvs_queue_command(struct sas_task *task, const int num,
                         gfp_t gfp_flags)
 {
-        return mvs_task_exec(task, num, gfp_flags, NULL, 0, NULL);
+        struct mvs_device *mvi_dev = task->dev->lldd_dev;
+        struct sas_ha_struct *sas = mvi_dev->mvi_info->sas;
+
+        if (sas->lldd_max_execute_num < 2)
+                return mvs_task_exec(task, num, gfp_flags, NULL, 0, NULL);
+        else
+                return mvs_collector_task_exec(task, num, gfp_flags, NULL, 0, NULL);
 }
 
 static void mvs_slot_free(struct mvs_info *mvi, u32 rx_desc)
@@ -1067,6 +1176,11 @@ static void mvs_slot_task_free(struct mvs_info *mvi, struct sas_task *task,
                 /* do nothing */
                 break;
         }
+
+        if (slot->buf) {
+                pci_pool_free(mvi->dma_pool, slot->buf, slot->buf_dma);
+                slot->buf = NULL;
+        }
         list_del_init(&slot->entry);
         task->lldd_task = NULL;
         slot->task = NULL;
@@ -1255,6 +1369,7 @@ static void mvs_port_notify_formed(struct asd_sas_phy *sas_phy, int lock)
                 spin_lock_irqsave(&mvi->lock, flags);
         port->port_attached = 1;
         phy->port = port;
+        sas_port->lldd_port = port;
         if (phy->phy_type & PORT_TYPE_SAS) {
                 port->wide_port_phymap = sas_port->phy_mask;
                 mv_printk("set wide port phy map %x\n", sas_port->phy_mask);
diff --git a/drivers/scsi/mvsas/mv_sas.h b/drivers/scsi/mvsas/mv_sas.h
index 77ddc7c1e5f2..1367d8b9350d 100644
--- a/drivers/scsi/mvsas/mv_sas.h
+++ b/drivers/scsi/mvsas/mv_sas.h
@@ -3,6 +3,7 @@
  *
  * Copyright 2007 Red Hat, Inc.
  * Copyright 2008 Marvell. <kewei@marvell.com>
+ * Copyright 2009-2011 Marvell. <yuxiangl@marvell.com>
  *
  * This file is licensed under GPLv2.
  *
@@ -67,6 +68,7 @@ extern struct mvs_tgt_initiator mvs_tgt;
 extern struct mvs_info *tgt_mvi;
 extern const struct mvs_dispatch mvs_64xx_dispatch;
 extern const struct mvs_dispatch mvs_94xx_dispatch;
+extern struct kmem_cache *mvs_task_list_cache;
 
 #define DEV_IS_EXPANDER(type)   \
         ((type == EDGE_DEV) || (type == FANOUT_DEV))
@@ -341,6 +343,7 @@ struct mvs_info {
         dma_addr_t bulk_buffer_dma;
 #define TRASH_BUCKET_SIZE       0x20000
 #endif
+        void *dma_pool;
         struct mvs_slot_info slot_info[0];
 };
 
@@ -367,6 +370,11 @@ struct mvs_task_exec_info {
         int n_elem;
 };
 
+struct mvs_task_list {
+        struct sas_task *task;
+        struct list_head list;
+};
+
 
 /******************** function prototype *********************/
 void mvs_get_sas_addr(void *buf, u32 buflen);
diff --git a/drivers/scsi/ncr53c8xx.c b/drivers/scsi/ncr53c8xx.c
index 835d8d66e696..4b3b4755945c 100644
--- a/drivers/scsi/ncr53c8xx.c
+++ b/drivers/scsi/ncr53c8xx.c
@@ -8147,7 +8147,7 @@ static int ncr53c8xx_abort(struct scsi_cmnd *cmd)
         unsigned long flags;
         struct scsi_cmnd *done_list;
 
-        printk("ncr53c8xx_abort: command pid %lu\n", cmd->serial_number);
+        printk("ncr53c8xx_abort\n");
 
         NCR_LOCK_NCB(np, flags);
 
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index 8ba5744c267e..d838205ab169 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -4066,7 +4066,7 @@ __qla1280_print_scsi_cmd(struct scsi_cmnd *cmd)
            } */
         printk("  tag=%d, transfersize=0x%x \n",
                cmd->tag, cmd->transfersize);
-        printk("  Pid=%li, SP=0x%p\n", cmd->serial_number, CMD_SP(cmd));
+        printk("  SP=0x%p\n", CMD_SP(cmd));
         printk(" underflow size = 0x%x, direction=0x%x\n",
                cmd->underflow, cmd->sc_data_direction);
 }
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index d3e58d763b43..532313e0725e 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -496,8 +496,8 @@ do_read:
                         offset = 0;
                 }
 
-                rval = qla2x00_read_sfp(vha, ha->sfp_data_dma, addr, offset,
-                    SFP_BLOCK_SIZE);
+                rval = qla2x00_read_sfp(vha, ha->sfp_data_dma, ha->sfp_data,
+                    addr, offset, SFP_BLOCK_SIZE, 0);
                 if (rval != QLA_SUCCESS) {
                         qla_printk(KERN_WARNING, ha,
                             "Unable to read SFP data (%x/%x/%x).\n", rval,
@@ -628,12 +628,12 @@ qla2x00_sysfs_write_edc(struct file *filp, struct kobject *kobj,
 
         memcpy(ha->edc_data, &buf[8], len);
 
-        rval = qla2x00_write_edc(vha, dev, adr, ha->edc_data_dma,
-            ha->edc_data, len, opt);
+        rval = qla2x00_write_sfp(vha, ha->edc_data_dma, ha->edc_data,
+            dev, adr, len, opt);
         if (rval != QLA_SUCCESS) {
                 DEBUG2(qla_printk(KERN_INFO, ha,
                     "Unable to write EDC (%x) %02x:%02x:%04x:%02x:%02x.\n",
-                    rval, dev, adr, opt, len, *buf));
+                    rval, dev, adr, opt, len, buf[8]));
                 return 0;
         }
 
@@ -685,8 +685,8 @@ qla2x00_sysfs_write_edc_status(struct file *filp, struct kobject *kobj,
                         return -EINVAL;
 
         memset(ha->edc_data, 0, len);
-        rval = qla2x00_read_edc(vha, dev, adr, ha->edc_data_dma,
-            ha->edc_data, len, opt);
+        rval = qla2x00_read_sfp(vha, ha->edc_data_dma, ha->edc_data,
+                        dev, adr, len, opt);
         if (rval != QLA_SUCCESS) {
                 DEBUG2(qla_printk(KERN_INFO, ha,
                     "Unable to write EDC status (%x) %02x:%02x:%04x:%02x.\n",
@@ -1568,7 +1568,7 @@ qla2x00_dev_loss_tmo_callbk(struct fc_rport *rport)
 
         /* Now that the rport has been deleted, set the fcport state to
            FCS_DEVICE_DEAD */
-        atomic_set(&fcport->state, FCS_DEVICE_DEAD);
+        qla2x00_set_fcport_state(fcport, FCS_DEVICE_DEAD);
 
         /*
          * Transport has effectively 'deleted' the rport, clear
@@ -1877,14 +1877,15 @@ qla24xx_vport_delete(struct fc_vport *fc_vport)
 
         scsi_remove_host(vha->host);
 
+        /* Allow timer to run to drain queued items, when removing vp */
+        qla24xx_deallocate_vp_id(vha);
+
         if (vha->timer_active) {
                 qla2x00_vp_stop_timer(vha);
                 DEBUG15(printk(KERN_INFO "scsi(%ld): timer for the vport[%d]"
                 " = %p has stopped\n", vha->host_no, vha->vp_idx, vha));
         }
 
-        qla24xx_deallocate_vp_id(vha);
-
         /* No pending activities shall be there on the vha now */
         DEBUG(msleep(random32()%10));  /* Just to see if something falls on
                                         * the net we have placed below */
diff --git a/drivers/scsi/qla2xxx/qla_bsg.c b/drivers/scsi/qla2xxx/qla_bsg.c
index 903b0586ded3..8c10e2c4928e 100644
--- a/drivers/scsi/qla2xxx/qla_bsg.c
+++ b/drivers/scsi/qla2xxx/qla_bsg.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_bsg.h b/drivers/scsi/qla2xxx/qla_bsg.h
index 074a999c7017..0f0f54e35f06 100644
--- a/drivers/scsi/qla2xxx/qla_bsg.h
+++ b/drivers/scsi/qla2xxx/qla_bsg.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_dbg.c b/drivers/scsi/qla2xxx/qla_dbg.c
index 096141148257..c53719a9a747 100644
--- a/drivers/scsi/qla2xxx/qla_dbg.c
+++ b/drivers/scsi/qla2xxx/qla_dbg.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_dbg.h b/drivers/scsi/qla2xxx/qla_dbg.h
index b74e6b5743dc..930414541ec6 100644
--- a/drivers/scsi/qla2xxx/qla_dbg.h
+++ b/drivers/scsi/qla2xxx/qla_dbg.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index ee20353c8550..cc5a79259d33 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -1717,6 +1717,14 @@ typedef struct fc_port {
 #define FCS_DEVICE_LOST         3
 #define FCS_ONLINE              4
 
+static const char * const port_state_str[] = {
+        "Unknown",
+        "UNCONFIGURED",
+        "DEAD",
+        "LOST",
+        "ONLINE"
+};
+
 /*
  * FC port flags.
  */
diff --git a/drivers/scsi/qla2xxx/qla_dfs.c b/drivers/scsi/qla2xxx/qla_dfs.c
index 6271353e8c51..a5a4e1275bf2 100644
--- a/drivers/scsi/qla2xxx/qla_dfs.c
+++ b/drivers/scsi/qla2xxx/qla_dfs.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_fw.h b/drivers/scsi/qla2xxx/qla_fw.h
index f5ba09c8a663..691783abfb69 100644
--- a/drivers/scsi/qla2xxx/qla_fw.h
+++ b/drivers/scsi/qla2xxx/qla_fw.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -416,8 +416,7 @@ struct cmd_type_6 {
         uint8_t vp_index;
 
         uint32_t fcp_data_dseg_address[2];      /* Data segment address. */
-        uint16_t fcp_data_dseg_len;             /* Data segment length. */
-        uint16_t reserved_1;                    /* MUST be set to 0. */
+        uint32_t fcp_data_dseg_len;             /* Data segment length. */
 };
 
 #define COMMAND_TYPE_7  0x18            /* Command Type 7 entry */
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index d48326ee3f61..0b381224ae4b 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -39,6 +39,8 @@ extern int qla81xx_load_risc(scsi_qla_host_t *, uint32_t *);
 extern int qla2x00_perform_loop_resync(scsi_qla_host_t *);
 extern int qla2x00_loop_resync(scsi_qla_host_t *);
 
+extern int qla2x00_find_new_loop_id(scsi_qla_host_t *, fc_port_t *);
+
 extern int qla2x00_fabric_login(scsi_qla_host_t *, fc_port_t *, uint16_t *);
 extern int qla2x00_local_device_login(scsi_qla_host_t *, fc_port_t *);
 
@@ -100,6 +102,8 @@ extern int ql2xgffidenable;
 extern int ql2xenabledif;
 extern int ql2xenablehba_err_chk;
 extern int ql2xtargetreset;
+extern int ql2xdontresethba;
+extern unsigned int ql2xmaxlun;
 
 extern int qla2x00_loop_reset(scsi_qla_host_t *);
 extern void qla2x00_abort_all_cmds(scsi_qla_host_t *, int);
@@ -319,15 +323,12 @@ extern int
 qla2x00_disable_fce_trace(scsi_qla_host_t *, uint64_t *, uint64_t *);
 
 extern int
-qla2x00_read_sfp(scsi_qla_host_t *, dma_addr_t, uint16_t, uint16_t, uint16_t);
-
-extern int
-qla2x00_read_edc(scsi_qla_host_t *, uint16_t, uint16_t, dma_addr_t,
-    uint8_t *, uint16_t, uint16_t);
+qla2x00_read_sfp(scsi_qla_host_t *, dma_addr_t, uint8_t *,
+        uint16_t, uint16_t, uint16_t, uint16_t);
 
 extern int
-qla2x00_write_edc(scsi_qla_host_t *, uint16_t, uint16_t, dma_addr_t,
-    uint8_t *, uint16_t, uint16_t);
+qla2x00_write_sfp(scsi_qla_host_t *, dma_addr_t, uint8_t *,
+        uint16_t, uint16_t, uint16_t, uint16_t);
 
 extern int
 qla2x00_set_idma_speed(scsi_qla_host_t *, uint16_t, uint16_t, uint16_t *);
@@ -549,7 +550,6 @@ extern int qla82xx_wr_32(struct qla_hw_data *, ulong, u32);
 extern int qla82xx_rd_32(struct qla_hw_data *, ulong);
 extern int qla82xx_rdmem(struct qla_hw_data *, u64, void *, int);
 extern int qla82xx_wrmem(struct qla_hw_data *, u64, void *, int);
-extern void qla82xx_rom_unlock(struct qla_hw_data *);
 
 /* ISP 8021 IDC */
 extern void qla82xx_clear_drv_active(struct qla_hw_data *);
diff --git a/drivers/scsi/qla2xxx/qla_gs.c b/drivers/scsi/qla2xxx/qla_gs.c
index 74a91b6dfc68..8cd9066ad906 100644
--- a/drivers/scsi/qla2xxx/qla_gs.c
+++ b/drivers/scsi/qla2xxx/qla_gs.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 8575808dbae0..920b76bfbb93 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -35,8 +35,6 @@ static int qla2x00_fabric_dev_login(scsi_qla_host_t *, fc_port_t *,
 
 static int qla2x00_restart_isp(scsi_qla_host_t *);
 
-static int qla2x00_find_new_loop_id(scsi_qla_host_t *, fc_port_t *);
-
 static struct qla_chip_state_84xx *qla84xx_get_chip(struct scsi_qla_host *);
 static int qla84xx_init_chip(scsi_qla_host_t *);
 static int qla25xx_init_queues(struct qla_hw_data *);
@@ -385,8 +383,18 @@ qla2x00_async_login_done(struct scsi_qla_host *vha, fc_port_t *fcport,
 
         switch (data[0]) {
         case MBS_COMMAND_COMPLETE:
+                /*
+                 * Driver must validate login state - If PRLI not complete,
+                 * force a relogin attempt via implicit LOGO, PLOGI, and PRLI
+                 * requests.
+                 */
+                rval = qla2x00_get_port_database(vha, fcport, 0);
+                if (rval != QLA_SUCCESS) {
+                        qla2x00_post_async_logout_work(vha, fcport, NULL);
+                        qla2x00_post_async_login_work(vha, fcport, NULL);
+                        break;
+                }
                 if (fcport->flags & FCF_FCP2_DEVICE) {
-                        fcport->flags |= FCF_ASYNC_SENT;
                         qla2x00_post_async_adisc_work(vha, fcport, data);
                         break;
                 }
@@ -397,7 +405,7 @@ qla2x00_async_login_done(struct scsi_qla_host *vha, fc_port_t *fcport,
                 if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
                         set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
                 else
-                        qla2x00_mark_device_lost(vha, fcport, 1, 1);
+                        qla2x00_mark_device_lost(vha, fcport, 1, 0);
                 break;
         case MBS_PORT_ID_USED:
                 fcport->loop_id = data[1];
@@ -409,7 +417,7 @@ qla2x00_async_login_done(struct scsi_qla_host *vha, fc_port_t *fcport,
                 rval = qla2x00_find_new_loop_id(vha, fcport);
                 if (rval != QLA_SUCCESS) {
                         fcport->flags &= ~FCF_ASYNC_SENT;
-                        qla2x00_mark_device_lost(vha, fcport, 1, 1);
+                        qla2x00_mark_device_lost(vha, fcport, 1, 0);
                         break;
                 }
                 qla2x00_post_async_login_work(vha, fcport, NULL);
@@ -441,7 +449,7 @@ qla2x00_async_adisc_done(struct scsi_qla_host *vha, fc_port_t *fcport,
         if (data[1] & QLA_LOGIO_LOGIN_RETRIED)
                 set_bit(RELOGIN_NEEDED, &vha->dpc_flags);
         else
-                qla2x00_mark_device_lost(vha, fcport, 1, 1);
+                qla2x00_mark_device_lost(vha, fcport, 1, 0);
 
         return;
 }
@@ -2536,7 +2544,7 @@ qla2x00_alloc_fcport(scsi_qla_host_t *vha, gfp_t flags)
         fcport->vp_idx = vha->vp_idx;
         fcport->port_type = FCT_UNKNOWN;
         fcport->loop_id = FC_NO_LOOP_ID;
-        atomic_set(&fcport->state, FCS_UNCONFIGURED);
+        qla2x00_set_fcport_state(fcport, FCS_UNCONFIGURED);
         fcport->supported_classes = FC_COS_UNSPECIFIED;
 
         return fcport;
@@ -2722,7 +2730,7 @@ qla2x00_configure_local_loop(scsi_qla_host_t *vha)
                             "loop_id=0x%04x\n",
                             vha->host_no, fcport->loop_id));
 
-                        atomic_set(&fcport->state, FCS_DEVICE_LOST);
+                        qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
                 }
         }
 
@@ -2934,7 +2942,7 @@ qla2x00_update_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
         qla2x00_iidma_fcport(vha, fcport);
         qla24xx_update_fcport_fcp_prio(vha, fcport);
         qla2x00_reg_remote_port(vha, fcport);
-        atomic_set(&fcport->state, FCS_ONLINE);
+        qla2x00_set_fcport_state(fcport, FCS_ONLINE);
 }
 
 /*
@@ -3391,7 +3399,7 @@ qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
  * Context:
  *      Kernel context.
  */
-static int
+int
 qla2x00_find_new_loop_id(scsi_qla_host_t *vha, fc_port_t *dev)
 {
         int     rval;
@@ -5202,7 +5210,7 @@ qla81xx_nvram_config(scsi_qla_host_t *vha)
         }
 
         /* Reset Initialization control block */
-        memset(icb, 0, sizeof(struct init_cb_81xx));
+        memset(icb, 0, ha->init_cb_size);
 
         /* Copy 1st segment. */
         dptr1 = (uint8_t *)icb;
@@ -5427,6 +5435,13 @@ qla82xx_restart_isp(scsi_qla_host_t *vha)
                 ha->isp_abort_cnt = 0;
                 clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
 
+                /* Update the firmware version */
+                qla2x00_get_fw_version(vha, &ha->fw_major_version,
+                    &ha->fw_minor_version, &ha->fw_subminor_version,
+                    &ha->fw_attributes, &ha->fw_memory_size,
+                    ha->mpi_version, &ha->mpi_capabilities,
+                    ha->phy_version);
+
                 if (ha->fce) {
                         ha->flags.fce_enabled = 1;
                         memset(ha->fce, 0,
@@ -5508,26 +5523,26 @@ qla81xx_update_fw_options(scsi_qla_host_t *vha)
  *
  * Return:
  *      non-zero (if found)
- *      0 (if not found)
+ *      -1 (if not found)
  *
  * Context:
  *      Kernel context
  */
-uint8_t
+static int
 qla24xx_get_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
 {
         int i, entries;
         uint8_t pid_match, wwn_match;
-        uint8_t priority;
+        int priority;
         uint32_t pid1, pid2;
         uint64_t wwn1, wwn2;
         struct qla_fcp_prio_entry *pri_entry;
         struct qla_hw_data *ha = vha->hw;
 
         if (!ha->fcp_prio_cfg || !ha->flags.fcp_prio_enabled)
-                return 0;
+                return -1;
 
-        priority = 0;
+        priority = -1;
         entries = ha->fcp_prio_cfg->num_entries;
         pri_entry = &ha->fcp_prio_cfg->entry[0];
 
@@ -5610,7 +5625,7 @@ int
 qla24xx_update_fcport_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
 {
         int ret;
-        uint8_t priority;
+        int priority;
         uint16_t mb[5];
 
         if (fcport->port_type != FCT_TARGET ||
@@ -5618,6 +5633,9 @@ qla24xx_update_fcport_fcp_prio(scsi_qla_host_t *vha, fc_port_t *fcport)
                 return QLA_FUNCTION_FAILED;
 
         priority = qla24xx_get_fcp_prio(vha, fcport);
+        if (priority < 0)
+                return QLA_FUNCTION_FAILED;
+
         ret = qla24xx_set_fcp_prio(vha, fcport->loop_id, priority, mb);
         if (ret == QLA_SUCCESS)
                 fcport->fcp_prio = priority;
diff --git a/drivers/scsi/qla2xxx/qla_inline.h b/drivers/scsi/qla2xxx/qla_inline.h
index 48f97a92e33d..4c8167e11f69 100644
--- a/drivers/scsi/qla2xxx/qla_inline.h
+++ b/drivers/scsi/qla2xxx/qla_inline.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -83,3 +83,22 @@ qla2x00_clean_dsd_pool(struct qla_hw_data *ha, srb_t *sp)
         }
         INIT_LIST_HEAD(&((struct crc_context *)sp->ctx)->dsd_list);
 }
+
+static inline void
+qla2x00_set_fcport_state(fc_port_t *fcport, int state)
+{
+        int old_state;
+
+        old_state = atomic_read(&fcport->state);
+        atomic_set(&fcport->state, state);
+
+        /* Don't print state transitions during initial allocation of fcport */
+        if (old_state && old_state != state) {
+                DEBUG(qla_printk(KERN_WARNING, fcport->vha->hw,
+                    "scsi(%ld): FCPort state transitioned from %s to %s - "
+                    "portid=%02x%02x%02x.\n", fcport->vha->host_no,
+                    port_state_str[old_state], port_state_str[state],
+                    fcport->d_id.b.domain, fcport->d_id.b.area,
+                    fcport->d_id.b.al_pa));
+        }
+}
diff --git a/drivers/scsi/qla2xxx/qla_iocb.c b/drivers/scsi/qla2xxx/qla_iocb.c
index d78d5896fc33..7bac3cd109d6 100644
--- a/drivers/scsi/qla2xxx/qla_iocb.c
+++ b/drivers/scsi/qla2xxx/qla_iocb.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index 712518d05128..9c0f0e3389eb 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -843,7 +843,10 @@ qla2x00_process_completed_request(struct scsi_qla_host *vha,
                 qla_printk(KERN_WARNING, ha,
                     "Invalid SCSI completion handle %d.\n", index);
 
-                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                if (IS_QLA82XX(ha))
+                        set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
+                else
+                        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                 return;
         }
 
@@ -861,7 +864,10 @@ qla2x00_process_completed_request(struct scsi_qla_host *vha,
                 qla_printk(KERN_WARNING, ha,
                     "Invalid ISP SCSI completion handle\n");
 
-                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                if (IS_QLA82XX(ha))
+                        set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
+                else
+                        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
         }
 }
 
@@ -878,7 +884,10 @@ qla2x00_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
         if (index >= MAX_OUTSTANDING_COMMANDS) {
                 qla_printk(KERN_WARNING, ha,
                     "%s: Invalid completion handle (%x).\n", func, index);
-                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                if (IS_QLA82XX(ha))
+                        set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
+                else
+                        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                 goto done;
         }
         sp = req->outstanding_cmds[index];
@@ -1564,7 +1573,10 @@ qla2x00_status_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, void *pkt)
                     "scsi(%ld): Invalid status handle (0x%x).\n", vha->host_no,
                     sts->handle);
 
-                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                if (IS_QLA82XX(ha))
+                        set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
+                else
+                        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                 qla2xxx_wake_dpc(vha);
                 return;
         }
@@ -1794,12 +1806,13 @@ out:
         if (logit)
                 DEBUG2(qla_printk(KERN_INFO, ha,
                     "scsi(%ld:%d:%d) FCP command status: 0x%x-0x%x (0x%x) "
-                    "oxid=0x%x cdb=%02x%02x%02x len=0x%x "
+                    "portid=%02x%02x%02x oxid=0x%x cdb=%02x%02x%02x len=0x%x "
                     "rsp_info=0x%x resid=0x%x fw_resid=0x%x\n", vha->host_no,
                     cp->device->id, cp->device->lun, comp_status, scsi_status,
-                    cp->result, ox_id, cp->cmnd[0],
-                    cp->cmnd[1], cp->cmnd[2], scsi_bufflen(cp), rsp_info_len,
-                    resid_len, fw_resid_len));
+                    cp->result, fcport->d_id.b.domain, fcport->d_id.b.area,
+                    fcport->d_id.b.al_pa, ox_id, cp->cmnd[0], cp->cmnd[1],
+                    cp->cmnd[2], scsi_bufflen(cp), rsp_info_len, resid_len,
+                    fw_resid_len));
 
         if (rsp->status_srb == NULL)
                 qla2x00_sp_compl(ha, sp);
@@ -1908,13 +1921,17 @@ qla2x00_error_entry(scsi_qla_host_t *vha, struct rsp_que *rsp, sts_entry_t *pkt)
                 qla2x00_sp_compl(ha, sp);
 
         } else if (pkt->entry_type == COMMAND_A64_TYPE || pkt->entry_type ==
-            COMMAND_TYPE || pkt->entry_type == COMMAND_TYPE_7) {
+                COMMAND_TYPE || pkt->entry_type == COMMAND_TYPE_7
+                || pkt->entry_type == COMMAND_TYPE_6) {
                 DEBUG2(printk("scsi(%ld): Error entry - invalid handle\n",
-                    vha->host_no));
+                        vha->host_no));
                 qla_printk(KERN_WARNING, ha,
-                    "Error entry - invalid handle\n");
+                        "Error entry - invalid handle\n");
 
-                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                if (IS_QLA82XX(ha))
+                        set_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags);
+                else
+                        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                 qla2xxx_wake_dpc(vha);
         }
 }
diff --git a/drivers/scsi/qla2xxx/qla_mbx.c b/drivers/scsi/qla2xxx/qla_mbx.c
index 34893397ac84..c26f0acdfecc 100644
--- a/drivers/scsi/qla2xxx/qla_mbx.c
+++ b/drivers/scsi/qla2xxx/qla_mbx.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -1261,11 +1261,12 @@ qla2x00_get_port_database(scsi_qla_host_t *vha, fc_port_t *fcport, uint8_t opt)
                 /* Check for logged in state. */
                 if (pd24->current_login_state != PDS_PRLI_COMPLETE &&
                     pd24->last_login_state != PDS_PRLI_COMPLETE) {
-                        DEBUG2(printk("%s(%ld): Unable to verify "
-                            "login-state (%x/%x) for loop_id %x\n",
-                            __func__, vha->host_no,
-                            pd24->current_login_state,
-                            pd24->last_login_state, fcport->loop_id));
+                        DEBUG2(qla_printk(KERN_WARNING, ha,
+                           "scsi(%ld): Unable to verify login-state (%x/%x) "
+                           " - portid=%02x%02x%02x.\n", vha->host_no,
+                           pd24->current_login_state, pd24->last_login_state,
+                           fcport->d_id.b.domain, fcport->d_id.b.area,
+                           fcport->d_id.b.al_pa));
                         rval = QLA_FUNCTION_FAILED;
                         goto gpd_error_out;
                 }
@@ -1289,6 +1290,12 @@ qla2x00_get_port_database(scsi_qla_host_t *vha, fc_port_t *fcport, uint8_t opt)
                 /* Check for logged in state. */
                 if (pd->master_state != PD_STATE_PORT_LOGGED_IN &&
                     pd->slave_state != PD_STATE_PORT_LOGGED_IN) {
+                        DEBUG2(qla_printk(KERN_WARNING, ha,
+                           "scsi(%ld): Unable to verify login-state (%x/%x) "
+                           " - portid=%02x%02x%02x.\n", vha->host_no,
+                           pd->master_state, pd->slave_state,
+                           fcport->d_id.b.domain, fcport->d_id.b.area,
+                           fcport->d_id.b.al_pa));
                         rval = QLA_FUNCTION_FAILED;
                         goto gpd_error_out;
                 }
@@ -1883,7 +1890,8 @@ qla24xx_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
         lg->handle = MAKE_HANDLE(req->id, lg->handle);
         lg->nport_handle = cpu_to_le16(loop_id);
         lg->control_flags =
-            __constant_cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO);
+            __constant_cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO|
+                LCF_FREE_NPORT);
         lg->port_id[0] = al_pa;
         lg->port_id[1] = area;
         lg->port_id[2] = domain;
@@ -2362,7 +2370,7 @@ qla24xx_abort_command(srb_t *sp)
         abt->entry_count = 1;
         abt->handle = MAKE_HANDLE(req->id, abt->handle);
         abt->nport_handle = cpu_to_le16(fcport->loop_id);
-        abt->handle_to_abort = handle;
+        abt->handle_to_abort = MAKE_HANDLE(req->id, handle);
         abt->port_id[0] = fcport->d_id.b.al_pa;
         abt->port_id[1] = fcport->d_id.b.area;
         abt->port_id[2] = fcport->d_id.b.domain;
@@ -2779,44 +2787,6 @@ qla2x00_disable_fce_trace(scsi_qla_host_t *vha, uint64_t *wr, uint64_t *rd)
 }
 
 int
-qla2x00_read_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint16_t addr,
-    uint16_t off, uint16_t count)
-{
-        int rval;
-        mbx_cmd_t mc;
-        mbx_cmd_t *mcp = &mc;
-
-        if (!IS_FWI2_CAPABLE(vha->hw))
-                return QLA_FUNCTION_FAILED;
-
-        DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
-
-        mcp->mb[0] = MBC_READ_SFP;
-        mcp->mb[1] = addr;
-        mcp->mb[2] = MSW(sfp_dma);
-        mcp->mb[3] = LSW(sfp_dma);
-        mcp->mb[6] = MSW(MSD(sfp_dma));
-        mcp->mb[7] = LSW(MSD(sfp_dma));
-        mcp->mb[8] = count;
-        mcp->mb[9] = off;
-        mcp->mb[10] = 0;
-        mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
-        mcp->in_mb = MBX_0;
-        mcp->tov = MBX_TOV_SECONDS;
-        mcp->flags = 0;
-        rval = qla2x00_mailbox_command(vha, mcp);
-
-        if (rval != QLA_SUCCESS) {
-                DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
-        } else {
-                DEBUG11(printk("%s(%ld): done.\n", __func__, vha->host_no));
-        }
-
-        return rval;
-}
-
-int
 qla2x00_get_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
         uint16_t *port_speed, uint16_t *mb)
 {
@@ -3581,15 +3551,22 @@ qla81xx_restart_mpi_firmware(scsi_qla_host_t *vha)
 }
 
 int
-qla2x00_read_edc(scsi_qla_host_t *vha, uint16_t dev, uint16_t adr,
-    dma_addr_t sfp_dma, uint8_t *sfp, uint16_t len, uint16_t opt)
+qla2x00_read_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
+        uint16_t dev, uint16_t off, uint16_t len, uint16_t opt)
 {
         int rval;
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
+        struct qla_hw_data *ha = vha->hw;
+
+        if (!IS_FWI2_CAPABLE(ha))
+                return QLA_FUNCTION_FAILED;
 
         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
 
+        if (len == 1)
+                opt |= BIT_0;
+
         mcp->mb[0] = MBC_READ_SFP;
         mcp->mb[1] = dev;
         mcp->mb[2] = MSW(sfp_dma);
@@ -3597,17 +3574,16 @@ qla2x00_read_edc(scsi_qla_host_t *vha, uint16_t dev, uint16_t adr,
         mcp->mb[6] = MSW(MSD(sfp_dma));
         mcp->mb[7] = LSW(MSD(sfp_dma));
         mcp->mb[8] = len;
-        mcp->mb[9] = adr;
+        mcp->mb[9] = off;
         mcp->mb[10] = opt;
         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
-        mcp->in_mb = MBX_0;
+        mcp->in_mb = MBX_1|MBX_0;
         mcp->tov = MBX_TOV_SECONDS;
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
 
         if (opt & BIT_0)
-                if (sfp)
-                        *sfp = mcp->mb[8];
+                *sfp = mcp->mb[1];
 
         if (rval != QLA_SUCCESS) {
                 DEBUG2_3_11(printk("%s(%ld): failed=%x (%x).\n", __func__,
@@ -3620,18 +3596,24 @@ qla2x00_read_edc(scsi_qla_host_t *vha, uint16_t dev, uint16_t adr,
 }
 
 int
-qla2x00_write_edc(scsi_qla_host_t *vha, uint16_t dev, uint16_t adr,
-    dma_addr_t sfp_dma, uint8_t *sfp, uint16_t len, uint16_t opt)
+qla2x00_write_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
+        uint16_t dev, uint16_t off, uint16_t len, uint16_t opt)
 {
         int rval;
         mbx_cmd_t mc;
         mbx_cmd_t *mcp = &mc;
+        struct qla_hw_data *ha = vha->hw;
+
+        if (!IS_FWI2_CAPABLE(ha))
+                return QLA_FUNCTION_FAILED;
 
         DEBUG11(printk("%s(%ld): entered.\n", __func__, vha->host_no));
 
+        if (len == 1)
+                opt |= BIT_0;
+
         if (opt & BIT_0)
-                if (sfp)
-                        len = *sfp;
+                len = *sfp;
 
         mcp->mb[0] = MBC_WRITE_SFP;
         mcp->mb[1] = dev;
@@ -3640,10 +3622,10 @@ qla2x00_write_edc(scsi_qla_host_t *vha, uint16_t dev, uint16_t adr,
         mcp->mb[6] = MSW(MSD(sfp_dma));
         mcp->mb[7] = LSW(MSD(sfp_dma));
         mcp->mb[8] = len;
-        mcp->mb[9] = adr;
+        mcp->mb[9] = off;
         mcp->mb[10] = opt;
         mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
-        mcp->in_mb = MBX_0;
+        mcp->in_mb = MBX_1|MBX_0;
         mcp->tov = MBX_TOV_SECONDS;
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
@@ -4160,63 +4142,32 @@ int
 qla2x00_get_thermal_temp(scsi_qla_host_t *vha, uint16_t *temp, uint16_t *frac)
 {
         int rval;
-        mbx_cmd_t mc;
-        mbx_cmd_t *mcp = &mc;
+        uint8_t byte;
         struct qla_hw_data *ha = vha->hw;
 
-        DEBUG11(printk(KERN_INFO "%s(%ld): entered.\n", __func__, ha->host_no));
+        DEBUG11(printk(KERN_INFO "%s(%ld): entered.\n", __func__, vha->host_no));
 
-        /* High bits. */
-        mcp->mb[0] = MBC_READ_SFP;
-        mcp->mb[1] = 0x98;
-        mcp->mb[2] = 0;
-        mcp->mb[3] = 0;
-        mcp->mb[6] = 0;
-        mcp->mb[7] = 0;
-        mcp->mb[8] = 1;
-        mcp->mb[9] = 0x01;
-        mcp->mb[10] = BIT_13|BIT_0;
-        mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
-        mcp->in_mb = MBX_1|MBX_0;
-        mcp->tov = MBX_TOV_SECONDS;
-        mcp->flags = 0;
-        rval = qla2x00_mailbox_command(vha, mcp);
+        /* Integer part */
+        rval = qla2x00_read_sfp(vha, 0, &byte, 0x98, 0x01, 1, BIT_13|BIT_0);
         if (rval != QLA_SUCCESS) {
                 DEBUG2_3_11(printk(KERN_WARNING
-                    "%s(%ld): failed=%x (%x).\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
+                    "%s(%ld): failed=%x.\n", __func__, vha->host_no, rval));
                 ha->flags.thermal_supported = 0;
                 goto fail;
         }
-        *temp = mcp->mb[1] & 0xFF;
+        *temp = byte;
 
-        /* Low bits. */
-        mcp->mb[0] = MBC_READ_SFP;
-        mcp->mb[1] = 0x98;
-        mcp->mb[2] = 0;
-        mcp->mb[3] = 0;
-        mcp->mb[6] = 0;
-        mcp->mb[7] = 0;
-        mcp->mb[8] = 1;
-        mcp->mb[9] = 0x10;
-        mcp->mb[10] = BIT_13|BIT_0;
-        mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
-        mcp->in_mb = MBX_1|MBX_0;
-        mcp->tov = MBX_TOV_SECONDS;
-        mcp->flags = 0;
-        rval = qla2x00_mailbox_command(vha, mcp);
+        /* Fraction part */
+        rval = qla2x00_read_sfp(vha, 0, &byte, 0x98, 0x10, 1, BIT_13|BIT_0);
         if (rval != QLA_SUCCESS) {
                 DEBUG2_3_11(printk(KERN_WARNING
-                    "%s(%ld): failed=%x (%x).\n", __func__,
-                    vha->host_no, rval, mcp->mb[0]));
+                    "%s(%ld): failed=%x.\n", __func__, vha->host_no, rval));
                 ha->flags.thermal_supported = 0;
                 goto fail;
         }
-        *frac = ((mcp->mb[1] & 0xFF) >> 6) * 25;
+        *frac = (byte >> 6) * 25;
 
-        if (rval == QLA_SUCCESS)
-                DEBUG11(printk(KERN_INFO
-                    "%s(%ld): done.\n", __func__, ha->host_no));
+        DEBUG11(printk(KERN_INFO "%s(%ld): done.\n", __func__, vha->host_no));
 fail:
         return rval;
 }
diff --git a/drivers/scsi/qla2xxx/qla_mid.c b/drivers/scsi/qla2xxx/qla_mid.c
index 2b69392a71a1..5e343919acad 100644
--- a/drivers/scsi/qla2xxx/qla_mid.c
+++ b/drivers/scsi/qla2xxx/qla_mid.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -136,7 +136,7 @@ qla2x00_mark_vp_devices_dead(scsi_qla_host_t *vha)
                     vha->host_no, fcport->loop_id, fcport->vp_idx));
 
                 qla2x00_mark_device_lost(vha, fcport, 0, 0);
-                atomic_set(&fcport->state, FCS_UNCONFIGURED);
+                qla2x00_set_fcport_state(fcport, FCS_UNCONFIGURED);
         }
 }
 
@@ -456,7 +456,7 @@ qla24xx_create_vhost(struct fc_vport *fc_vport)
         else
                 host->max_cmd_len = MAX_CMDSZ;
         host->max_channel = MAX_BUSES - 1;
-        host->max_lun = MAX_LUNS;
+        host->max_lun = ql2xmaxlun;
         host->unique_id = host->host_no;
         host->max_id = MAX_TARGETS_2200;
         host->transportt = qla2xxx_transport_vport_template;
diff --git a/drivers/scsi/qla2xxx/qla_nx.c b/drivers/scsi/qla2xxx/qla_nx.c
index 455fe134d31d..e1138bcc834c 100644
--- a/drivers/scsi/qla2xxx/qla_nx.c
+++ b/drivers/scsi/qla2xxx/qla_nx.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -844,6 +844,12 @@ qla82xx_rom_lock(struct qla_hw_data *ha)
         return 0;
 }
 
+static void
+qla82xx_rom_unlock(struct qla_hw_data *ha)
+{
+        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+}
+
 static int
 qla82xx_wait_rom_busy(struct qla_hw_data *ha)
 {
@@ -924,7 +930,7 @@ qla82xx_rom_fast_read(struct qla_hw_data *ha, int addr, int *valp)
                 return -1;
         }
         ret = qla82xx_do_rom_fast_read(ha, addr, valp);
-        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+        qla82xx_rom_unlock(ha);
         return ret;
 }
 
@@ -1056,7 +1062,7 @@ qla82xx_write_flash_dword(struct qla_hw_data *ha, uint32_t flashaddr,
         ret = qla82xx_flash_wait_write_finish(ha);
 
 done_write:
-        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+        qla82xx_rom_unlock(ha);
         return ret;
 }
 
@@ -1081,12 +1087,26 @@ qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
         /* Halt all the indiviual PEGs and other blocks of the ISP */
         qla82xx_rom_lock(ha);
 
-        /* mask all niu interrupts */
+        /* disable all I2Q */
+        qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x10, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x14, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x18, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x1c, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x20, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_I2Q + 0x24, 0x0);
+
+        /* disable all niu interrupts */
         qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x40, 0xff);
         /* disable xge rx/tx */
         qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x70000, 0x00);
         /* disable xg1 rx/tx */
         qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x80000, 0x00);
+        /* disable sideband mac */
+        qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0x90000, 0x00);
+        /* disable ap0 mac */
+        qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0xa0000, 0x00);
+        /* disable ap1 mac */
+        qla82xx_wr_32(ha, QLA82XX_CRB_NIU + 0xb0000, 0x00);
 
         /* halt sre */
         val = qla82xx_rd_32(ha, QLA82XX_CRB_SRE + 0x1000);
@@ -1101,6 +1121,7 @@ qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
         qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x10, 0x0);
         qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x18, 0x0);
         qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x100, 0x0);
+        qla82xx_wr_32(ha, QLA82XX_CRB_TIMER + 0x200, 0x0);
 
         /* halt pegs */
         qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_0 + 0x3c, 1);
@@ -1108,9 +1129,9 @@ qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
         qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_2 + 0x3c, 1);
         qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_3 + 0x3c, 1);
         qla82xx_wr_32(ha, QLA82XX_CRB_PEG_NET_4 + 0x3c, 1);
+        msleep(20);
 
         /* big hammer */
-        msleep(1000);
         if (test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))
                 /* don't reset CAM block on reset */
                 qla82xx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, 0xfeffffff);
@@ -1129,7 +1150,7 @@ qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
         qla82xx_wr_32(ha, QLA82XX_CRB_QDR_NET + 0xe4, val);
         msleep(20);
 
-        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+        qla82xx_rom_unlock(ha);
 
         /* Read the signature value from the flash.
          * Offset 0: Contain signature (0xcafecafe)
@@ -2395,9 +2416,13 @@ qla82xx_load_fw(scsi_qla_host_t *vha)
 
         if (qla82xx_fw_load_from_flash(ha) == QLA_SUCCESS) {
                 qla_printk(KERN_ERR, ha,
-                        "Firmware loaded successfully from flash\n");
+                    "Firmware loaded successfully from flash\n");
                 return QLA_SUCCESS;
+        } else {
+                qla_printk(KERN_ERR, ha,
+                    "Firmware load from flash failed\n");
         }
+
 try_blob_fw:
         qla_printk(KERN_INFO, ha,
             "Attempting to load firmware from blob\n");
@@ -2548,11 +2573,11 @@ qla2xx_build_scsi_type_6_iocbs(srb_t *sp, struct cmd_type_6 *cmd_pkt,
                         dsd_seg = (uint32_t *)&cmd_pkt->fcp_data_dseg_address;
                         *dsd_seg++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma));
                         *dsd_seg++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma));
-                        cmd_pkt->fcp_data_dseg_len = dsd_list_len;
+                        *dsd_seg++ = cpu_to_le32(dsd_list_len);
                 } else {
                         *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma));
                         *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma));
-                        *cur_dsd++ = dsd_list_len;
+                        *cur_dsd++ = cpu_to_le32(dsd_list_len);
                 }
                 cur_dsd = (uint32_t *)next_dsd;
                 while (avail_dsds) {
@@ -2991,7 +3016,7 @@ qla82xx_unprotect_flash(struct qla_hw_data *ha)
                 qla_printk(KERN_WARNING, ha, "Write disable failed\n");
 
 done_unprotect:
-        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+        qla82xx_rom_unlock(ha);
         return ret;
 }
 
@@ -3020,7 +3045,7 @@ qla82xx_protect_flash(struct qla_hw_data *ha)
         if (qla82xx_write_disable_flash(ha) != 0)
                 qla_printk(KERN_WARNING, ha, "Write disable failed\n");
 done_protect:
-        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+        qla82xx_rom_unlock(ha);
         return ret;
 }
 
@@ -3048,7 +3073,7 @@ qla82xx_erase_sector(struct qla_hw_data *ha, int addr)
         }
         ret = qla82xx_flash_wait_write_finish(ha);
 done:
-        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+        qla82xx_rom_unlock(ha);
         return ret;
 }
 
@@ -3228,7 +3253,7 @@ void qla82xx_rom_lock_recovery(struct qla_hw_data *ha)
          * else died while holding it.
          * In either case, unlock.
          */
-        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+        qla82xx_rom_unlock(ha);
 }
 
 /*
@@ -3528,15 +3553,18 @@ int
 qla82xx_device_state_handler(scsi_qla_host_t *vha)
 {
         uint32_t dev_state;
+        uint32_t old_dev_state;
         int rval = QLA_SUCCESS;
         unsigned long dev_init_timeout;
         struct qla_hw_data *ha = vha->hw;
+        int loopcount = 0;
 
         qla82xx_idc_lock(ha);
         if (!vha->flags.init_done)
                 qla82xx_set_drv_active(vha);
 
         dev_state = qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE);
+        old_dev_state = dev_state;
         qla_printk(KERN_INFO, ha, "1:Device state is 0x%x = %s\n", dev_state,
                 dev_state < MAX_STATES ? qdev_state[dev_state] : "Unknown");
 
@@ -3553,10 +3581,16 @@ qla82xx_device_state_handler(scsi_qla_host_t *vha)
                         break;
                 }
                 dev_state = qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE);
-                qla_printk(KERN_INFO, ha,
-                        "2:Device state is 0x%x = %s\n", dev_state,
-                        dev_state < MAX_STATES ?
-                        qdev_state[dev_state] : "Unknown");
+                if (old_dev_state != dev_state) {
+                        loopcount = 0;
+                        old_dev_state = dev_state;
+                }
+                if (loopcount < 5) {
+                        qla_printk(KERN_INFO, ha,
+                            "2:Device state is 0x%x = %s\n", dev_state,
+                            dev_state < MAX_STATES ?
+                            qdev_state[dev_state] : "Unknown");
+                }
 
                 switch (dev_state) {
                 case QLA82XX_DEV_READY:
@@ -3570,6 +3604,7 @@ qla82xx_device_state_handler(scsi_qla_host_t *vha)
                         qla82xx_idc_lock(ha);
                         break;
                 case QLA82XX_DEV_NEED_RESET:
+                    if (!ql2xdontresethba)
                         qla82xx_need_reset_handler(vha);
                         dev_init_timeout = jiffies +
                                 (ha->nx_dev_init_timeout * HZ);
@@ -3604,6 +3639,7 @@ qla82xx_device_state_handler(scsi_qla_host_t *vha)
                         msleep(1000);
                         qla82xx_idc_lock(ha);
                 }
+                loopcount++;
         }
 exit:
         qla82xx_idc_unlock(ha);
@@ -3621,7 +3657,8 @@ void qla82xx_watchdog(scsi_qla_host_t *vha)
                 if (dev_state == QLA82XX_DEV_NEED_RESET &&
                     !test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags)) {
                         qla_printk(KERN_WARNING, ha,
-                            "%s(): Adapter reset needed!\n", __func__);
+                            "scsi(%ld) %s: Adapter reset needed!\n",
+                                vha->host_no, __func__);
                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                         qla2xxx_wake_dpc(vha);
                 } else if (dev_state == QLA82XX_DEV_NEED_QUIESCENT &&
@@ -3632,10 +3669,27 @@ void qla82xx_watchdog(scsi_qla_host_t *vha)
                         set_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags);
                         qla2xxx_wake_dpc(vha);
                 } else {
-                        qla82xx_check_fw_alive(vha);
                         if (qla82xx_check_fw_alive(vha)) {
                                 halt_status = qla82xx_rd_32(ha,
                                     QLA82XX_PEG_HALT_STATUS1);
+                                qla_printk(KERN_INFO, ha,
+                                    "scsi(%ld): %s, Dumping hw/fw registers:\n "
+                                    " PEG_HALT_STATUS1: 0x%x, PEG_HALT_STATUS2: 0x%x,\n "
+                                    " PEG_NET_0_PC: 0x%x, PEG_NET_1_PC: 0x%x,\n "
+                                    " PEG_NET_2_PC: 0x%x, PEG_NET_3_PC: 0x%x,\n "
+                                    " PEG_NET_4_PC: 0x%x\n",
+                                    vha->host_no, __func__, halt_status,
+                                    qla82xx_rd_32(ha, QLA82XX_PEG_HALT_STATUS2),
+                                    qla82xx_rd_32(ha,
+                                            QLA82XX_CRB_PEG_NET_0 + 0x3c),
+                                    qla82xx_rd_32(ha,
+                                            QLA82XX_CRB_PEG_NET_1 + 0x3c),
+                                    qla82xx_rd_32(ha,
+                                            QLA82XX_CRB_PEG_NET_2 + 0x3c),
+                                    qla82xx_rd_32(ha,
+                                            QLA82XX_CRB_PEG_NET_3 + 0x3c),
+                                    qla82xx_rd_32(ha,
+                                            QLA82XX_CRB_PEG_NET_4 + 0x3c));
                                 if (halt_status & HALT_STATUS_UNRECOVERABLE) {
                                         set_bit(ISP_UNRECOVERABLE,
                                             &vha->dpc_flags);
@@ -3651,8 +3705,9 @@ void qla82xx_watchdog(scsi_qla_host_t *vha)
                                 if (ha->flags.mbox_busy) {
                                         ha->flags.mbox_int = 1;
                                         DEBUG2(qla_printk(KERN_ERR, ha,
-                                            "Due to fw hung, doing premature "
-                                            "completion of mbx command\n"));
+                                            "scsi(%ld) Due to fw hung, doing "
+                                            "premature completion of mbx "
+                                            "command\n", vha->host_no));
                                         if (test_bit(MBX_INTR_WAIT,
                                             &ha->mbx_cmd_flags))
                                                 complete(&ha->mbx_intr_comp);
diff --git a/drivers/scsi/qla2xxx/qla_nx.h b/drivers/scsi/qla2xxx/qla_nx.h
index ed5883f1778a..8a21832c6693 100644
--- a/drivers/scsi/qla2xxx/qla_nx.h
+++ b/drivers/scsi/qla2xxx/qla_nx.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index aa7747529165..f461925a9dfc 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
@@ -164,6 +164,20 @@ module_param(ql2xasynctmfenable, int, S_IRUGO);
 MODULE_PARM_DESC(ql2xasynctmfenable,
                 "Enables issue of TM IOCBs asynchronously via IOCB mechanism"
                 "Default is 0 - Issue TM IOCBs via mailbox mechanism.");
+
+int ql2xdontresethba;
+module_param(ql2xdontresethba, int, S_IRUGO);
+MODULE_PARM_DESC(ql2xdontresethba,
+        "Option to specify reset behaviour\n"
+        " 0 (Default) -- Reset on failure.\n"
+        " 1 -- Do not reset on failure.\n");
+
+uint ql2xmaxlun = MAX_LUNS;
+module_param(ql2xmaxlun, uint, S_IRUGO);
+MODULE_PARM_DESC(ql2xmaxlun,
+                "Defines the maximum LU number to register with the SCSI "
+                "midlayer. Default is 65535.");
+
 /*
  * SCSI host template entry points
  */
@@ -528,7 +542,7 @@ qla2x00_get_new_sp(scsi_qla_host_t *vha, fc_port_t *fcport,
 static int
 qla2xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 {
-        scsi_qla_host_t *vha = shost_priv(cmd->device->host);
+        scsi_qla_host_t *vha = shost_priv(host);
         fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
         struct fc_rport *rport = starget_to_rport(scsi_target(cmd->device));
         struct qla_hw_data *ha = vha->hw;
@@ -2128,7 +2142,7 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         else
                 host->max_cmd_len = MAX_CMDSZ;
         host->max_channel = MAX_BUSES - 1;
-        host->max_lun = MAX_LUNS;
+        host->max_lun = ql2xmaxlun;
         host->transportt = qla2xxx_transport_template;
         sht->vendor_id = (SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_QLOGIC);
 
@@ -2360,21 +2374,26 @@ qla2x00_remove_one(struct pci_dev *pdev)
         base_vha = pci_get_drvdata(pdev);
         ha = base_vha->hw;
 
-        spin_lock_irqsave(&ha->vport_slock, flags);
-        list_for_each_entry(vha, &ha->vp_list, list) {
-                atomic_inc(&vha->vref_count);
+        mutex_lock(&ha->vport_lock);
+        while (ha->cur_vport_count) {
+                struct Scsi_Host *scsi_host;
 
-                if (vha->fc_vport) {
-                        spin_unlock_irqrestore(&ha->vport_slock, flags);
+                spin_lock_irqsave(&ha->vport_slock, flags);
 
-                        fc_vport_terminate(vha->fc_vport);
+                BUG_ON(base_vha->list.next == &ha->vp_list);
+                /* This assumes first entry in ha->vp_list is always base vha */
+                vha = list_first_entry(&base_vha->list, scsi_qla_host_t, list);
+                scsi_host = scsi_host_get(vha->host);
 
-                        spin_lock_irqsave(&ha->vport_slock, flags);
-                }
+                spin_unlock_irqrestore(&ha->vport_slock, flags);
+                mutex_unlock(&ha->vport_lock);
+
+                fc_vport_terminate(vha->fc_vport);
+                scsi_host_put(vha->host);
 
-                atomic_dec(&vha->vref_count);
+                mutex_lock(&ha->vport_lock);
         }
-        spin_unlock_irqrestore(&ha->vport_slock, flags);
+        mutex_unlock(&ha->vport_lock);
 
         set_bit(UNLOADING, &base_vha->dpc_flags);
 
@@ -2544,7 +2563,7 @@ void qla2x00_mark_device_lost(scsi_qla_host_t *vha, fc_port_t *fcport,
 {
         if (atomic_read(&fcport->state) == FCS_ONLINE &&
             vha->vp_idx == fcport->vp_idx) {
-                atomic_set(&fcport->state, FCS_DEVICE_LOST);
+                qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
                 qla2x00_schedule_rport_del(vha, fcport, defer);
         }
         /*
@@ -2552,7 +2571,7 @@ void qla2x00_mark_device_lost(scsi_qla_host_t *vha, fc_port_t *fcport,
          * port but do the retries.
          */
         if (atomic_read(&fcport->state) != FCS_DEVICE_DEAD)
-                atomic_set(&fcport->state, FCS_DEVICE_LOST);
+                qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
 
         if (!do_login)
                 return;
@@ -2607,7 +2626,7 @@ qla2x00_mark_all_devices_lost(scsi_qla_host_t *vha, int defer)
                 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD)
                         continue;
                 if (atomic_read(&fcport->state) == FCS_ONLINE) {
-                        atomic_set(&fcport->state, FCS_DEVICE_LOST);
+                        qla2x00_set_fcport_state(fcport, FCS_DEVICE_LOST);
                         if (defer)
                                 qla2x00_schedule_rport_del(vha, fcport, defer);
                         else if (vha->vp_idx == fcport->vp_idx)
@@ -3214,6 +3233,17 @@ void qla2x00_relogin(struct scsi_qla_host *vha)
                                                         fcport->d_id.b.area,
                                                         fcport->d_id.b.al_pa);
 
+                                if (fcport->loop_id == FC_NO_LOOP_ID) {
+                                        fcport->loop_id = next_loopid =
+                                            ha->min_external_loopid;
+                                        status = qla2x00_find_new_loop_id(
+                                            vha, fcport);
+                                        if (status != QLA_SUCCESS) {
+                                                /* Ran out of IDs to use */
+                                                break;
+                                        }
+                                }
+
                                 if (IS_ALOGIO_CAPABLE(ha)) {
                                         fcport->flags |= FCF_ASYNC_SENT;
                                         data[0] = 0;
@@ -3604,7 +3634,8 @@ qla2x00_timer(scsi_qla_host_t *vha)
         if (!pci_channel_offline(ha->pdev))
                 pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w);
 
-        if (IS_QLA82XX(ha)) {
+        /* Make sure qla82xx_watchdog is run only for physical port */
+        if (!vha->vp_idx && IS_QLA82XX(ha)) {
                 if (test_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags))
                         start_dpc++;
                 qla82xx_watchdog(vha);
@@ -3612,7 +3643,8 @@ qla2x00_timer(scsi_qla_host_t *vha)
 
         /* Loop down handler. */
         if (atomic_read(&vha->loop_down_timer) > 0 &&
-            !(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))
+            !(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) &&
+            !(test_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags))
                 && vha->flags.online) {
 
                 if (atomic_read(&vha->loop_down_timer) ==
@@ -3648,7 +3680,11 @@ qla2x00_timer(scsi_qla_host_t *vha)
                                         if (!(sfcp->flags & FCF_FCP2_DEVICE))
                                                 continue;
 
-                                        set_bit(ISP_ABORT_NEEDED,
+                                        if (IS_QLA82XX(ha))
+                                                set_bit(FCOE_CTX_RESET_NEEDED,
+                                                        &vha->dpc_flags);
+                                        else
+                                                set_bit(ISP_ABORT_NEEDED,
                                                         &vha->dpc_flags);
                                         break;
                                 }
@@ -3667,7 +3703,12 @@ qla2x00_timer(scsi_qla_host_t *vha)
                                 qla_printk(KERN_WARNING, ha,
                                     "Loop down - aborting ISP.\n");
 
-                                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                                if (IS_QLA82XX(ha))
+                                        set_bit(FCOE_CTX_RESET_NEEDED,
+                                                &vha->dpc_flags);
+                                else
+                                        set_bit(ISP_ABORT_NEEDED,
+                                                &vha->dpc_flags);
                         }
                 }
                 DEBUG3(printk("scsi(%ld): Loop Down - seconds remaining %d\n",
@@ -3675,8 +3716,8 @@ qla2x00_timer(scsi_qla_host_t *vha)
                     atomic_read(&vha->loop_down_timer)));
         }
 
-        /* Check if beacon LED needs to be blinked */
-        if (ha->beacon_blink_led == 1) {
+        /* Check if beacon LED needs to be blinked for physical host only */
+        if (!vha->vp_idx && (ha->beacon_blink_led == 1)) {
                 set_bit(BEACON_BLINK_NEEDED, &vha->dpc_flags);
                 start_dpc++;
         }
diff --git a/drivers/scsi/qla2xxx/qla_settings.h b/drivers/scsi/qla2xxx/qla_settings.h
index f0b2b9986a55..d70f03008981 100644
--- a/drivers/scsi/qla2xxx/qla_settings.h
+++ b/drivers/scsi/qla2xxx/qla_settings.h
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_sup.c b/drivers/scsi/qla2xxx/qla_sup.c
index 22070621206c..693647661ed1 100644
--- a/drivers/scsi/qla2xxx/qla_sup.c
+++ b/drivers/scsi/qla2xxx/qla_sup.c
@@ -1,6 +1,6 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
diff --git a/drivers/scsi/qla2xxx/qla_version.h b/drivers/scsi/qla2xxx/qla_version.h
index 3a260c3f055a..062c97bf62f5 100644
--- a/drivers/scsi/qla2xxx/qla_version.h
+++ b/drivers/scsi/qla2xxx/qla_version.h
@@ -1,15 +1,15 @@
 /*
  * QLogic Fibre Channel HBA Driver
- * Copyright (c)  2003-2010 QLogic Corporation
+ * Copyright (c)  2003-2011 QLogic Corporation
  *
  * See LICENSE.qla2xxx for copyright and licensing details.
  */
 /*
  * Driver version
  */
-#define QLA2XXX_VERSION      "8.03.07.00"
+#define QLA2XXX_VERSION      "8.03.07.03-k"
 
 #define QLA_DRIVER_MAJOR_VER    8
 #define QLA_DRIVER_MINOR_VER    3
 #define QLA_DRIVER_PATCH_VER    7
-#define QLA_DRIVER_BETA_VER     0
+#define QLA_DRIVER_BETA_VER     3
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index 230ba097d28c..c22f2a764d9d 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -2068,15 +2068,14 @@ static int qla4xxx_eh_abort(struct scsi_cmnd *cmd)
         struct scsi_qla_host *ha = to_qla_host(cmd->device->host);
         unsigned int id = cmd->device->id;
         unsigned int lun = cmd->device->lun;
-        unsigned long serial = cmd->serial_number;
         unsigned long flags;
         struct srb *srb = NULL;
         int ret = SUCCESS;
         int wait = 0;
 
         ql4_printk(KERN_INFO, ha,
-            "scsi%ld:%d:%d: Abort command issued cmd=%p, pid=%ld\n",
-            ha->host_no, id, lun, cmd, serial);
+            "scsi%ld:%d:%d: Abort command issued cmd=%p\n",
+            ha->host_no, id, lun, cmd);
 
         spin_lock_irqsave(&ha->hardware_lock, flags);
         srb = (struct srb *) CMD_SP(cmd);
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index 633c2395a92a..abea2cf05c2e 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -321,6 +321,12 @@ static int scsi_check_sense(struct scsi_cmnd *scmd)
                                     "changed. The Linux SCSI layer does not "
                                     "automatically adjust these parameters.\n");
 
+                if (sshdr.asc == 0x38 && sshdr.ascq == 0x07)
+                        scmd_printk(KERN_WARNING, scmd,
+                                    "Warning! Received an indication that the "
+                                    "LUN reached a thin provisioning soft "
+                                    "threshold.\n");
+
                 /*
                  * Pass the UA upwards for a determination in the completion
                  * functions.
diff --git a/drivers/scsi/scsi_proc.c b/drivers/scsi/scsi_proc.c
index c99da926fdac..f46855cd853d 100644
--- a/drivers/scsi/scsi_proc.c
+++ b/drivers/scsi/scsi_proc.c
@@ -386,13 +386,59 @@ static ssize_t proc_scsi_write(struct file *file, const char __user *buf,
  * @s: output goes here
  * @p: not used
  */
-static int proc_scsi_show(struct seq_file *s, void *p)
+static int always_match(struct device *dev, void *data)
 {
-        seq_printf(s, "Attached devices:\n");
-        bus_for_each_dev(&scsi_bus_type, NULL, s, proc_print_scsidevice);
-        return 0;
+        return 1;
+}
+
+static inline struct device *next_scsi_device(struct device *start)
+{
+        struct device *next = bus_find_device(&scsi_bus_type, start, NULL,
+                                              always_match);
+        put_device(start);
+        return next;
 }
 
+static void *scsi_seq_start(struct seq_file *sfile, loff_t *pos)
+{
+        struct device *dev = NULL;
+        loff_t n = *pos;
+
+        while ((dev = next_scsi_device(dev))) {
+                if (!n--)
+                        break;
+                sfile->private++;
+        }
+        return dev;
+}
+
+static void *scsi_seq_next(struct seq_file *sfile, void *v, loff_t *pos)
+{
+        (*pos)++;
+        sfile->private++;
+        return next_scsi_device(v);
+}
+
+static void scsi_seq_stop(struct seq_file *sfile, void *v)
+{
+        put_device(v);
+}
+
+static int scsi_seq_show(struct seq_file *sfile, void *dev)
+{
+        if (!sfile->private)
+                seq_puts(sfile, "Attached devices:\n");
+
+        return proc_print_scsidevice(dev, sfile);
+}
+
+static const struct seq_operations scsi_seq_ops = {
+        .start  = scsi_seq_start,
+        .next   = scsi_seq_next,
+        .stop   = scsi_seq_stop,
+        .show   = scsi_seq_show
+};
+
 /**
  * proc_scsi_open - glue function
  * @inode: not used
@@ -406,7 +452,7 @@ static int proc_scsi_open(struct inode *inode, struct file *file)
          * We don't really need this for the write case but it doesn't
          * harm either.
          */
-        return single_open(file, proc_scsi_show, NULL);
+        return seq_open(file, &scsi_seq_ops);
 }
 
 static const struct file_operations proc_scsi_operations = {
@@ -415,7 +461,7 @@ static const struct file_operations proc_scsi_operations = {
         .read           = seq_read,
         .write          = proc_scsi_write,
         .llseek         = seq_lseek,
-        .release        = single_release,
+        .release        = seq_release,
 };
 
 /**
diff --git a/drivers/scsi/scsi_tgt_lib.c b/drivers/scsi/scsi_tgt_lib.c
index 8bca8c25ba69..84a1fdf67864 100644
--- a/drivers/scsi/scsi_tgt_lib.c
+++ b/drivers/scsi/scsi_tgt_lib.c
@@ -275,10 +275,8 @@ void scsi_tgt_free_queue(struct Scsi_Host *shost)
 
         for (i = 0; i < ARRAY_SIZE(qdata->cmd_hash); i++) {
                 list_for_each_entry_safe(tcmd, n, &qdata->cmd_hash[i],
-                                         hash_list) {
-                        list_del(&tcmd->hash_list);
-                        list_add(&tcmd->hash_list, &cmds);
-                }
+                                         hash_list)
+                        list_move(&tcmd->hash_list, &cmds);
         }
 
         spin_unlock_irqrestore(&qdata->cmd_hash_lock, flags);
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index 815069d13f9b..1b214910b714 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -422,8 +422,7 @@ static int fc_host_setup(struct transport_container *tc, struct device *dev,
 
         snprintf(fc_host->work_q_name, sizeof(fc_host->work_q_name),
                  "fc_wq_%d", shost->host_no);
-        fc_host->work_q = create_singlethread_workqueue(
-                                        fc_host->work_q_name);
+        fc_host->work_q = alloc_workqueue(fc_host->work_q_name, 0, 0);
         if (!fc_host->work_q)
                 return -ENOMEM;
 
@@ -431,8 +430,8 @@ static int fc_host_setup(struct transport_container *tc, struct device *dev,
         snprintf(fc_host->devloss_work_q_name,
                  sizeof(fc_host->devloss_work_q_name),
                  "fc_dl_%d", shost->host_no);
-        fc_host->devloss_work_q = create_singlethread_workqueue(
-                                        fc_host->devloss_work_q_name);
+        fc_host->devloss_work_q =
+                        alloc_workqueue(fc_host->devloss_work_q_name, 0, 0);
         if (!fc_host->devloss_work_q) {
                 destroy_workqueue(fc_host->work_q);
                 fc_host->work_q = NULL;
@@ -2489,6 +2488,8 @@ fc_rport_final_delete(struct work_struct *work)
         unsigned long flags;
         int do_callback = 0;
 
+        fc_terminate_rport_io(rport);
+
         /*
          * if a scan is pending, flush the SCSI Host work_q so that
          * that we can reclaim the rport scan work element.
@@ -2496,8 +2497,6 @@ fc_rport_final_delete(struct work_struct *work)
         if (rport->flags & FC_RPORT_SCAN_PENDING)
                 scsi_flush_work(shost);
 
-        fc_terminate_rport_io(rport);
-
         /*
          * Cancel any outstanding timers. These should really exist
          * only when rmmod'ing the LLDD and we're asking for
diff --git a/drivers/scsi/tmscsim.c b/drivers/scsi/tmscsim.c
index a124a28f2ccb..a1baccce05f0 100644
--- a/drivers/scsi/tmscsim.c
+++ b/drivers/scsi/tmscsim.c
@@ -565,12 +565,12 @@ dc390_StartSCSI( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_sr
         pDCB->TagMask |= 1 << tag[1];
         pSRB->TagNumber = tag[1];
         DC390_write8(ScsiFifo, tag[1]);
-        DEBUG1(printk(KERN_INFO "DC390: Select w/DisCn for Cmd %li (SRB %p), block tag %02x\n", scmd->serial_number, pSRB, tag[1]));
+        DEBUG1(printk(KERN_INFO "DC390: Select w/DisCn for SRB %p, block tag %02x\n", pSRB, tag[1]));
         cmd = SEL_W_ATN3;
     } else {
         /* No TagQ */
 //no_tag:
-        DEBUG1(printk(KERN_INFO "DC390: Select w%s/DisCn for Cmd %li (SRB %p), No TagQ\n", disc_allowed ? "" : "o", scmd->serial_number, pSRB));
+        DEBUG1(printk(KERN_INFO "DC390: Select w%s/DisCn for SRB %p, No TagQ\n", disc_allowed ? "" : "o", pSRB));
     }
 
     pSRB->SRBState = SRB_START_;
@@ -620,8 +620,8 @@ dc390_StartSCSI( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_sr
     if (DC390_read8 (Scsi_Status) & INTERRUPT)
     {
         dc390_freetag (pDCB, pSRB);
-        DEBUG0(printk ("DC390: Interrupt during Start SCSI (pid %li, target %02i-%02i)\n",
-                scmd->serial_number, scmd->device->id, scmd->device->lun));
+        DEBUG0(printk ("DC390: Interrupt during Start SCSI (target %02i-%02i)\n",
+                scmd->device->id, scmd->device->lun));
         pSRB->SRBState = SRB_READY;
         //DC390_write8 (ScsiCmd, CLEAR_FIFO_CMD);
         pACB->SelLost++;
@@ -1705,8 +1705,7 @@ dc390_SRBdone( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb*
 
     status = pSRB->TargetStatus;
 
-    DEBUG0(printk (" SRBdone (%02x,%08x), SRB %p, pid %li\n", status, pcmd->result,\
-                pSRB, pcmd->serial_number));
+    DEBUG0(printk (" SRBdone (%02x,%08x), SRB %p\n", status, pcmd->result, pSRB));
     if(pSRB->SRBFlag & AUTO_REQSENSE)
     {   /* Last command was a Request Sense */
         pSRB->SRBFlag &= ~AUTO_REQSENSE;
@@ -1727,7 +1726,7 @@ dc390_SRBdone( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb*
             } else {
                 SET_RES_DRV(pcmd->result, DRIVER_SENSE);
                 //pSRB->ScsiCmdLen       = (u8) (pSRB->Segment1[0] >> 8);
-                DEBUG0 (printk ("DC390: RETRY pid %li (%02x), target %02i-%02i\n", pcmd->serial_number, pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun));
+                DEBUG0 (printk ("DC390: RETRY (%02x), target %02i-%02i\n", pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun));
                 pSRB->TotalXferredLen = 0;
                 SET_RES_DID(pcmd->result, DID_SOFT_ERROR);
             }
@@ -1747,7 +1746,7 @@ dc390_SRBdone( struct dc390_acb* pACB, struct dc390_dcb* pDCB, struct dc390_srb*
         else if (status == SAM_STAT_TASK_SET_FULL)
         {
             scsi_track_queue_full(pcmd->device, pDCB->GoingSRBCnt - 1);
-            DEBUG0 (printk ("DC390: RETRY pid %li (%02x), target %02i-%02i\n", pcmd->serial_number, pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun));
+            DEBUG0 (printk ("DC390: RETRY (%02x), target %02i-%02i\n", pcmd->cmnd[0], pcmd->device->id, pcmd->device->lun));
             pSRB->TotalXferredLen = 0;
             SET_RES_DID(pcmd->result, DID_SOFT_ERROR);
         }
@@ -1801,7 +1800,7 @@ cmd_done:
     /* Add to free list */
     dc390_Free_insert (pACB, pSRB);
 
-    DEBUG0(printk (KERN_DEBUG "DC390: SRBdone: done pid %li\n", pcmd->serial_number));
+    DEBUG0(printk (KERN_DEBUG "DC390: SRBdone: done\n"));
     pcmd->scsi_done (pcmd);
 
     return;
@@ -1997,8 +1996,7 @@ static int DC390_abort(struct scsi_cmnd *cmd)
         struct dc390_acb *pACB = (struct dc390_acb*) cmd->device->host->hostdata;
         struct dc390_dcb *pDCB = (struct dc390_dcb*) cmd->device->hostdata;
 
-        scmd_printk(KERN_WARNING, cmd,
-                "DC390: Abort command (pid %li)\n", cmd->serial_number);
+        scmd_printk(KERN_WARNING, cmd, "DC390: Abort command\n");
 
         /* abort() is too stupid for already sent commands at the moment. 
          * If it's called we are in trouble anyway, so let's dump some info 
@@ -2006,7 +2004,7 @@ static int DC390_abort(struct scsi_cmnd *cmd)
         dc390_dumpinfo(pACB, pDCB, NULL);
 
         pDCB->DCBFlag |= ABORT_DEV_;
-        printk(KERN_INFO "DC390: Aborted pid %li\n", cmd->serial_number);
+        printk(KERN_INFO "DC390: Aborted.\n");
 
         return FAILED;
 }
diff --git a/drivers/scsi/u14-34f.c b/drivers/scsi/u14-34f.c
index edfc5da8be4c..90e104d6b558 100644
--- a/drivers/scsi/u14-34f.c
+++ b/drivers/scsi/u14-34f.c
@@ -1256,8 +1256,8 @@ static int u14_34f_queuecommand_lck(struct scsi_cmnd *SCpnt, void (*done)(struct
    j = ((struct hostdata *) SCpnt->device->host->hostdata)->board_number;
 
    if (SCpnt->host_scribble)
-      panic("%s: qcomm, pid %ld, SCpnt %p already active.\n",
-            BN(j), SCpnt->serial_number, SCpnt);
+      panic("%s: qcomm, SCpnt %p already active.\n",
+            BN(j), SCpnt);
 
    /* i is the mailbox number, look for the first free mailbox
       starting from last_cp_used */
@@ -1286,9 +1286,9 @@ static int u14_34f_queuecommand_lck(struct scsi_cmnd *SCpnt, void (*done)(struct
    cpp->cpp_index = i;
    SCpnt->host_scribble = (unsigned char *) &cpp->cpp_index;
 
-   if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d, pid %ld.\n",
+   if (do_trace) printk("%s: qcomm, mbox %d, target %d.%d:%d.\n",
                         BN(j), i, SCpnt->device->channel, SCpnt->device->id,
-                        SCpnt->device->lun, SCpnt->serial_number);
+                        SCpnt->device->lun);
 
    cpp->opcode = OP_SCSI;
    cpp->channel = SCpnt->device->channel;
@@ -1315,7 +1315,7 @@ static int u14_34f_queuecommand_lck(struct scsi_cmnd *SCpnt, void (*done)(struct
       unmap_dma(i, j);
       SCpnt->host_scribble = NULL;
       scmd_printk(KERN_INFO, SCpnt,
-                "qcomm, pid %ld, adapter busy.\n", SCpnt->serial_number);
+                "qcomm, adapter busy.\n");
       return 1;
       }
 
@@ -1337,14 +1337,12 @@ static int u14_34f_eh_abort(struct scsi_cmnd *SCarg) {
    j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
 
    if (SCarg->host_scribble == NULL) {
-      scmd_printk(KERN_INFO, SCarg, "abort, pid %ld inactive.\n",
-             SCarg->serial_number);
+      scmd_printk(KERN_INFO, SCarg, "abort, command inactive.\n");
       return SUCCESS;
       }
 
    i = *(unsigned int *)SCarg->host_scribble;
-   scmd_printk(KERN_INFO, SCarg, "abort, mbox %d, pid %ld.\n",
-               i, SCarg->serial_number);
+   scmd_printk(KERN_INFO, SCarg, "abort, mbox %d.\n", i);
 
    if (i >= sh[j]->can_queue)
       panic("%s: abort, invalid SCarg->host_scribble.\n", BN(j));
@@ -1387,8 +1385,7 @@ static int u14_34f_eh_abort(struct scsi_cmnd *SCarg) {
       SCarg->result = DID_ABORT << 16;
       SCarg->host_scribble = NULL;
       HD(j)->cp_stat[i] = FREE;
-      printk("%s, abort, mbox %d ready, DID_ABORT, pid %ld done.\n",
-             BN(j), i, SCarg->serial_number);
+      printk("%s, abort, mbox %d ready, DID_ABORT, done.\n", BN(j), i);
       SCarg->scsi_done(SCarg);
       return SUCCESS;
       }
@@ -1403,12 +1400,12 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
    struct scsi_cmnd *SCpnt;
 
    j = ((struct hostdata *) SCarg->device->host->hostdata)->board_number;
-   scmd_printk(KERN_INFO, SCarg, "reset, enter, pid %ld.\n", SCarg->serial_number);
+   scmd_printk(KERN_INFO, SCarg, "reset, enter.\n");
 
    spin_lock_irq(sh[j]->host_lock);
 
    if (SCarg->host_scribble == NULL)
-      printk("%s: reset, pid %ld inactive.\n", BN(j), SCarg->serial_number);
+      printk("%s: reset, inactive.\n", BN(j));
 
    if (HD(j)->in_reset) {
       printk("%s: reset, exit, already in reset.\n", BN(j));
@@ -1445,14 +1442,12 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
 
       if (HD(j)->cp_stat[i] == READY || HD(j)->cp_stat[i] == ABORTING) {
          HD(j)->cp_stat[i] = ABORTING;
-         printk("%s: reset, mbox %d aborting, pid %ld.\n",
-                BN(j), i, SCpnt->serial_number);
+         printk("%s: reset, mbox %d aborting.\n", BN(j), i);
          }
 
       else {
          HD(j)->cp_stat[i] = IN_RESET;
-         printk("%s: reset, mbox %d in reset, pid %ld.\n",
-                BN(j), i, SCpnt->serial_number);
+         printk("%s: reset, mbox %d in reset.\n", BN(j), i);
          }
 
       if (SCpnt->host_scribble == NULL)
@@ -1500,8 +1495,7 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
          /* This mailbox is still waiting for its interrupt */
          HD(j)->cp_stat[i] = LOCKED;
 
-         printk("%s, reset, mbox %d locked, DID_RESET, pid %ld done.\n",
-                BN(j), i, SCpnt->serial_number);
+         printk("%s, reset, mbox %d locked, DID_RESET, done.\n", BN(j), i);
          }
 
       else if (HD(j)->cp_stat[i] == ABORTING) {
@@ -1513,8 +1507,7 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
          /* This mailbox was never queued to the adapter */
          HD(j)->cp_stat[i] = FREE;
 
-         printk("%s, reset, mbox %d aborting, DID_RESET, pid %ld done.\n",
-                BN(j), i, SCpnt->serial_number);
+         printk("%s, reset, mbox %d aborting, DID_RESET, done.\n", BN(j), i);
          }
 
       else
@@ -1528,7 +1521,7 @@ static int u14_34f_eh_host_reset(struct scsi_cmnd *SCarg) {
    HD(j)->in_reset = FALSE;
    do_trace = FALSE;
 
-   if (arg_done) printk("%s: reset, exit, pid %ld done.\n", BN(j), SCarg->serial_number);
+   if (arg_done) printk("%s: reset, exit, done.\n", BN(j));
    else          printk("%s: reset, exit.\n", BN(j));
 
    spin_unlock_irq(sh[j]->host_lock);
@@ -1671,10 +1664,10 @@ static int reorder(unsigned int j, unsigned long cursec,
    if (link_statistics && (overlap || !(flushcount % link_statistics)))
       for (n = 0; n < n_ready; n++) {
          k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
-         printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %u"\
+         printk("%s %d.%d:%d mb %d fc %d nr %d sec %ld ns %u"\
                 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
                 (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target,
-                SCpnt->lun, SCpnt->serial_number, k, flushcount, n_ready,
+                SCpnt->lun, k, flushcount, n_ready,
                 blk_rq_pos(SCpnt->request), blk_rq_sectors(SCpnt->request),
                 cursec, YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
                 YESNO(overlap), cpp->xdir);
@@ -1709,9 +1702,9 @@ static void flush_dev(struct scsi_device *dev, unsigned long cursec, unsigned in
 
       if (wait_on_busy(sh[j]->io_port, MAXLOOP)) {
          scmd_printk(KERN_INFO, SCpnt,
-                "%s, pid %ld, mbox %d, adapter"
+                "%s, mbox %d, adapter"
                 " busy, will abort.\n", (ihdlr ? "ihdlr" : "qcomm"),
-                SCpnt->serial_number, k);
+                k);
          HD(j)->cp_stat[k] = ABORTING;
          continue;
          }
@@ -1793,12 +1786,12 @@ static irqreturn_t ihdlr(unsigned int j)
    if (SCpnt == NULL) panic("%s: ihdlr, mbox %d, SCpnt == NULL.\n", BN(j), i);
 
    if (SCpnt->host_scribble == NULL)
-      panic("%s: ihdlr, mbox %d, pid %ld, SCpnt %p garbled.\n", BN(j), i,
-            SCpnt->serial_number, SCpnt);
+      panic("%s: ihdlr, mbox %d, SCpnt %p garbled.\n", BN(j), i,
+            SCpnt);
 
    if (*(unsigned int *)SCpnt->host_scribble != i)
-      panic("%s: ihdlr, mbox %d, pid %ld, index mismatch %d.\n",
-            BN(j), i, SCpnt->serial_number, *(unsigned int *)SCpnt->host_scribble);
+      panic("%s: ihdlr, mbox %d, index mismatch %d.\n",
+            BN(j), i, *(unsigned int *)SCpnt->host_scribble);
 
    sync_dma(i, j);
 
@@ -1841,8 +1834,8 @@ static irqreturn_t ihdlr(unsigned int j)
              (!(tstatus == CHECK_CONDITION && HD(j)->iocount <= 1000 &&
                (SCpnt->sense_buffer[2] & 0xf) == NOT_READY)))
             scmd_printk(KERN_INFO, SCpnt,
-                "ihdlr, pid %ld, target_status 0x%x, sense key 0x%x.\n",
-                   SCpnt->serial_number, spp->target_status,
+                "ihdlr, target_status 0x%x, sense key 0x%x.\n",
+                   spp->target_status,
                    SCpnt->sense_buffer[2]);
 
          HD(j)->target_to[scmd_id(SCpnt)][scmd_channel(SCpnt)] = 0;
@@ -1913,8 +1906,8 @@ static irqreturn_t ihdlr(unsigned int j)
         do_trace || msg_byte(spp->target_status))
 #endif
       scmd_printk(KERN_INFO, SCpnt, "ihdlr, mbox %2d, err 0x%x:%x,"\
-             " pid %ld, reg 0x%x, count %d.\n",
-             i, spp->adapter_status, spp->target_status, SCpnt->serial_number,
+             " reg 0x%x, count %d.\n",
+             i, spp->adapter_status, spp->target_status,
              reg, HD(j)->iocount);
 
    unmap_dma(i, j);
diff --git a/drivers/scsi/wd33c93.c b/drivers/scsi/wd33c93.c
index 4468ae3610f7..97ae716134d0 100644
--- a/drivers/scsi/wd33c93.c
+++ b/drivers/scsi/wd33c93.c
@@ -381,7 +381,7 @@ wd33c93_queuecommand_lck(struct scsi_cmnd *cmd,
         hostdata = (struct WD33C93_hostdata *) cmd->device->host->hostdata;
 
         DB(DB_QUEUE_COMMAND,
-           printk("Q-%d-%02x-%ld( ", cmd->device->id, cmd->cmnd[0], cmd->serial_number))
+           printk("Q-%d-%02x( ", cmd->device->id, cmd->cmnd[0]))
 
 /* Set up a few fields in the scsi_cmnd structure for our own use:
  *  - host_scribble is the pointer to the next cmd in the input queue
@@ -462,7 +462,7 @@ wd33c93_queuecommand_lck(struct scsi_cmnd *cmd,
 
         wd33c93_execute(cmd->device->host);
 
-        DB(DB_QUEUE_COMMAND, printk(")Q-%ld ", cmd->serial_number))
+        DB(DB_QUEUE_COMMAND, printk(")Q "))
 
         spin_unlock_irq(&hostdata->lock);
         return 0;
@@ -687,7 +687,7 @@ wd33c93_execute(struct Scsi_Host *instance)
          */
 
         DB(DB_EXECUTE,
-           printk("%s%ld)EX-2 ", (cmd->SCp.phase) ? "d:" : "", cmd->serial_number))
+           printk("%s)EX-2 ", (cmd->SCp.phase) ? "d:" : ""))
 }
 
 static void
@@ -963,7 +963,7 @@ wd33c93_intr(struct Scsi_Host *instance)
         case CSR_XFER_DONE | PHS_COMMAND:
         case CSR_UNEXP | PHS_COMMAND:
         case CSR_SRV_REQ | PHS_COMMAND:
-                DB(DB_INTR, printk("CMND-%02x,%ld", cmd->cmnd[0], cmd->serial_number))
+                DB(DB_INTR, printk("CMND-%02x", cmd->cmnd[0]))
                     transfer_pio(regs, cmd->cmnd, cmd->cmd_len, DATA_OUT_DIR,
                                  hostdata);
                 hostdata->state = S_CONNECTED;
@@ -1007,7 +1007,7 @@ wd33c93_intr(struct Scsi_Host *instance)
                 switch (msg) {
 
                 case COMMAND_COMPLETE:
-                        DB(DB_INTR, printk("CCMP-%ld", cmd->serial_number))
+                        DB(DB_INTR, printk("CCMP"))
                             write_wd33c93_cmd(regs, WD_CMD_NEGATE_ACK);
                         hostdata->state = S_PRE_CMP_DISC;
                         break;
@@ -1174,7 +1174,7 @@ wd33c93_intr(struct Scsi_Host *instance)
 
                 write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER);
                 if (phs == 0x60) {
-                        DB(DB_INTR, printk("SX-DONE-%ld", cmd->serial_number))
+                        DB(DB_INTR, printk("SX-DONE"))
                             cmd->SCp.Message = COMMAND_COMPLETE;
                         lun = read_wd33c93(regs, WD_TARGET_LUN);
                         DB(DB_INTR, printk(":%d.%d", cmd->SCp.Status, lun))
@@ -1200,8 +1200,8 @@ wd33c93_intr(struct Scsi_Host *instance)
                         wd33c93_execute(instance);
                 } else {
                         printk
-                            ("%02x:%02x:%02x-%ld: Unknown SEL_XFER_DONE phase!!---",
-                             asr, sr, phs, cmd->serial_number);
+                            ("%02x:%02x:%02x: Unknown SEL_XFER_DONE phase!!---",
+                             asr, sr, phs);
                         spin_unlock_irqrestore(&hostdata->lock, flags);
                 }
                 break;
@@ -1266,7 +1266,7 @@ wd33c93_intr(struct Scsi_Host *instance)
                         spin_unlock_irqrestore(&hostdata->lock, flags);
                         return;
                 }
-                DB(DB_INTR, printk("UNEXP_DISC-%ld", cmd->serial_number))
+                DB(DB_INTR, printk("UNEXP_DISC"))
                     hostdata->connected = NULL;
                 hostdata->busy[cmd->device->id] &= ~(1 << cmd->device->lun);
                 hostdata->state = S_UNCONNECTED;
@@ -1292,7 +1292,7 @@ wd33c93_intr(struct Scsi_Host *instance)
  */
 
                 write_wd33c93(regs, WD_SOURCE_ID, SRCID_ER);
-                DB(DB_INTR, printk("DISC-%ld", cmd->serial_number))
+                DB(DB_INTR, printk("DISC"))
                     if (cmd == NULL) {
                         printk(" - Already disconnected! ");
                         hostdata->state = S_UNCONNECTED;
@@ -1491,7 +1491,6 @@ wd33c93_intr(struct Scsi_Host *instance)
                 } else
                         hostdata->state = S_CONNECTED;
 
-                DB(DB_INTR, printk("-%ld", cmd->serial_number))
                     spin_unlock_irqrestore(&hostdata->lock, flags);
                 break;
 
@@ -1637,8 +1636,8 @@ wd33c93_abort(struct scsi_cmnd * cmd)
                         cmd->host_scribble = NULL;
                         cmd->result = DID_ABORT << 16;
                         printk
-                            ("scsi%d: Abort - removing command %ld from input_Q. ",
-                             instance->host_no, cmd->serial_number);
+                            ("scsi%d: Abort - removing command from input_Q. ",
+                             instance->host_no);
                         enable_irq(cmd->device->host->irq);
                         cmd->scsi_done(cmd);
                         return SUCCESS;
@@ -1662,8 +1661,8 @@ wd33c93_abort(struct scsi_cmnd * cmd)
                 uchar sr, asr;
                 unsigned long timeout;
 
-                printk("scsi%d: Aborting connected command %ld - ",
-                       instance->host_no, cmd->serial_number);
+                printk("scsi%d: Aborting connected command - ",
+                       instance->host_no);
 
                 printk("stopping DMA - ");
                 if (hostdata->dma == D_DMA_RUNNING) {
@@ -1729,8 +1728,8 @@ wd33c93_abort(struct scsi_cmnd * cmd)
         while (tmp) {
                 if (tmp == cmd) {
                         printk
-                            ("scsi%d: Abort - command %ld found on disconnected_Q - ",
-                             instance->host_no, cmd->serial_number);
+                            ("scsi%d: Abort - command found on disconnected_Q - ",
+                             instance->host_no);
                         printk("Abort SNOOZE. ");
                         enable_irq(cmd->device->host->irq);
                         return FAILED;
@@ -2180,8 +2179,8 @@ wd33c93_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off
                 strcat(bp, "\nconnected:     ");
                 if (hd->connected) {
                         cmd = (struct scsi_cmnd *) hd->connected;
-                        sprintf(tbuf, " %ld-%d:%d(%02x)",
-                                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+                        sprintf(tbuf, " %d:%d(%02x)",
+                                cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
                         strcat(bp, tbuf);
                 }
         }
@@ -2189,8 +2188,8 @@ wd33c93_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off
                 strcat(bp, "\ninput_Q:       ");
                 cmd = (struct scsi_cmnd *) hd->input_Q;
                 while (cmd) {
-                        sprintf(tbuf, " %ld-%d:%d(%02x)",
-                                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+                        sprintf(tbuf, " %d:%d(%02x)",
+                                cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
                         strcat(bp, tbuf);
                         cmd = (struct scsi_cmnd *) cmd->host_scribble;
                 }
@@ -2199,8 +2198,8 @@ wd33c93_proc_info(struct Scsi_Host *instance, char *buf, char **start, off_t off
                 strcat(bp, "\ndisconnected_Q:");
                 cmd = (struct scsi_cmnd *) hd->disconnected_Q;
                 while (cmd) {
-                        sprintf(tbuf, " %ld-%d:%d(%02x)",
-                                cmd->serial_number, cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
+                        sprintf(tbuf, " %d:%d(%02x)",
+                                cmd->device->id, cmd->device->lun, cmd->cmnd[0]);
                         strcat(bp, tbuf);
                         cmd = (struct scsi_cmnd *) cmd->host_scribble;
                 }
diff --git a/drivers/target/Kconfig b/drivers/target/Kconfig
index 9ef2dbbfa62b..5cb0f0ef6af0 100644
--- a/drivers/target/Kconfig
+++ b/drivers/target/Kconfig
@@ -30,5 +30,6 @@ config TCM_PSCSI
         passthrough access to Linux/SCSI device
 
 source "drivers/target/loopback/Kconfig"
+source "drivers/target/tcm_fc/Kconfig"
 
 endif
diff --git a/drivers/target/Makefile b/drivers/target/Makefile
index 1178bbfc68fe..21df808a992c 100644
--- a/drivers/target/Makefile
+++ b/drivers/target/Makefile
@@ -24,3 +24,5 @@ obj-$(CONFIG_TCM_PSCSI)		+= target_core_pscsi.o
 
 # Fabric modules
 obj-$(CONFIG_LOOPBACK_TARGET)   += loopback/
+
+obj-$(CONFIG_TCM_FC)            += tcm_fc/
diff --git a/drivers/target/tcm_fc/Kconfig b/drivers/target/tcm_fc/Kconfig
new file mode 100644
index 000000000000..40caf458e89e
--- /dev/null
+++ b/drivers/target/tcm_fc/Kconfig
@@ -0,0 +1,5 @@
+config TCM_FC
+        tristate "TCM_FC fabric Plugin"
+        depends on LIBFC
+        help
+        Say Y here to enable the TCM FC plugin for accessing FC fabrics in TCM
diff --git a/drivers/target/tcm_fc/Makefile b/drivers/target/tcm_fc/Makefile
new file mode 100644
index 000000000000..7a5c2b64cf65
--- /dev/null
+++ b/drivers/target/tcm_fc/Makefile
@@ -0,0 +1,15 @@
+EXTRA_CFLAGS += -I$(srctree)/drivers/target/ \
+                -I$(srctree)/drivers/scsi/ \
+                -I$(srctree)/include/scsi/ \
+                -I$(srctree)/drivers/target/tcm_fc/
+
+tcm_fc-y +=     tfc_cmd.o \
+                tfc_conf.o \
+                tfc_io.o \
+                tfc_sess.o
+
+obj-$(CONFIG_TCM_FC)    += tcm_fc.o
+
+ifdef CONFIGFS_TCM_FC_DEBUG
+EXTRA_CFLAGS    += -DTCM_FC_DEBUG
+endif
diff --git a/drivers/target/tcm_fc/tcm_fc.h b/drivers/target/tcm_fc/tcm_fc.h
new file mode 100644
index 000000000000..defff32b7880
--- /dev/null
+++ b/drivers/target/tcm_fc/tcm_fc.h
@@ -0,0 +1,215 @@
+/*
+ * Copyright (c) 2010 Cisco Systems, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#ifndef __TCM_FC_H__
+#define __TCM_FC_H__
+
+#define FT_VERSION "0.3"
+
+#define FT_NAMELEN 32           /* length of ASCII WWPNs including pad */
+#define FT_TPG_NAMELEN 32       /* max length of TPG name */
+#define FT_LUN_NAMELEN 32       /* max length of LUN name */
+
+/*
+ * Debug options.
+ */
+#define FT_DEBUG_CONF   0x01    /* configuration messages */
+#define FT_DEBUG_SESS   0x02    /* session messages */
+#define FT_DEBUG_TM     0x04    /* TM operations */
+#define FT_DEBUG_IO     0x08    /* I/O commands */
+#define FT_DEBUG_DATA   0x10    /* Data transfer */
+
+extern unsigned int ft_debug_logging;   /* debug options */
+
+#define FT_DEBUG(mask, fmt, args...)                                    \
+        do {                                                            \
+                if (ft_debug_logging & (mask))                          \
+                        printk(KERN_INFO "tcm_fc: %s: " fmt,            \
+                                __func__, ##args);                      \
+        } while (0)
+
+#define FT_CONF_DBG(fmt, args...)       FT_DEBUG(FT_DEBUG_CONF, fmt, ##args)
+#define FT_SESS_DBG(fmt, args...)       FT_DEBUG(FT_DEBUG_SESS, fmt, ##args)
+#define FT_TM_DBG(fmt, args...)         FT_DEBUG(FT_DEBUG_TM, fmt, ##args)
+#define FT_IO_DBG(fmt, args...)         FT_DEBUG(FT_DEBUG_IO, fmt, ##args)
+#define FT_DATA_DBG(fmt, args...)       FT_DEBUG(FT_DEBUG_DATA, fmt, ##args)
+
+struct ft_transport_id {
+        __u8    format;
+        __u8    __resvd1[7];
+        __u8    wwpn[8];
+        __u8    __resvd2[8];
+} __attribute__((__packed__));
+
+/*
+ * Session (remote port).
+ */
+struct ft_sess {
+        u32 port_id;                    /* for hash lookup use only */
+        u32 params;
+        u16 max_frame;                  /* maximum frame size */
+        u64 port_name;                  /* port name for transport ID */
+        struct ft_tport *tport;
+        struct se_session *se_sess;
+        struct hlist_node hash;         /* linkage in ft_sess_hash table */
+        struct rcu_head rcu;
+        struct kref kref;               /* ref for hash and outstanding I/Os */
+};
+
+/*
+ * Hash table of sessions per local port.
+ * Hash lookup by remote port FC_ID.
+ */
+#define FT_SESS_HASH_BITS       6
+#define FT_SESS_HASH_SIZE       (1 << FT_SESS_HASH_BITS)
+
+/*
+ * Per local port data.
+ * This is created only after a TPG exists that allows target function
+ * for the local port.  If the TPG exists, this is allocated when
+ * we're notified that the local port has been created, or when
+ * the first PRLI provider callback is received.
+ */
+struct ft_tport {
+        struct fc_lport *lport;
+        struct ft_tpg *tpg;             /* NULL if TPG deleted before tport */
+        u32     sess_count;             /* number of sessions in hash */
+        struct rcu_head rcu;
+        struct hlist_head hash[FT_SESS_HASH_SIZE];      /* list of sessions */
+};
+
+/*
+ * Node ID and authentication.
+ */
+struct ft_node_auth {
+        u64     port_name;
+        u64     node_name;
+};
+
+/*
+ * Node ACL for FC remote port session.
+ */
+struct ft_node_acl {
+        struct ft_node_auth node_auth;
+        struct se_node_acl se_node_acl;
+};
+
+struct ft_lun {
+        u32 index;
+        char name[FT_LUN_NAMELEN];
+};
+
+/*
+ * Target portal group (local port).
+ */
+struct ft_tpg {
+        u32 index;
+        struct ft_lport_acl *lport_acl;
+        struct ft_tport *tport;         /* active tport or NULL */
+        struct list_head list;          /* linkage in ft_lport_acl tpg_list */
+        struct list_head lun_list;      /* head of LUNs */
+        struct se_portal_group se_tpg;
+        struct task_struct *thread;     /* processing thread */
+        struct se_queue_obj qobj;       /* queue for processing thread */
+};
+
+struct ft_lport_acl {
+        u64 wwpn;
+        char name[FT_NAMELEN];
+        struct list_head list;
+        struct list_head tpg_list;
+        struct se_wwn fc_lport_wwn;
+};
+
+enum ft_cmd_state {
+        FC_CMD_ST_NEW = 0,
+        FC_CMD_ST_REJ
+};
+
+/*
+ * Commands
+ */
+struct ft_cmd {
+        enum ft_cmd_state state;
+        u16 lun;                        /* LUN from request */
+        struct ft_sess *sess;           /* session held for cmd */
+        struct fc_seq *seq;             /* sequence in exchange mgr */
+        struct se_cmd se_cmd;           /* Local TCM I/O descriptor */
+        struct fc_frame *req_frame;
+        unsigned char *cdb;             /* pointer to CDB inside frame */
+        u32 write_data_len;             /* data received on writes */
+        struct se_queue_req se_req;
+        /* Local sense buffer */
+        unsigned char ft_sense_buffer[TRANSPORT_SENSE_BUFFER];
+        u32 was_ddp_setup:1;            /* Set only if ddp is setup */
+        struct scatterlist *sg;         /* Set only if DDP is setup */
+        u32 sg_cnt;                     /* No. of item in scatterlist */
+};
+
+extern struct list_head ft_lport_list;
+extern struct mutex ft_lport_lock;
+extern struct fc4_prov ft_prov;
+extern struct target_fabric_configfs *ft_configfs;
+
+/*
+ * Fabric methods.
+ */
+
+/*
+ * Session ops.
+ */
+void ft_sess_put(struct ft_sess *);
+int ft_sess_shutdown(struct se_session *);
+void ft_sess_close(struct se_session *);
+void ft_sess_stop(struct se_session *, int, int);
+int ft_sess_logged_in(struct se_session *);
+u32 ft_sess_get_index(struct se_session *);
+u32 ft_sess_get_port_name(struct se_session *, unsigned char *, u32);
+void ft_sess_set_erl0(struct se_session *);
+
+void ft_lport_add(struct fc_lport *, void *);
+void ft_lport_del(struct fc_lport *, void *);
+int ft_lport_notify(struct notifier_block *, unsigned long, void *);
+
+/*
+ * IO methods.
+ */
+void ft_check_stop_free(struct se_cmd *);
+void ft_release_cmd(struct se_cmd *);
+int ft_queue_status(struct se_cmd *);
+int ft_queue_data_in(struct se_cmd *);
+int ft_write_pending(struct se_cmd *);
+int ft_write_pending_status(struct se_cmd *);
+u32 ft_get_task_tag(struct se_cmd *);
+int ft_get_cmd_state(struct se_cmd *);
+void ft_new_cmd_failure(struct se_cmd *);
+int ft_queue_tm_resp(struct se_cmd *);
+int ft_is_state_remove(struct se_cmd *);
+
+/*
+ * other internal functions.
+ */
+int ft_thread(void *);
+void ft_recv_req(struct ft_sess *, struct fc_frame *);
+struct ft_tpg *ft_lport_find_tpg(struct fc_lport *);
+struct ft_node_acl *ft_acl_get(struct ft_tpg *, struct fc_rport_priv *);
+
+void ft_recv_write_data(struct ft_cmd *, struct fc_frame *);
+void ft_dump_cmd(struct ft_cmd *, const char *caller);
+
+ssize_t ft_format_wwn(char *, size_t, u64);
+
+#endif /* __TCM_FC_H__ */
diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
new file mode 100644
index 000000000000..49e51778f733
--- /dev/null
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -0,0 +1,696 @@
+/*
+ * Copyright (c) 2010 Cisco Systems, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/* XXX TBD some includes may be extraneous */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/version.h>
+#include <generated/utsrelease.h>
+#include <linux/utsname.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/kthread.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/configfs.h>
+#include <linux/ctype.h>
+#include <linux/hash.h>
+#include <asm/unaligned.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/libfc.h>
+#include <scsi/fc_encode.h>
+
+#include <target/target_core_base.h>
+#include <target/target_core_transport.h>
+#include <target/target_core_fabric_ops.h>
+#include <target/target_core_device.h>
+#include <target/target_core_tpg.h>
+#include <target/target_core_configfs.h>
+#include <target/target_core_base.h>
+#include <target/target_core_tmr.h>
+#include <target/configfs_macros.h>
+
+#include "tcm_fc.h"
+
+/*
+ * Dump cmd state for debugging.
+ */
+void ft_dump_cmd(struct ft_cmd *cmd, const char *caller)
+{
+        struct fc_exch *ep;
+        struct fc_seq *sp;
+        struct se_cmd *se_cmd;
+        struct se_mem *mem;
+        struct se_transport_task *task;
+
+        if (!(ft_debug_logging & FT_DEBUG_IO))
+                return;
+
+        se_cmd = &cmd->se_cmd;
+        printk(KERN_INFO "%s: cmd %p state %d sess %p seq %p se_cmd %p\n",
+                caller, cmd, cmd->state, cmd->sess, cmd->seq, se_cmd);
+        printk(KERN_INFO "%s: cmd %p cdb %p\n",
+                caller, cmd, cmd->cdb);
+        printk(KERN_INFO "%s: cmd %p lun %d\n", caller, cmd, cmd->lun);
+
+        task = T_TASK(se_cmd);
+        printk(KERN_INFO "%s: cmd %p task %p se_num %u buf %p len %u se_cmd_flags <0x%x>\n",
+               caller, cmd, task, task->t_tasks_se_num,
+               task->t_task_buf, se_cmd->data_length, se_cmd->se_cmd_flags);
+        if (task->t_mem_list)
+                list_for_each_entry(mem, task->t_mem_list, se_list)
+                        printk(KERN_INFO "%s: cmd %p mem %p page %p "
+                               "len 0x%x off 0x%x\n",
+                               caller, cmd, mem,
+                               mem->se_page, mem->se_len, mem->se_off);
+        sp = cmd->seq;
+        if (sp) {
+                ep = fc_seq_exch(sp);
+                printk(KERN_INFO "%s: cmd %p sid %x did %x "
+                        "ox_id %x rx_id %x seq_id %x e_stat %x\n",
+                        caller, cmd, ep->sid, ep->did, ep->oxid, ep->rxid,
+                        sp->id, ep->esb_stat);
+        }
+        print_hex_dump(KERN_INFO, "ft_dump_cmd ", DUMP_PREFIX_NONE,
+                16, 4, cmd->cdb, MAX_COMMAND_SIZE, 0);
+}
+
+/*
+ * Get LUN from CDB.
+ */
+static int ft_get_lun_for_cmd(struct ft_cmd *cmd, u8 *lunp)
+{
+        u64 lun;
+
+        lun = lunp[1];
+        switch (lunp[0] >> 6) {
+        case 0:
+                break;
+        case 1:
+                lun |= (lunp[0] & 0x3f) << 8;
+                break;
+        default:
+                return -1;
+        }
+        if (lun >= TRANSPORT_MAX_LUNS_PER_TPG)
+                return -1;
+        cmd->lun = lun;
+        return transport_get_lun_for_cmd(&cmd->se_cmd, NULL, lun);
+}
+
+static void ft_queue_cmd(struct ft_sess *sess, struct ft_cmd *cmd)
+{
+        struct se_queue_obj *qobj;
+        unsigned long flags;
+
+        qobj = &sess->tport->tpg->qobj;
+        spin_lock_irqsave(&qobj->cmd_queue_lock, flags);
+        list_add_tail(&cmd->se_req.qr_list, &qobj->qobj_list);
+        spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
+        atomic_inc(&qobj->queue_cnt);
+        wake_up_interruptible(&qobj->thread_wq);
+}
+
+static struct ft_cmd *ft_dequeue_cmd(struct se_queue_obj *qobj)
+{
+        unsigned long flags;
+        struct se_queue_req *qr;
+
+        spin_lock_irqsave(&qobj->cmd_queue_lock, flags);
+        if (list_empty(&qobj->qobj_list)) {
+                spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
+                return NULL;
+        }
+        qr = list_first_entry(&qobj->qobj_list, struct se_queue_req, qr_list);
+        list_del(&qr->qr_list);
+        atomic_dec(&qobj->queue_cnt);
+        spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
+        return container_of(qr, struct ft_cmd, se_req);
+}
+
+static void ft_free_cmd(struct ft_cmd *cmd)
+{
+        struct fc_frame *fp;
+        struct fc_lport *lport;
+
+        if (!cmd)
+                return;
+        fp = cmd->req_frame;
+        lport = fr_dev(fp);
+        if (fr_seq(fp))
+                lport->tt.seq_release(fr_seq(fp));
+        fc_frame_free(fp);
+        ft_sess_put(cmd->sess); /* undo get from lookup at recv */
+        kfree(cmd);
+}
+
+void ft_release_cmd(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+
+        ft_free_cmd(cmd);
+}
+
+void ft_check_stop_free(struct se_cmd *se_cmd)
+{
+        transport_generic_free_cmd(se_cmd, 0, 1, 0);
+}
+
+/*
+ * Send response.
+ */
+int ft_queue_status(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+        struct fc_frame *fp;
+        struct fcp_resp_with_ext *fcp;
+        struct fc_lport *lport;
+        struct fc_exch *ep;
+        size_t len;
+
+        ft_dump_cmd(cmd, __func__);
+        ep = fc_seq_exch(cmd->seq);
+        lport = ep->lp;
+        len = sizeof(*fcp) + se_cmd->scsi_sense_length;
+        fp = fc_frame_alloc(lport, len);
+        if (!fp) {
+                /* XXX shouldn't just drop it - requeue and retry? */
+                return 0;
+        }
+        fcp = fc_frame_payload_get(fp, len);
+        memset(fcp, 0, len);
+        fcp->resp.fr_status = se_cmd->scsi_status;
+
+        len = se_cmd->scsi_sense_length;
+        if (len) {
+                fcp->resp.fr_flags |= FCP_SNS_LEN_VAL;
+                fcp->ext.fr_sns_len = htonl(len);
+                memcpy((fcp + 1), se_cmd->sense_buffer, len);
+        }
+
+        /*
+         * Test underflow and overflow with one mask.  Usually both are off.
+         * Bidirectional commands are not handled yet.
+         */
+        if (se_cmd->se_cmd_flags & (SCF_OVERFLOW_BIT | SCF_UNDERFLOW_BIT)) {
+                if (se_cmd->se_cmd_flags & SCF_OVERFLOW_BIT)
+                        fcp->resp.fr_flags |= FCP_RESID_OVER;
+                else
+                        fcp->resp.fr_flags |= FCP_RESID_UNDER;
+                fcp->ext.fr_resid = cpu_to_be32(se_cmd->residual_count);
+        }
+
+        /*
+         * Send response.
+         */
+        cmd->seq = lport->tt.seq_start_next(cmd->seq);
+        fc_fill_fc_hdr(fp, FC_RCTL_DD_CMD_STATUS, ep->did, ep->sid, FC_TYPE_FCP,
+                       FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ, 0);
+
+        lport->tt.seq_send(lport, cmd->seq, fp);
+        lport->tt.exch_done(cmd->seq);
+        return 0;
+}
+
+int ft_write_pending_status(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+
+        return cmd->write_data_len != se_cmd->data_length;
+}
+
+/*
+ * Send TX_RDY (transfer ready).
+ */
+int ft_write_pending(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+        struct fc_frame *fp;
+        struct fcp_txrdy *txrdy;
+        struct fc_lport *lport;
+        struct fc_exch *ep;
+        struct fc_frame_header *fh;
+        u32 f_ctl;
+
+        ft_dump_cmd(cmd, __func__);
+
+        ep = fc_seq_exch(cmd->seq);
+        lport = ep->lp;
+        fp = fc_frame_alloc(lport, sizeof(*txrdy));
+        if (!fp)
+                return PYX_TRANSPORT_OUT_OF_MEMORY_RESOURCES;
+
+        txrdy = fc_frame_payload_get(fp, sizeof(*txrdy));
+        memset(txrdy, 0, sizeof(*txrdy));
+        txrdy->ft_burst_len = htonl(se_cmd->data_length);
+
+        cmd->seq = lport->tt.seq_start_next(cmd->seq);
+        fc_fill_fc_hdr(fp, FC_RCTL_DD_DATA_DESC, ep->did, ep->sid, FC_TYPE_FCP,
+                       FC_FC_EX_CTX | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0);
+
+        fh = fc_frame_header_get(fp);
+        f_ctl = ntoh24(fh->fh_f_ctl);
+
+        /* Only if it is 'Exchange Responder' */
+        if (f_ctl & FC_FC_EX_CTX) {
+                /* Target is 'exchange responder' and sending XFER_READY
+                 * to 'exchange initiator (initiator)'
+                 */
+                if ((ep->xid <= lport->lro_xid) &&
+                    (fh->fh_r_ctl == FC_RCTL_DD_DATA_DESC)) {
+                        if (se_cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) {
+                                /*
+                                 * Map se_mem list to scatterlist, so that
+                                 * DDP can be setup. DDP setup function require
+                                 * scatterlist. se_mem_list is internal to
+                                 * TCM/LIO target
+                                 */
+                                transport_do_task_sg_chain(se_cmd);
+                                cmd->sg = T_TASK(se_cmd)->t_tasks_sg_chained;
+                                cmd->sg_cnt =
+                                        T_TASK(se_cmd)->t_tasks_sg_chained_no;
+                        }
+                        if (cmd->sg && lport->tt.ddp_setup(lport, ep->xid,
+                                                    cmd->sg, cmd->sg_cnt))
+                                cmd->was_ddp_setup = 1;
+                }
+        }
+        lport->tt.seq_send(lport, cmd->seq, fp);
+        return 0;
+}
+
+u32 ft_get_task_tag(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+
+        return fc_seq_exch(cmd->seq)->rxid;
+}
+
+int ft_get_cmd_state(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+
+        return cmd->state;
+}
+
+int ft_is_state_remove(struct se_cmd *se_cmd)
+{
+        return 0;       /* XXX TBD */
+}
+
+void ft_new_cmd_failure(struct se_cmd *se_cmd)
+{
+        /* XXX TBD */
+        printk(KERN_INFO "%s: se_cmd %p\n", __func__, se_cmd);
+}
+
+/*
+ * FC sequence response handler for follow-on sequences (data) and aborts.
+ */
+static void ft_recv_seq(struct fc_seq *sp, struct fc_frame *fp, void *arg)
+{
+        struct ft_cmd *cmd = arg;
+        struct fc_frame_header *fh;
+
+        if (IS_ERR(fp)) {
+                /* XXX need to find cmd if queued */
+                cmd->se_cmd.t_state = TRANSPORT_REMOVE;
+                cmd->seq = NULL;
+                transport_generic_free_cmd(&cmd->se_cmd, 0, 1, 0);
+                return;
+        }
+
+        fh = fc_frame_header_get(fp);
+
+        switch (fh->fh_r_ctl) {
+        case FC_RCTL_DD_SOL_DATA:       /* write data */
+                ft_recv_write_data(cmd, fp);
+                break;
+        case FC_RCTL_DD_UNSOL_CTL:      /* command */
+        case FC_RCTL_DD_SOL_CTL:        /* transfer ready */
+        case FC_RCTL_DD_DATA_DESC:      /* transfer ready */
+        default:
+                printk(KERN_INFO "%s: unhandled frame r_ctl %x\n",
+                       __func__, fh->fh_r_ctl);
+                fc_frame_free(fp);
+                transport_generic_free_cmd(&cmd->se_cmd, 0, 1, 0);
+                break;
+        }
+}
+
+/*
+ * Send a FCP response including SCSI status and optional FCP rsp_code.
+ * status is SAM_STAT_GOOD (zero) iff code is valid.
+ * This is used in error cases, such as allocation failures.
+ */
+static void ft_send_resp_status(struct fc_lport *lport,
+                                const struct fc_frame *rx_fp,
+                                u32 status, enum fcp_resp_rsp_codes code)
+{
+        struct fc_frame *fp;
+        struct fc_seq *sp;
+        const struct fc_frame_header *fh;
+        size_t len;
+        struct fcp_resp_with_ext *fcp;
+        struct fcp_resp_rsp_info *info;
+
+        fh = fc_frame_header_get(rx_fp);
+        FT_IO_DBG("FCP error response: did %x oxid %x status %x code %x\n",
+                  ntoh24(fh->fh_s_id), ntohs(fh->fh_ox_id), status, code);
+        len = sizeof(*fcp);
+        if (status == SAM_STAT_GOOD)
+                len += sizeof(*info);
+        fp = fc_frame_alloc(lport, len);
+        if (!fp)
+                return;
+        fcp = fc_frame_payload_get(fp, len);
+        memset(fcp, 0, len);
+        fcp->resp.fr_status = status;
+        if (status == SAM_STAT_GOOD) {
+                fcp->ext.fr_rsp_len = htonl(sizeof(*info));
+                fcp->resp.fr_flags |= FCP_RSP_LEN_VAL;
+                info = (struct fcp_resp_rsp_info *)(fcp + 1);
+                info->rsp_code = code;
+        }
+
+        fc_fill_reply_hdr(fp, rx_fp, FC_RCTL_DD_CMD_STATUS, 0);
+        sp = fr_seq(fp);
+        if (sp)
+                lport->tt.seq_send(lport, sp, fp);
+        else
+                lport->tt.frame_send(lport, fp);
+}
+
+/*
+ * Send error or task management response.
+ * Always frees the cmd and associated state.
+ */
+static void ft_send_resp_code(struct ft_cmd *cmd, enum fcp_resp_rsp_codes code)
+{
+        ft_send_resp_status(cmd->sess->tport->lport,
+                            cmd->req_frame, SAM_STAT_GOOD, code);
+        ft_free_cmd(cmd);
+}
+
+/*
+ * Handle Task Management Request.
+ */
+static void ft_send_tm(struct ft_cmd *cmd)
+{
+        struct se_tmr_req *tmr;
+        struct fcp_cmnd *fcp;
+        u8 tm_func;
+
+        fcp = fc_frame_payload_get(cmd->req_frame, sizeof(*fcp));
+
+        switch (fcp->fc_tm_flags) {
+        case FCP_TMF_LUN_RESET:
+                tm_func = TMR_LUN_RESET;
+                if (ft_get_lun_for_cmd(cmd, fcp->fc_lun) < 0) {
+                        ft_dump_cmd(cmd, __func__);
+                        transport_send_check_condition_and_sense(&cmd->se_cmd,
+                                cmd->se_cmd.scsi_sense_reason, 0);
+                        ft_sess_put(cmd->sess);
+                        return;
+                }
+                break;
+        case FCP_TMF_TGT_RESET:
+                tm_func = TMR_TARGET_WARM_RESET;
+                break;
+        case FCP_TMF_CLR_TASK_SET:
+                tm_func = TMR_CLEAR_TASK_SET;
+                break;
+        case FCP_TMF_ABT_TASK_SET:
+                tm_func = TMR_ABORT_TASK_SET;
+                break;
+        case FCP_TMF_CLR_ACA:
+                tm_func = TMR_CLEAR_ACA;
+                break;
+        default:
+                /*
+                 * FCP4r01 indicates having a combination of
+                 * tm_flags set is invalid.
+                 */
+                FT_TM_DBG("invalid FCP tm_flags %x\n", fcp->fc_tm_flags);
+                ft_send_resp_code(cmd, FCP_CMND_FIELDS_INVALID);
+                return;
+        }
+
+        FT_TM_DBG("alloc tm cmd fn %d\n", tm_func);
+        tmr = core_tmr_alloc_req(&cmd->se_cmd, cmd, tm_func);
+        if (!tmr) {
+                FT_TM_DBG("alloc failed\n");
+                ft_send_resp_code(cmd, FCP_TMF_FAILED);
+                return;
+        }
+        cmd->se_cmd.se_tmr_req = tmr;
+        transport_generic_handle_tmr(&cmd->se_cmd);
+}
+
+/*
+ * Send status from completed task management request.
+ */
+int ft_queue_tm_resp(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+        struct se_tmr_req *tmr = se_cmd->se_tmr_req;
+        enum fcp_resp_rsp_codes code;
+
+        switch (tmr->response) {
+        case TMR_FUNCTION_COMPLETE:
+                code = FCP_TMF_CMPL;
+                break;
+        case TMR_LUN_DOES_NOT_EXIST:
+                code = FCP_TMF_INVALID_LUN;
+                break;
+        case TMR_FUNCTION_REJECTED:
+                code = FCP_TMF_REJECTED;
+                break;
+        case TMR_TASK_DOES_NOT_EXIST:
+        case TMR_TASK_STILL_ALLEGIANT:
+        case TMR_TASK_FAILOVER_NOT_SUPPORTED:
+        case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED:
+        case TMR_FUNCTION_AUTHORIZATION_FAILED:
+        default:
+                code = FCP_TMF_FAILED;
+                break;
+        }
+        FT_TM_DBG("tmr fn %d resp %d fcp code %d\n",
+                  tmr->function, tmr->response, code);
+        ft_send_resp_code(cmd, code);
+        return 0;
+}
+
+/*
+ * Handle incoming FCP command.
+ */
+static void ft_recv_cmd(struct ft_sess *sess, struct fc_frame *fp)
+{
+        struct ft_cmd *cmd;
+        struct fc_lport *lport = sess->tport->lport;
+
+        cmd = kzalloc(sizeof(*cmd), GFP_ATOMIC);
+        if (!cmd)
+                goto busy;
+        cmd->sess = sess;
+        cmd->seq = lport->tt.seq_assign(lport, fp);
+        if (!cmd->seq) {
+                kfree(cmd);
+                goto busy;
+        }
+        cmd->req_frame = fp;            /* hold frame during cmd */
+        ft_queue_cmd(sess, cmd);
+        return;
+
+busy:
+        FT_IO_DBG("cmd or seq allocation failure - sending BUSY\n");
+        ft_send_resp_status(lport, fp, SAM_STAT_BUSY, 0);
+        fc_frame_free(fp);
+        ft_sess_put(sess);              /* undo get from lookup */
+}
+
+
+/*
+ * Handle incoming FCP frame.
+ * Caller has verified that the frame is type FCP.
+ */
+void ft_recv_req(struct ft_sess *sess, struct fc_frame *fp)
+{
+        struct fc_frame_header *fh = fc_frame_header_get(fp);
+
+        switch (fh->fh_r_ctl) {
+        case FC_RCTL_DD_UNSOL_CMD:      /* command */
+                ft_recv_cmd(sess, fp);
+                break;
+        case FC_RCTL_DD_SOL_DATA:       /* write data */
+        case FC_RCTL_DD_UNSOL_CTL:
+        case FC_RCTL_DD_SOL_CTL:
+        case FC_RCTL_DD_DATA_DESC:      /* transfer ready */
+        case FC_RCTL_ELS4_REQ:          /* SRR, perhaps */
+        default:
+                printk(KERN_INFO "%s: unhandled frame r_ctl %x\n",
+                       __func__, fh->fh_r_ctl);
+                fc_frame_free(fp);
+                ft_sess_put(sess);      /* undo get from lookup */
+                break;
+        }
+}
+
+/*
+ * Send new command to target.
+ */
+static void ft_send_cmd(struct ft_cmd *cmd)
+{
+        struct fc_frame_header *fh = fc_frame_header_get(cmd->req_frame);
+        struct se_cmd *se_cmd;
+        struct fcp_cmnd *fcp;
+        int data_dir;
+        u32 data_len;
+        int task_attr;
+        int ret;
+
+        fcp = fc_frame_payload_get(cmd->req_frame, sizeof(*fcp));
+        if (!fcp)
+                goto err;
+
+        if (fcp->fc_flags & FCP_CFL_LEN_MASK)
+                goto err;               /* not handling longer CDBs yet */
+
+        if (fcp->fc_tm_flags) {
+                task_attr = FCP_PTA_SIMPLE;
+                data_dir = DMA_NONE;
+                data_len = 0;
+        } else {
+                switch (fcp->fc_flags & (FCP_CFL_RDDATA | FCP_CFL_WRDATA)) {
+                case 0:
+                        data_dir = DMA_NONE;
+                        break;
+                case FCP_CFL_RDDATA:
+                        data_dir = DMA_FROM_DEVICE;
+                        break;
+                case FCP_CFL_WRDATA:
+                        data_dir = DMA_TO_DEVICE;
+                        break;
+                case FCP_CFL_WRDATA | FCP_CFL_RDDATA:
+                        goto err;       /* TBD not supported by tcm_fc yet */
+                }
+
+                /* FCP_PTA_ maps 1:1 to TASK_ATTR_ */
+                task_attr = fcp->fc_pri_ta & FCP_PTA_MASK;
+                data_len = ntohl(fcp->fc_dl);
+                cmd->cdb = fcp->fc_cdb;
+        }
+
+        se_cmd = &cmd->se_cmd;
+        /*
+         * Initialize struct se_cmd descriptor from target_core_mod
+         * infrastructure
+         */
+        transport_init_se_cmd(se_cmd, &ft_configfs->tf_ops, cmd->sess->se_sess,
+                              data_len, data_dir, task_attr,
+                              &cmd->ft_sense_buffer[0]);
+        /*
+         * Check for FCP task management flags
+         */
+        if (fcp->fc_tm_flags) {
+                ft_send_tm(cmd);
+                return;
+        }
+
+        fc_seq_exch(cmd->seq)->lp->tt.seq_set_resp(cmd->seq, ft_recv_seq, cmd);
+
+        ret = ft_get_lun_for_cmd(cmd, fcp->fc_lun);
+        if (ret < 0) {
+                ft_dump_cmd(cmd, __func__);
+                transport_send_check_condition_and_sense(&cmd->se_cmd,
+                        cmd->se_cmd.scsi_sense_reason, 0);
+                return;
+        }
+
+        ret = transport_generic_allocate_tasks(se_cmd, cmd->cdb);
+
+        FT_IO_DBG("r_ctl %x alloc task ret %d\n", fh->fh_r_ctl, ret);
+        ft_dump_cmd(cmd, __func__);
+
+        if (ret == -1) {
+                transport_send_check_condition_and_sense(se_cmd,
+                                TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE, 0);
+                transport_generic_free_cmd(se_cmd, 0, 1, 0);
+                return;
+        }
+        if (ret == -2) {
+                if (se_cmd->se_cmd_flags & SCF_SCSI_RESERVATION_CONFLICT)
+                        ft_queue_status(se_cmd);
+                else
+                        transport_send_check_condition_and_sense(se_cmd,
+                                        se_cmd->scsi_sense_reason, 0);
+                transport_generic_free_cmd(se_cmd, 0, 1, 0);
+                return;
+        }
+        transport_generic_handle_cdb(se_cmd);
+        return;
+
+err:
+        ft_send_resp_code(cmd, FCP_CMND_FIELDS_INVALID);
+        return;
+}
+
+/*
+ * Handle request in the command thread.
+ */
+static void ft_exec_req(struct ft_cmd *cmd)
+{
+        FT_IO_DBG("cmd state %x\n", cmd->state);
+        switch (cmd->state) {
+        case FC_CMD_ST_NEW:
+                ft_send_cmd(cmd);
+                break;
+        default:
+                break;
+        }
+}
+
+/*
+ * Processing thread.
+ * Currently one thread per tpg.
+ */
+int ft_thread(void *arg)
+{
+        struct ft_tpg *tpg = arg;
+        struct se_queue_obj *qobj = &tpg->qobj;
+        struct ft_cmd *cmd;
+        int ret;
+
+        set_user_nice(current, -20);
+
+        while (!kthread_should_stop()) {
+                ret = wait_event_interruptible(qobj->thread_wq,
+                        atomic_read(&qobj->queue_cnt) || kthread_should_stop());
+                if (ret < 0 || kthread_should_stop())
+                        goto out;
+                cmd = ft_dequeue_cmd(qobj);
+                if (cmd)
+                        ft_exec_req(cmd);
+        }
+
+out:
+        return 0;
+}
diff --git a/drivers/target/tcm_fc/tfc_conf.c b/drivers/target/tcm_fc/tfc_conf.c
new file mode 100644
index 000000000000..fcdbbffe88cc
--- /dev/null
+++ b/drivers/target/tcm_fc/tfc_conf.c
@@ -0,0 +1,677 @@
+/*******************************************************************************
+ * Filename:  tcm_fc.c
+ *
+ * This file contains the configfs implementation for TCM_fc fabric node.
+ * Based on tcm_loop_configfs.c
+ *
+ * Copyright (c) 2010 Cisco Systems, Inc.
+ * Copyright (c) 2009,2010 Rising Tide, Inc.
+ * Copyright (c) 2009,2010 Linux-iSCSI.org
+ *
+ * Copyright (c) 2009,2010 Nicholas A. Bellinger <nab@linux-iscsi.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ ****************************************************************************/
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/version.h>
+#include <generated/utsrelease.h>
+#include <linux/utsname.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/kthread.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/configfs.h>
+#include <linux/ctype.h>
+#include <asm/unaligned.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/libfc.h>
+
+#include <target/target_core_base.h>
+#include <target/target_core_transport.h>
+#include <target/target_core_fabric_ops.h>
+#include <target/target_core_fabric_configfs.h>
+#include <target/target_core_fabric_lib.h>
+#include <target/target_core_device.h>
+#include <target/target_core_tpg.h>
+#include <target/target_core_configfs.h>
+#include <target/target_core_base.h>
+#include <target/configfs_macros.h>
+
+#include "tcm_fc.h"
+
+struct target_fabric_configfs *ft_configfs;
+
+LIST_HEAD(ft_lport_list);
+DEFINE_MUTEX(ft_lport_lock);
+
+unsigned int ft_debug_logging;
+module_param_named(debug_logging, ft_debug_logging, int, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
+
+/*
+ * Parse WWN.
+ * If strict, we require lower-case hex and colon separators to be sure
+ * the name is the same as what would be generated by ft_format_wwn()
+ * so the name and wwn are mapped one-to-one.
+ */
+static ssize_t ft_parse_wwn(const char *name, u64 *wwn, int strict)
+{
+        const char *cp;
+        char c;
+        u32 nibble;
+        u32 byte = 0;
+        u32 pos = 0;
+        u32 err;
+
+        *wwn = 0;
+        for (cp = name; cp < &name[FT_NAMELEN - 1]; cp++) {
+                c = *cp;
+                if (c == '\n' && cp[1] == '\0')
+                        continue;
+                if (strict && pos++ == 2 && byte++ < 7) {
+                        pos = 0;
+                        if (c == ':')
+                                continue;
+                        err = 1;
+                        goto fail;
+                }
+                if (c == '\0') {
+                        err = 2;
+                        if (strict && byte != 8)
+                                goto fail;
+                        return cp - name;
+                }
+                err = 3;
+                if (isdigit(c))
+                        nibble = c - '0';
+                else if (isxdigit(c) && (islower(c) || !strict))
+                        nibble = tolower(c) - 'a' + 10;
+                else
+                        goto fail;
+                *wwn = (*wwn << 4) | nibble;
+        }
+        err = 4;
+fail:
+        FT_CONF_DBG("err %u len %zu pos %u byte %u\n",
+                    err, cp - name, pos, byte);
+        return -1;
+}
+
+ssize_t ft_format_wwn(char *buf, size_t len, u64 wwn)
+{
+        u8 b[8];
+
+        put_unaligned_be64(wwn, b);
+        return snprintf(buf, len,
+                 "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x",
+                 b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]);
+}
+
+static ssize_t ft_wwn_show(void *arg, char *buf)
+{
+        u64 *wwn = arg;
+        ssize_t len;
+
+        len = ft_format_wwn(buf, PAGE_SIZE - 2, *wwn);
+        buf[len++] = '\n';
+        return len;
+}
+
+static ssize_t ft_wwn_store(void *arg, const char *buf, size_t len)
+{
+        ssize_t ret;
+        u64 wwn;
+
+        ret = ft_parse_wwn(buf, &wwn, 0);
+        if (ret > 0)
+                *(u64 *)arg = wwn;
+        return ret;
+}
+
+/*
+ * ACL auth ops.
+ */
+
+static ssize_t ft_nacl_show_port_name(
+        struct se_node_acl *se_nacl,
+        char *page)
+{
+        struct ft_node_acl *acl = container_of(se_nacl,
+                        struct ft_node_acl, se_node_acl);
+
+        return ft_wwn_show(&acl->node_auth.port_name, page);
+}
+
+static ssize_t ft_nacl_store_port_name(
+        struct se_node_acl *se_nacl,
+        const char *page,
+        size_t count)
+{
+        struct ft_node_acl *acl = container_of(se_nacl,
+                        struct ft_node_acl, se_node_acl);
+
+        return ft_wwn_store(&acl->node_auth.port_name, page, count);
+}
+
+TF_NACL_BASE_ATTR(ft, port_name, S_IRUGO | S_IWUSR);
+
+static ssize_t ft_nacl_show_node_name(
+        struct se_node_acl *se_nacl,
+        char *page)
+{
+        struct ft_node_acl *acl = container_of(se_nacl,
+                        struct ft_node_acl, se_node_acl);
+
+        return ft_wwn_show(&acl->node_auth.node_name, page);
+}
+
+static ssize_t ft_nacl_store_node_name(
+        struct se_node_acl *se_nacl,
+        const char *page,
+        size_t count)
+{
+        struct ft_node_acl *acl = container_of(se_nacl,
+                        struct ft_node_acl, se_node_acl);
+
+        return ft_wwn_store(&acl->node_auth.node_name, page, count);
+}
+
+TF_NACL_BASE_ATTR(ft, node_name, S_IRUGO | S_IWUSR);
+
+static struct configfs_attribute *ft_nacl_base_attrs[] = {
+        &ft_nacl_port_name.attr,
+        &ft_nacl_node_name.attr,
+        NULL,
+};
+
+/*
+ * ACL ops.
+ */
+
+/*
+ * Add ACL for an initiator.  The ACL is named arbitrarily.
+ * The port_name and/or node_name are attributes.
+ */
+static struct se_node_acl *ft_add_acl(
+        struct se_portal_group *se_tpg,
+        struct config_group *group,
+        const char *name)
+{
+        struct ft_node_acl *acl;
+        struct ft_tpg *tpg;
+        u64 wwpn;
+        u32 q_depth;
+
+        FT_CONF_DBG("add acl %s\n", name);
+        tpg = container_of(se_tpg, struct ft_tpg, se_tpg);
+
+        if (ft_parse_wwn(name, &wwpn, 1) < 0)
+                return ERR_PTR(-EINVAL);
+
+        acl = kzalloc(sizeof(struct ft_node_acl), GFP_KERNEL);
+        if (!(acl))
+                return ERR_PTR(-ENOMEM);
+        acl->node_auth.port_name = wwpn;
+
+        q_depth = 32;           /* XXX bogus default - get from tpg? */
+        return core_tpg_add_initiator_node_acl(&tpg->se_tpg,
+                                &acl->se_node_acl, name, q_depth);
+}
+
+static void ft_del_acl(struct se_node_acl *se_acl)
+{
+        struct se_portal_group *se_tpg = se_acl->se_tpg;
+        struct ft_tpg *tpg;
+        struct ft_node_acl *acl = container_of(se_acl,
+                                struct ft_node_acl, se_node_acl);
+
+        FT_CONF_DBG("del acl %s\n",
+                config_item_name(&se_acl->acl_group.cg_item));
+
+        tpg = container_of(se_tpg, struct ft_tpg, se_tpg);
+        FT_CONF_DBG("del acl %p se_acl %p tpg %p se_tpg %p\n",
+                    acl, se_acl, tpg, &tpg->se_tpg);
+
+        core_tpg_del_initiator_node_acl(&tpg->se_tpg, se_acl, 1);
+        kfree(acl);
+}
+
+struct ft_node_acl *ft_acl_get(struct ft_tpg *tpg, struct fc_rport_priv *rdata)
+{
+        struct ft_node_acl *found = NULL;
+        struct ft_node_acl *acl;
+        struct se_portal_group *se_tpg = &tpg->se_tpg;
+        struct se_node_acl *se_acl;
+
+        spin_lock_bh(&se_tpg->acl_node_lock);
+        list_for_each_entry(se_acl, &se_tpg->acl_node_list, acl_list) {
+                acl = container_of(se_acl, struct ft_node_acl, se_node_acl);
+                FT_CONF_DBG("acl %p port_name %llx\n",
+                        acl, (unsigned long long)acl->node_auth.port_name);
+                if (acl->node_auth.port_name == rdata->ids.port_name ||
+                    acl->node_auth.node_name == rdata->ids.node_name) {
+                        FT_CONF_DBG("acl %p port_name %llx matched\n", acl,
+                                    (unsigned long long)rdata->ids.port_name);
+                        found = acl;
+                        /* XXX need to hold onto ACL */
+                        break;
+                }
+        }
+        spin_unlock_bh(&se_tpg->acl_node_lock);
+        return found;
+}
+
+struct se_node_acl *ft_tpg_alloc_fabric_acl(struct se_portal_group *se_tpg)
+{
+        struct ft_node_acl *acl;
+
+        acl = kzalloc(sizeof(*acl), GFP_KERNEL);
+        if (!(acl)) {
+                printk(KERN_ERR "Unable to allocate struct ft_node_acl\n");
+                return NULL;
+        }
+        FT_CONF_DBG("acl %p\n", acl);
+        return &acl->se_node_acl;
+}
+
+static void ft_tpg_release_fabric_acl(struct se_portal_group *se_tpg,
+                                      struct se_node_acl *se_acl)
+{
+        struct ft_node_acl *acl = container_of(se_acl,
+                                struct ft_node_acl, se_node_acl);
+
+        FT_CONF_DBG(KERN_INFO "acl %p\n", acl);
+        kfree(acl);
+}
+
+/*
+ * local_port port_group (tpg) ops.
+ */
+static struct se_portal_group *ft_add_tpg(
+        struct se_wwn *wwn,
+        struct config_group *group,
+        const char *name)
+{
+        struct ft_lport_acl *lacl;
+        struct ft_tpg *tpg;
+        unsigned long index;
+        int ret;
+
+        FT_CONF_DBG("tcm_fc: add tpg %s\n", name);
+
+        /*
+         * Name must be "tpgt_" followed by the index.
+         */
+        if (strstr(name, "tpgt_") != name)
+                return NULL;
+        if (strict_strtoul(name + 5, 10, &index) || index > UINT_MAX)
+                return NULL;
+
+        lacl = container_of(wwn, struct ft_lport_acl, fc_lport_wwn);
+        tpg = kzalloc(sizeof(*tpg), GFP_KERNEL);
+        if (!tpg)
+                return NULL;
+        tpg->index = index;
+        tpg->lport_acl = lacl;
+        INIT_LIST_HEAD(&tpg->lun_list);
+        transport_init_queue_obj(&tpg->qobj);
+
+        ret = core_tpg_register(&ft_configfs->tf_ops, wwn, &tpg->se_tpg,
+                                (void *)tpg, TRANSPORT_TPG_TYPE_NORMAL);
+        if (ret < 0) {
+                kfree(tpg);
+                return NULL;
+        }
+
+        tpg->thread = kthread_run(ft_thread, tpg, "ft_tpg%lu", index);
+        if (IS_ERR(tpg->thread)) {
+                kfree(tpg);
+                return NULL;
+        }
+
+        mutex_lock(&ft_lport_lock);
+        list_add_tail(&tpg->list, &lacl->tpg_list);
+        mutex_unlock(&ft_lport_lock);
+
+        return &tpg->se_tpg;
+}
+
+static void ft_del_tpg(struct se_portal_group *se_tpg)
+{
+        struct ft_tpg *tpg = container_of(se_tpg, struct ft_tpg, se_tpg);
+
+        FT_CONF_DBG("del tpg %s\n",
+                    config_item_name(&tpg->se_tpg.tpg_group.cg_item));
+
+        kthread_stop(tpg->thread);
+
+        /* Wait for sessions to be freed thru RCU, for BUG_ON below */
+        synchronize_rcu();
+
+        mutex_lock(&ft_lport_lock);
+        list_del(&tpg->list);
+        if (tpg->tport) {
+                tpg->tport->tpg = NULL;
+                tpg->tport = NULL;
+        }
+        mutex_unlock(&ft_lport_lock);
+
+        core_tpg_deregister(se_tpg);
+        kfree(tpg);
+}
+
+/*
+ * Verify that an lport is configured to use the tcm_fc module, and return
+ * the target port group that should be used.
+ *
+ * The caller holds ft_lport_lock.
+ */
+struct ft_tpg *ft_lport_find_tpg(struct fc_lport *lport)
+{
+        struct ft_lport_acl *lacl;
+        struct ft_tpg *tpg;
+
+        list_for_each_entry(lacl, &ft_lport_list, list) {
+                if (lacl->wwpn == lport->wwpn) {
+                        list_for_each_entry(tpg, &lacl->tpg_list, list)
+                                return tpg; /* XXX for now return first entry */
+                        return NULL;
+                }
+        }
+        return NULL;
+}
+
+/*
+ * target config instance ops.
+ */
+
+/*
+ * Add lport to allowed config.
+ * The name is the WWPN in lower-case ASCII, colon-separated bytes.
+ */
+static struct se_wwn *ft_add_lport(
+        struct target_fabric_configfs *tf,
+        struct config_group *group,
+        const char *name)
+{
+        struct ft_lport_acl *lacl;
+        struct ft_lport_acl *old_lacl;
+        u64 wwpn;
+
+        FT_CONF_DBG("add lport %s\n", name);
+        if (ft_parse_wwn(name, &wwpn, 1) < 0)
+                return NULL;
+        lacl = kzalloc(sizeof(*lacl), GFP_KERNEL);
+        if (!lacl)
+                return NULL;
+        lacl->wwpn = wwpn;
+        INIT_LIST_HEAD(&lacl->tpg_list);
+
+        mutex_lock(&ft_lport_lock);
+        list_for_each_entry(old_lacl, &ft_lport_list, list) {
+                if (old_lacl->wwpn == wwpn) {
+                        mutex_unlock(&ft_lport_lock);
+                        kfree(lacl);
+                        return NULL;
+                }
+        }
+        list_add_tail(&lacl->list, &ft_lport_list);
+        ft_format_wwn(lacl->name, sizeof(lacl->name), wwpn);
+        mutex_unlock(&ft_lport_lock);
+
+        return &lacl->fc_lport_wwn;
+}
+
+static void ft_del_lport(struct se_wwn *wwn)
+{
+        struct ft_lport_acl *lacl = container_of(wwn,
+                                struct ft_lport_acl, fc_lport_wwn);
+
+        FT_CONF_DBG("del lport %s\n",
+                        config_item_name(&wwn->wwn_group.cg_item));
+        mutex_lock(&ft_lport_lock);
+        list_del(&lacl->list);
+        mutex_unlock(&ft_lport_lock);
+
+        kfree(lacl);
+}
+
+static ssize_t ft_wwn_show_attr_version(
+        struct target_fabric_configfs *tf,
+        char *page)
+{
+        return sprintf(page, "TCM FC " FT_VERSION " on %s/%s on "
+                ""UTS_RELEASE"\n",  utsname()->sysname, utsname()->machine);
+}
+
+TF_WWN_ATTR_RO(ft, version);
+
+static struct configfs_attribute *ft_wwn_attrs[] = {
+        &ft_wwn_version.attr,
+        NULL,
+};
+
+static char *ft_get_fabric_name(void)
+{
+        return "fc";
+}
+
+static char *ft_get_fabric_wwn(struct se_portal_group *se_tpg)
+{
+        struct ft_tpg *tpg = se_tpg->se_tpg_fabric_ptr;
+
+        return tpg->lport_acl->name;
+}
+
+static u16 ft_get_tag(struct se_portal_group *se_tpg)
+{
+        struct ft_tpg *tpg = se_tpg->se_tpg_fabric_ptr;
+
+        /*
+         * This tag is used when forming SCSI Name identifier in EVPD=1 0x83
+         * to represent the SCSI Target Port.
+         */
+        return tpg->index;
+}
+
+static u32 ft_get_default_depth(struct se_portal_group *se_tpg)
+{
+        return 1;
+}
+
+static int ft_check_false(struct se_portal_group *se_tpg)
+{
+        return 0;
+}
+
+static void ft_set_default_node_attr(struct se_node_acl *se_nacl)
+{
+}
+
+static u16 ft_get_fabric_sense_len(void)
+{
+        return 0;
+}
+
+static u16 ft_set_fabric_sense_len(struct se_cmd *se_cmd, u32 sense_len)
+{
+        return 0;
+}
+
+static u32 ft_tpg_get_inst_index(struct se_portal_group *se_tpg)
+{
+        struct ft_tpg *tpg = se_tpg->se_tpg_fabric_ptr;
+
+        return tpg->index;
+}
+
+static u64 ft_pack_lun(unsigned int index)
+{
+        WARN_ON(index >= 256);
+        /* Caller wants this byte-swapped */
+        return cpu_to_le64((index & 0xff) << 8);
+}
+
+static struct target_core_fabric_ops ft_fabric_ops = {
+        .get_fabric_name =              ft_get_fabric_name,
+        .get_fabric_proto_ident =       fc_get_fabric_proto_ident,
+        .tpg_get_wwn =                  ft_get_fabric_wwn,
+        .tpg_get_tag =                  ft_get_tag,
+        .tpg_get_default_depth =        ft_get_default_depth,
+        .tpg_get_pr_transport_id =      fc_get_pr_transport_id,
+        .tpg_get_pr_transport_id_len =  fc_get_pr_transport_id_len,
+        .tpg_parse_pr_out_transport_id = fc_parse_pr_out_transport_id,
+        .tpg_check_demo_mode =          ft_check_false,
+        .tpg_check_demo_mode_cache =    ft_check_false,
+        .tpg_check_demo_mode_write_protect = ft_check_false,
+        .tpg_check_prod_mode_write_protect = ft_check_false,
+        .tpg_alloc_fabric_acl =         ft_tpg_alloc_fabric_acl,
+        .tpg_release_fabric_acl =       ft_tpg_release_fabric_acl,
+        .tpg_get_inst_index =           ft_tpg_get_inst_index,
+        .check_stop_free =              ft_check_stop_free,
+        .release_cmd_to_pool =          ft_release_cmd,
+        .release_cmd_direct =           ft_release_cmd,
+        .shutdown_session =             ft_sess_shutdown,
+        .close_session =                ft_sess_close,
+        .stop_session =                 ft_sess_stop,
+        .fall_back_to_erl0 =            ft_sess_set_erl0,
+        .sess_logged_in =               ft_sess_logged_in,
+        .sess_get_index =               ft_sess_get_index,
+        .sess_get_initiator_sid =       NULL,
+        .write_pending =                ft_write_pending,
+        .write_pending_status =         ft_write_pending_status,
+        .set_default_node_attributes =  ft_set_default_node_attr,
+        .get_task_tag =                 ft_get_task_tag,
+        .get_cmd_state =                ft_get_cmd_state,
+        .new_cmd_failure =              ft_new_cmd_failure,
+        .queue_data_in =                ft_queue_data_in,
+        .queue_status =                 ft_queue_status,
+        .queue_tm_rsp =                 ft_queue_tm_resp,
+        .get_fabric_sense_len =         ft_get_fabric_sense_len,
+        .set_fabric_sense_len =         ft_set_fabric_sense_len,
+        .is_state_remove =              ft_is_state_remove,
+        .pack_lun =                     ft_pack_lun,
+        /*
+         * Setup function pointers for generic logic in
+         * target_core_fabric_configfs.c
+         */
+        .fabric_make_wwn =              &ft_add_lport,
+        .fabric_drop_wwn =              &ft_del_lport,
+        .fabric_make_tpg =              &ft_add_tpg,
+        .fabric_drop_tpg =              &ft_del_tpg,
+        .fabric_post_link =             NULL,
+        .fabric_pre_unlink =            NULL,
+        .fabric_make_np =               NULL,
+        .fabric_drop_np =               NULL,
+        .fabric_make_nodeacl =          &ft_add_acl,
+        .fabric_drop_nodeacl =          &ft_del_acl,
+};
+
+int ft_register_configfs(void)
+{
+        struct target_fabric_configfs *fabric;
+        int ret;
+
+        /*
+         * Register the top level struct config_item_type with TCM core
+         */
+        fabric = target_fabric_configfs_init(THIS_MODULE, "fc");
+        if (!fabric) {
+                printk(KERN_INFO "%s: target_fabric_configfs_init() failed!\n",
+                       __func__);
+                return -1;
+        }
+        fabric->tf_ops = ft_fabric_ops;
+
+        /* Allowing support for task_sg_chaining */
+        fabric->tf_ops.task_sg_chaining = 1;
+
+        /*
+         * Setup default attribute lists for various fabric->tf_cit_tmpl
+         */
+        TF_CIT_TMPL(fabric)->tfc_wwn_cit.ct_attrs = ft_wwn_attrs;
+        TF_CIT_TMPL(fabric)->tfc_tpg_base_cit.ct_attrs = NULL;
+        TF_CIT_TMPL(fabric)->tfc_tpg_attrib_cit.ct_attrs = NULL;
+        TF_CIT_TMPL(fabric)->tfc_tpg_param_cit.ct_attrs = NULL;
+        TF_CIT_TMPL(fabric)->tfc_tpg_np_base_cit.ct_attrs = NULL;
+        TF_CIT_TMPL(fabric)->tfc_tpg_nacl_base_cit.ct_attrs =
+                                                    ft_nacl_base_attrs;
+        TF_CIT_TMPL(fabric)->tfc_tpg_nacl_attrib_cit.ct_attrs = NULL;
+        TF_CIT_TMPL(fabric)->tfc_tpg_nacl_auth_cit.ct_attrs = NULL;
+        TF_CIT_TMPL(fabric)->tfc_tpg_nacl_param_cit.ct_attrs = NULL;
+        /*
+         * register the fabric for use within TCM
+         */
+        ret = target_fabric_configfs_register(fabric);
+        if (ret < 0) {
+                FT_CONF_DBG("target_fabric_configfs_register() for"
+                            " FC Target failed!\n");
+                printk(KERN_INFO
+                       "%s: target_fabric_configfs_register() failed!\n",
+                       __func__);
+                target_fabric_configfs_free(fabric);
+                return -1;
+        }
+
+        /*
+         * Setup our local pointer to *fabric.
+         */
+        ft_configfs = fabric;
+        return 0;
+}
+
+void ft_deregister_configfs(void)
+{
+        if (!ft_configfs)
+                return;
+        target_fabric_configfs_deregister(ft_configfs);
+        ft_configfs = NULL;
+}
+
+static struct notifier_block ft_notifier = {
+        .notifier_call = ft_lport_notify
+};
+
+static int __init ft_init(void)
+{
+        if (ft_register_configfs())
+                return -1;
+        if (fc_fc4_register_provider(FC_TYPE_FCP, &ft_prov)) {
+                ft_deregister_configfs();
+                return -1;
+        }
+        blocking_notifier_chain_register(&fc_lport_notifier_head, &ft_notifier);
+        fc_lport_iterate(ft_lport_add, NULL);
+        return 0;
+}
+
+static void __exit ft_exit(void)
+{
+        blocking_notifier_chain_unregister(&fc_lport_notifier_head,
+                                           &ft_notifier);
+        fc_fc4_deregister_provider(FC_TYPE_FCP, &ft_prov);
+        fc_lport_iterate(ft_lport_del, NULL);
+        ft_deregister_configfs();
+        synchronize_rcu();
+}
+
+#ifdef MODULE
+MODULE_DESCRIPTION("FC TCM fabric driver " FT_VERSION);
+MODULE_LICENSE("GPL");
+module_init(ft_init);
+module_exit(ft_exit);
+#endif /* MODULE */
diff --git a/drivers/target/tcm_fc/tfc_io.c b/drivers/target/tcm_fc/tfc_io.c
new file mode 100644
index 000000000000..4c3c0efbe13f
--- /dev/null
+++ b/drivers/target/tcm_fc/tfc_io.c
@@ -0,0 +1,374 @@
+/*
+ * Copyright (c) 2010 Cisco Systems, Inc.
+ *
+ * Portions based on tcm_loop_fabric_scsi.c and libfc/fc_fcp.c
+ *
+ * Copyright (c) 2007 Intel Corporation. All rights reserved.
+ * Copyright (c) 2008 Red Hat, Inc.  All rights reserved.
+ * Copyright (c) 2008 Mike Christie
+ * Copyright (c) 2009 Rising Tide, Inc.
+ * Copyright (c) 2009 Linux-iSCSI.org
+ * Copyright (c) 2009 Nicholas A. Bellinger <nab@linux-iscsi.org>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/* XXX TBD some includes may be extraneous */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/version.h>
+#include <generated/utsrelease.h>
+#include <linux/utsname.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/kthread.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/configfs.h>
+#include <linux/ctype.h>
+#include <linux/hash.h>
+#include <asm/unaligned.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/libfc.h>
+#include <scsi/fc_encode.h>
+
+#include <target/target_core_base.h>
+#include <target/target_core_transport.h>
+#include <target/target_core_fabric_ops.h>
+#include <target/target_core_device.h>
+#include <target/target_core_tpg.h>
+#include <target/target_core_configfs.h>
+#include <target/target_core_base.h>
+#include <target/configfs_macros.h>
+
+#include "tcm_fc.h"
+
+/*
+ * Deliver read data back to initiator.
+ * XXX TBD handle resource problems later.
+ */
+int ft_queue_data_in(struct se_cmd *se_cmd)
+{
+        struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
+        struct se_transport_task *task;
+        struct fc_frame *fp = NULL;
+        struct fc_exch *ep;
+        struct fc_lport *lport;
+        struct se_mem *mem;
+        size_t remaining;
+        u32 f_ctl = FC_FC_EX_CTX | FC_FC_REL_OFF;
+        u32 mem_off;
+        u32 fh_off = 0;
+        u32 frame_off = 0;
+        size_t frame_len = 0;
+        size_t mem_len;
+        size_t tlen;
+        size_t off_in_page;
+        struct page *page;
+        int use_sg;
+        int error;
+        void *page_addr;
+        void *from;
+        void *to = NULL;
+
+        ep = fc_seq_exch(cmd->seq);
+        lport = ep->lp;
+        cmd->seq = lport->tt.seq_start_next(cmd->seq);
+
+        task = T_TASK(se_cmd);
+        BUG_ON(!task);
+        remaining = se_cmd->data_length;
+
+        /*
+         * Setup to use first mem list entry if any.
+         */
+        if (task->t_tasks_se_num) {
+                mem = list_first_entry(task->t_mem_list,
+                         struct se_mem, se_list);
+                mem_len = mem->se_len;
+                mem_off = mem->se_off;
+                page = mem->se_page;
+        } else {
+                mem = NULL;
+                mem_len = remaining;
+                mem_off = 0;
+                page = NULL;
+        }
+
+        /* no scatter/gather in skb for odd word length due to fc_seq_send() */
+        use_sg = !(remaining % 4);
+
+        while (remaining) {
+                if (!mem_len) {
+                        BUG_ON(!mem);
+                        mem = list_entry(mem->se_list.next,
+                                struct se_mem, se_list);
+                        mem_len = min((size_t)mem->se_len, remaining);
+                        mem_off = mem->se_off;
+                        page = mem->se_page;
+                }
+                if (!frame_len) {
+                        /*
+                         * If lport's has capability of Large Send Offload LSO)
+                         * , then allow 'frame_len' to be as big as 'lso_max'
+                         * if indicated transfer length is >= lport->lso_max
+                         */
+                        frame_len = (lport->seq_offload) ? lport->lso_max :
+                                                          cmd->sess->max_frame;
+                        frame_len = min(frame_len, remaining);
+                        fp = fc_frame_alloc(lport, use_sg ? 0 : frame_len);
+                        if (!fp)
+                                return -ENOMEM;
+                        to = fc_frame_payload_get(fp, 0);
+                        fh_off = frame_off;
+                        frame_off += frame_len;
+                        /*
+                         * Setup the frame's max payload which is used by base
+                         * driver to indicate HW about max frame size, so that
+                         * HW can do fragmentation appropriately based on
+                         * "gso_max_size" of underline netdev.
+                         */
+                        fr_max_payload(fp) = cmd->sess->max_frame;
+                }
+                tlen = min(mem_len, frame_len);
+
+                if (use_sg) {
+                        if (!mem) {
+                                BUG_ON(!task->t_task_buf);
+                                page_addr = task->t_task_buf + mem_off;
+                                /*
+                                 * In this case, offset is 'offset_in_page' of
+                                 * (t_task_buf + mem_off) instead of 'mem_off'.
+                                 */
+                                off_in_page = offset_in_page(page_addr);
+                                page = virt_to_page(page_addr);
+                                tlen = min(tlen, PAGE_SIZE - off_in_page);
+                        } else
+                                off_in_page = mem_off;
+                        BUG_ON(!page);
+                        get_page(page);
+                        skb_fill_page_desc(fp_skb(fp),
+                                           skb_shinfo(fp_skb(fp))->nr_frags,
+                                           page, off_in_page, tlen);
+                        fr_len(fp) += tlen;
+                        fp_skb(fp)->data_len += tlen;
+                        fp_skb(fp)->truesize +=
+                                        PAGE_SIZE << compound_order(page);
+                } else if (mem) {
+                        BUG_ON(!page);
+                        from = kmap_atomic(page + (mem_off >> PAGE_SHIFT),
+                                           KM_SOFTIRQ0);
+                        page_addr = from;
+                        from += mem_off & ~PAGE_MASK;
+                        tlen = min(tlen, (size_t)(PAGE_SIZE -
+                                                (mem_off & ~PAGE_MASK)));
+                        memcpy(to, from, tlen);
+                        kunmap_atomic(page_addr, KM_SOFTIRQ0);
+                        to += tlen;
+                } else {
+                        from = task->t_task_buf + mem_off;
+                        memcpy(to, from, tlen);
+                        to += tlen;
+                }
+
+                mem_off += tlen;
+                mem_len -= tlen;
+                frame_len -= tlen;
+                remaining -= tlen;
+
+                if (frame_len &&
+                    (skb_shinfo(fp_skb(fp))->nr_frags < FC_FRAME_SG_LEN))
+                        continue;
+                if (!remaining)
+                        f_ctl |= FC_FC_END_SEQ;
+                fc_fill_fc_hdr(fp, FC_RCTL_DD_SOL_DATA, ep->did, ep->sid,
+                               FC_TYPE_FCP, f_ctl, fh_off);
+                error = lport->tt.seq_send(lport, cmd->seq, fp);
+                if (error) {
+                        /* XXX For now, initiator will retry */
+                        if (printk_ratelimit())
+                                printk(KERN_ERR "%s: Failed to send frame %p, "
+                                                "xid <0x%x>, remaining <0x%x>, "
+                                                "lso_max <0x%x>\n",
+                                                __func__, fp, ep->xid,
+                                                remaining, lport->lso_max);
+                }
+        }
+        return ft_queue_status(se_cmd);
+}
+
+/*
+ * Receive write data frame.
+ */
+void ft_recv_write_data(struct ft_cmd *cmd, struct fc_frame *fp)
+{
+        struct se_cmd *se_cmd = &cmd->se_cmd;
+        struct fc_seq *seq = cmd->seq;
+        struct fc_exch *ep;
+        struct fc_lport *lport;
+        struct se_transport_task *task;
+        struct fc_frame_header *fh;
+        struct se_mem *mem;
+        u32 mem_off;
+        u32 rel_off;
+        size_t frame_len;
+        size_t mem_len;
+        size_t tlen;
+        struct page *page;
+        void *page_addr;
+        void *from;
+        void *to;
+        u32 f_ctl;
+        void *buf;
+
+        task = T_TASK(se_cmd);
+        BUG_ON(!task);
+
+        fh = fc_frame_header_get(fp);
+        if (!(ntoh24(fh->fh_f_ctl) & FC_FC_REL_OFF))
+                goto drop;
+
+        /*
+         * Doesn't expect even single byte of payload. Payload
+         * is expected to be copied directly to user buffers
+         * due to DDP (Large Rx offload) feature, hence
+         * BUG_ON if BUF is non-NULL
+         */
+        buf = fc_frame_payload_get(fp, 1);
+        if (cmd->was_ddp_setup && buf) {
+                printk(KERN_INFO "%s: When DDP was setup, not expected to"
+                                 "receive frame with payload, Payload shall be"
+                                 "copied directly to buffer instead of coming "
+                                 "via. legacy receive queues\n", __func__);
+                BUG_ON(buf);
+        }
+
+        /*
+         * If ft_cmd indicated 'ddp_setup', in that case only the last frame
+         * should come with 'TSI bit being set'. If 'TSI bit is not set and if
+         * data frame appears here, means error condition. In both the cases
+         * release the DDP context (ddp_put) and in error case, as well
+         * initiate error recovery mechanism.
+         */
+        ep = fc_seq_exch(seq);
+        if (cmd->was_ddp_setup) {
+                BUG_ON(!ep);
+                lport = ep->lp;
+                BUG_ON(!lport);
+        }
+        if (cmd->was_ddp_setup && ep->xid != FC_XID_UNKNOWN) {
+                f_ctl = ntoh24(fh->fh_f_ctl);
+                /*
+                 * If TSI bit set in f_ctl, means last write data frame is
+                 * received successfully where payload is posted directly
+                 * to user buffer and only the last frame's header is posted
+                 * in legacy receive queue
+                 */
+                if (f_ctl & FC_FC_SEQ_INIT) { /* TSI bit set in FC frame */
+                        cmd->write_data_len = lport->tt.ddp_done(lport,
+                                                                ep->xid);
+                        goto last_frame;
+                } else {
+                        /*
+                         * Updating the write_data_len may be meaningless at
+                         * this point, but just in case if required in future
+                         * for debugging or any other purpose
+                         */
+                        printk(KERN_ERR "%s: Received frame with TSI bit not"
+                                        " being SET, dropping the frame, "
+                                        "cmd->sg <%p>, cmd->sg_cnt <0x%x>\n",
+                                        __func__, cmd->sg, cmd->sg_cnt);
+                        cmd->write_data_len = lport->tt.ddp_done(lport,
+                                                              ep->xid);
+                        lport->tt.seq_exch_abort(cmd->seq, 0);
+                        goto drop;
+                }
+        }
+
+        rel_off = ntohl(fh->fh_parm_offset);
+        frame_len = fr_len(fp);
+        if (frame_len <= sizeof(*fh))
+                goto drop;
+        frame_len -= sizeof(*fh);
+        from = fc_frame_payload_get(fp, 0);
+        if (rel_off >= se_cmd->data_length)
+                goto drop;
+        if (frame_len + rel_off > se_cmd->data_length)
+                frame_len = se_cmd->data_length - rel_off;
+
+        /*
+         * Setup to use first mem list entry if any.
+         */
+        if (task->t_tasks_se_num) {
+                mem = list_first_entry(task->t_mem_list,
+                                       struct se_mem, se_list);
+                mem_len = mem->se_len;
+                mem_off = mem->se_off;
+                page = mem->se_page;
+        } else {
+                mem = NULL;
+                page = NULL;
+                mem_off = 0;
+                mem_len = frame_len;
+        }
+
+        while (frame_len) {
+                if (!mem_len) {
+                        BUG_ON(!mem);
+                        mem = list_entry(mem->se_list.next,
+                                         struct se_mem, se_list);
+                        mem_len = mem->se_len;
+                        mem_off = mem->se_off;
+                        page = mem->se_page;
+                }
+                if (rel_off >= mem_len) {
+                        rel_off -= mem_len;
+                        mem_len = 0;
+                        continue;
+                }
+                mem_off += rel_off;
+                mem_len -= rel_off;
+                rel_off = 0;
+
+                tlen = min(mem_len, frame_len);
+
+                if (mem) {
+                        to = kmap_atomic(page + (mem_off >> PAGE_SHIFT),
+                                         KM_SOFTIRQ0);
+                        page_addr = to;
+                        to += mem_off & ~PAGE_MASK;
+                        tlen = min(tlen, (size_t)(PAGE_SIZE -
+                                                (mem_off & ~PAGE_MASK)));
+                        memcpy(to, from, tlen);
+                        kunmap_atomic(page_addr, KM_SOFTIRQ0);
+                } else {
+                        to = task->t_task_buf + mem_off;
+                        memcpy(to, from, tlen);
+                }
+                from += tlen;
+                frame_len -= tlen;
+                mem_off += tlen;
+                mem_len -= tlen;
+                cmd->write_data_len += tlen;
+        }
+last_frame:
+        if (cmd->write_data_len == se_cmd->data_length)
+                transport_generic_handle_data(se_cmd);
+drop:
+        fc_frame_free(fp);
+}
diff --git a/drivers/target/tcm_fc/tfc_sess.c b/drivers/target/tcm_fc/tfc_sess.c
new file mode 100644
index 000000000000..a3bd57f2ea32
--- /dev/null
+++ b/drivers/target/tcm_fc/tfc_sess.c
@@ -0,0 +1,541 @@
+/*
+ * Copyright (c) 2010 Cisco Systems, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/* XXX TBD some includes may be extraneous */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/version.h>
+#include <generated/utsrelease.h>
+#include <linux/utsname.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/kthread.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/configfs.h>
+#include <linux/ctype.h>
+#include <linux/hash.h>
+#include <linux/rcupdate.h>
+#include <linux/rculist.h>
+#include <linux/kref.h>
+#include <asm/unaligned.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/libfc.h>
+
+#include <target/target_core_base.h>
+#include <target/target_core_transport.h>
+#include <target/target_core_fabric_ops.h>
+#include <target/target_core_device.h>
+#include <target/target_core_tpg.h>
+#include <target/target_core_configfs.h>
+#include <target/target_core_base.h>
+#include <target/configfs_macros.h>
+
+#include <scsi/libfc.h>
+#include "tcm_fc.h"
+
+static void ft_sess_delete_all(struct ft_tport *);
+
+/*
+ * Lookup or allocate target local port.
+ * Caller holds ft_lport_lock.
+ */
+static struct ft_tport *ft_tport_create(struct fc_lport *lport)
+{
+        struct ft_tpg *tpg;
+        struct ft_tport *tport;
+        int i;
+
+        tport = rcu_dereference(lport->prov[FC_TYPE_FCP]);
+        if (tport && tport->tpg)
+                return tport;
+
+        tpg = ft_lport_find_tpg(lport);
+        if (!tpg)
+                return NULL;
+
+        if (tport) {
+                tport->tpg = tpg;
+                return tport;
+        }
+
+        tport = kzalloc(sizeof(*tport), GFP_KERNEL);
+        if (!tport)
+                return NULL;
+
+        tport->lport = lport;
+        tport->tpg = tpg;
+        tpg->tport = tport;
+        for (i = 0; i < FT_SESS_HASH_SIZE; i++)
+                INIT_HLIST_HEAD(&tport->hash[i]);
+
+        rcu_assign_pointer(lport->prov[FC_TYPE_FCP], tport);
+        return tport;
+}
+
+/*
+ * Free tport via RCU.
+ */
+static void ft_tport_rcu_free(struct rcu_head *rcu)
+{
+        struct ft_tport *tport = container_of(rcu, struct ft_tport, rcu);
+
+        kfree(tport);
+}
+
+/*
+ * Delete a target local port.
+ * Caller holds ft_lport_lock.
+ */
+static void ft_tport_delete(struct ft_tport *tport)
+{
+        struct fc_lport *lport;
+        struct ft_tpg *tpg;
+
+        ft_sess_delete_all(tport);
+        lport = tport->lport;
+        BUG_ON(tport != lport->prov[FC_TYPE_FCP]);
+        rcu_assign_pointer(lport->prov[FC_TYPE_FCP], NULL);
+
+        tpg = tport->tpg;
+        if (tpg) {
+                tpg->tport = NULL;
+                tport->tpg = NULL;
+        }
+        call_rcu(&tport->rcu, ft_tport_rcu_free);
+}
+
+/*
+ * Add local port.
+ * Called thru fc_lport_iterate().
+ */
+void ft_lport_add(struct fc_lport *lport, void *arg)
+{
+        mutex_lock(&ft_lport_lock);
+        ft_tport_create(lport);
+        mutex_unlock(&ft_lport_lock);
+}
+
+/*
+ * Delete local port.
+ * Called thru fc_lport_iterate().
+ */
+void ft_lport_del(struct fc_lport *lport, void *arg)
+{
+        struct ft_tport *tport;
+
+        mutex_lock(&ft_lport_lock);
+        tport = lport->prov[FC_TYPE_FCP];
+        if (tport)
+                ft_tport_delete(tport);
+        mutex_unlock(&ft_lport_lock);
+}
+
+/*
+ * Notification of local port change from libfc.
+ * Create or delete local port and associated tport.
+ */
+int ft_lport_notify(struct notifier_block *nb, unsigned long event, void *arg)
+{
+        struct fc_lport *lport = arg;
+
+        switch (event) {
+        case FC_LPORT_EV_ADD:
+                ft_lport_add(lport, NULL);
+                break;
+        case FC_LPORT_EV_DEL:
+                ft_lport_del(lport, NULL);
+                break;
+        }
+        return NOTIFY_DONE;
+}
+
+/*
+ * Hash function for FC_IDs.
+ */
+static u32 ft_sess_hash(u32 port_id)
+{
+        return hash_32(port_id, FT_SESS_HASH_BITS);
+}
+
+/*
+ * Find session in local port.
+ * Sessions and hash lists are RCU-protected.
+ * A reference is taken which must be eventually freed.
+ */
+static struct ft_sess *ft_sess_get(struct fc_lport *lport, u32 port_id)
+{
+        struct ft_tport *tport;
+        struct hlist_head *head;
+        struct hlist_node *pos;
+        struct ft_sess *sess;
+
+        rcu_read_lock();
+        tport = rcu_dereference(lport->prov[FC_TYPE_FCP]);
+        if (!tport)
+                goto out;
+
+        head = &tport->hash[ft_sess_hash(port_id)];
+        hlist_for_each_entry_rcu(sess, pos, head, hash) {
+                if (sess->port_id == port_id) {
+                        kref_get(&sess->kref);
+                        rcu_read_unlock();
+                        FT_SESS_DBG("port_id %x found %p\n", port_id, sess);
+                        return sess;
+                }
+        }
+out:
+        rcu_read_unlock();
+        FT_SESS_DBG("port_id %x not found\n", port_id);
+        return NULL;
+}
+
+/*
+ * Allocate session and enter it in the hash for the local port.
+ * Caller holds ft_lport_lock.
+ */
+static struct ft_sess *ft_sess_create(struct ft_tport *tport, u32 port_id,
+                                      struct ft_node_acl *acl)
+{
+        struct ft_sess *sess;
+        struct hlist_head *head;
+        struct hlist_node *pos;
+
+        head = &tport->hash[ft_sess_hash(port_id)];
+        hlist_for_each_entry_rcu(sess, pos, head, hash)
+                if (sess->port_id == port_id)
+                        return sess;
+
+        sess = kzalloc(sizeof(*sess), GFP_KERNEL);
+        if (!sess)
+                return NULL;
+
+        sess->se_sess = transport_init_session();
+        if (!sess->se_sess) {
+                kfree(sess);
+                return NULL;
+        }
+        sess->se_sess->se_node_acl = &acl->se_node_acl;
+        sess->tport = tport;
+        sess->port_id = port_id;
+        kref_init(&sess->kref); /* ref for table entry */
+        hlist_add_head_rcu(&sess->hash, head);
+        tport->sess_count++;
+
+        FT_SESS_DBG("port_id %x sess %p\n", port_id, sess);
+
+        transport_register_session(&tport->tpg->se_tpg, &acl->se_node_acl,
+                                   sess->se_sess, sess);
+        return sess;
+}
+
+/*
+ * Unhash the session.
+ * Caller holds ft_lport_lock.
+ */
+static void ft_sess_unhash(struct ft_sess *sess)
+{
+        struct ft_tport *tport = sess->tport;
+
+        hlist_del_rcu(&sess->hash);
+        BUG_ON(!tport->sess_count);
+        tport->sess_count--;
+        sess->port_id = -1;
+        sess->params = 0;
+}
+
+/*
+ * Delete session from hash.
+ * Caller holds ft_lport_lock.
+ */
+static struct ft_sess *ft_sess_delete(struct ft_tport *tport, u32 port_id)
+{
+        struct hlist_head *head;
+        struct hlist_node *pos;
+        struct ft_sess *sess;
+
+        head = &tport->hash[ft_sess_hash(port_id)];
+        hlist_for_each_entry_rcu(sess, pos, head, hash) {
+                if (sess->port_id == port_id) {
+                        ft_sess_unhash(sess);
+                        return sess;
+                }
+        }
+        return NULL;
+}
+
+/*
+ * Delete all sessions from tport.
+ * Caller holds ft_lport_lock.
+ */
+static void ft_sess_delete_all(struct ft_tport *tport)
+{
+        struct hlist_head *head;
+        struct hlist_node *pos;
+        struct ft_sess *sess;
+
+        for (head = tport->hash;
+             head < &tport->hash[FT_SESS_HASH_SIZE]; head++) {
+                hlist_for_each_entry_rcu(sess, pos, head, hash) {
+                        ft_sess_unhash(sess);
+                        transport_deregister_session_configfs(sess->se_sess);
+                        ft_sess_put(sess);      /* release from table */
+                }
+        }
+}
+
+/*
+ * TCM ops for sessions.
+ */
+
+/*
+ * Determine whether session is allowed to be shutdown in the current context.
+ * Returns non-zero if the session should be shutdown.
+ */
+int ft_sess_shutdown(struct se_session *se_sess)
+{
+        struct ft_sess *sess = se_sess->fabric_sess_ptr;
+
+        FT_SESS_DBG("port_id %x\n", sess->port_id);
+        return 1;
+}
+
+/*
+ * Remove session and send PRLO.
+ * This is called when the ACL is being deleted or queue depth is changing.
+ */
+void ft_sess_close(struct se_session *se_sess)
+{
+        struct ft_sess *sess = se_sess->fabric_sess_ptr;
+        struct fc_lport *lport;
+        u32 port_id;
+
+        mutex_lock(&ft_lport_lock);
+        lport = sess->tport->lport;
+        port_id = sess->port_id;
+        if (port_id == -1) {
+                mutex_lock(&ft_lport_lock);
+                return;
+        }
+        FT_SESS_DBG("port_id %x\n", port_id);
+        ft_sess_unhash(sess);
+        mutex_unlock(&ft_lport_lock);
+        transport_deregister_session_configfs(se_sess);
+        ft_sess_put(sess);
+        /* XXX Send LOGO or PRLO */
+        synchronize_rcu();              /* let transport deregister happen */
+}
+
+void ft_sess_stop(struct se_session *se_sess, int sess_sleep, int conn_sleep)
+{
+        struct ft_sess *sess = se_sess->fabric_sess_ptr;
+
+        FT_SESS_DBG("port_id %x\n", sess->port_id);
+}
+
+int ft_sess_logged_in(struct se_session *se_sess)
+{
+        struct ft_sess *sess = se_sess->fabric_sess_ptr;
+
+        return sess->port_id != -1;
+}
+
+u32 ft_sess_get_index(struct se_session *se_sess)
+{
+        struct ft_sess *sess = se_sess->fabric_sess_ptr;
+
+        return sess->port_id;   /* XXX TBD probably not what is needed */
+}
+
+u32 ft_sess_get_port_name(struct se_session *se_sess,
+                          unsigned char *buf, u32 len)
+{
+        struct ft_sess *sess = se_sess->fabric_sess_ptr;
+
+        return ft_format_wwn(buf, len, sess->port_name);
+}
+
+void ft_sess_set_erl0(struct se_session *se_sess)
+{
+        /* XXX TBD called when out of memory */
+}
+
+/*
+ * libfc ops involving sessions.
+ */
+
+static int ft_prli_locked(struct fc_rport_priv *rdata, u32 spp_len,
+                          const struct fc_els_spp *rspp, struct fc_els_spp *spp)
+{
+        struct ft_tport *tport;
+        struct ft_sess *sess;
+        struct ft_node_acl *acl;
+        u32 fcp_parm;
+
+        tport = ft_tport_create(rdata->local_port);
+        if (!tport)
+                return 0;       /* not a target for this local port */
+
+        acl = ft_acl_get(tport->tpg, rdata);
+        if (!acl)
+                return 0;
+
+        if (!rspp)
+                goto fill;
+
+        if (rspp->spp_flags & (FC_SPP_OPA_VAL | FC_SPP_RPA_VAL))
+                return FC_SPP_RESP_NO_PA;
+
+        /*
+         * If both target and initiator bits are off, the SPP is invalid.
+         */
+        fcp_parm = ntohl(rspp->spp_params);
+        if (!(fcp_parm & (FCP_SPPF_INIT_FCN | FCP_SPPF_TARG_FCN)))
+                return FC_SPP_RESP_INVL;
+
+        /*
+         * Create session (image pair) only if requested by
+         * EST_IMG_PAIR flag and if the requestor is an initiator.
+         */
+        if (rspp->spp_flags & FC_SPP_EST_IMG_PAIR) {
+                spp->spp_flags |= FC_SPP_EST_IMG_PAIR;
+                if (!(fcp_parm & FCP_SPPF_INIT_FCN))
+                        return FC_SPP_RESP_CONF;
+                sess = ft_sess_create(tport, rdata->ids.port_id, acl);
+                if (!sess)
+                        return FC_SPP_RESP_RES;
+                if (!sess->params)
+                        rdata->prli_count++;
+                sess->params = fcp_parm;
+                sess->port_name = rdata->ids.port_name;
+                sess->max_frame = rdata->maxframe_size;
+
+                /* XXX TBD - clearing actions.  unit attn, see 4.10 */
+        }
+
+        /*
+         * OR in our service parameters with other provider (initiator), if any.
+         * TBD XXX - indicate RETRY capability?
+         */
+fill:
+        fcp_parm = ntohl(spp->spp_params);
+        spp->spp_params = htonl(fcp_parm | FCP_SPPF_TARG_FCN);
+        return FC_SPP_RESP_ACK;
+}
+
+/**
+ * tcm_fcp_prli() - Handle incoming or outgoing PRLI for the FCP target
+ * @rdata: remote port private
+ * @spp_len: service parameter page length
+ * @rspp: received service parameter page (NULL for outgoing PRLI)
+ * @spp: response service parameter page
+ *
+ * Returns spp response code.
+ */
+static int ft_prli(struct fc_rport_priv *rdata, u32 spp_len,
+                   const struct fc_els_spp *rspp, struct fc_els_spp *spp)
+{
+        int ret;
+
+        mutex_lock(&ft_lport_lock);
+        ret = ft_prli_locked(rdata, spp_len, rspp, spp);
+        mutex_unlock(&ft_lport_lock);
+        FT_SESS_DBG("port_id %x flags %x ret %x\n",
+               rdata->ids.port_id, rspp ? rspp->spp_flags : 0, ret);
+        return ret;
+}
+
+static void ft_sess_rcu_free(struct rcu_head *rcu)
+{
+        struct ft_sess *sess = container_of(rcu, struct ft_sess, rcu);
+
+        transport_deregister_session(sess->se_sess);
+        kfree(sess);
+}
+
+static void ft_sess_free(struct kref *kref)
+{
+        struct ft_sess *sess = container_of(kref, struct ft_sess, kref);
+
+        call_rcu(&sess->rcu, ft_sess_rcu_free);
+}
+
+void ft_sess_put(struct ft_sess *sess)
+{
+        int sess_held = atomic_read(&sess->kref.refcount);
+
+        BUG_ON(!sess_held);
+        kref_put(&sess->kref, ft_sess_free);
+}
+
+static void ft_prlo(struct fc_rport_priv *rdata)
+{
+        struct ft_sess *sess;
+        struct ft_tport *tport;
+
+        mutex_lock(&ft_lport_lock);
+        tport = rcu_dereference(rdata->local_port->prov[FC_TYPE_FCP]);
+        if (!tport) {
+                mutex_unlock(&ft_lport_lock);
+                return;
+        }
+        sess = ft_sess_delete(tport, rdata->ids.port_id);
+        if (!sess) {
+                mutex_unlock(&ft_lport_lock);
+                return;
+        }
+        mutex_unlock(&ft_lport_lock);
+        transport_deregister_session_configfs(sess->se_sess);
+        ft_sess_put(sess);              /* release from table */
+        rdata->prli_count--;
+        /* XXX TBD - clearing actions.  unit attn, see 4.10 */
+}
+
+/*
+ * Handle incoming FCP request.
+ * Caller has verified that the frame is type FCP.
+ */
+static void ft_recv(struct fc_lport *lport, struct fc_frame *fp)
+{
+        struct ft_sess *sess;
+        u32 sid = fc_frame_sid(fp);
+
+        FT_SESS_DBG("sid %x\n", sid);
+
+        sess = ft_sess_get(lport, sid);
+        if (!sess) {
+                FT_SESS_DBG("sid %x sess lookup failed\n", sid);
+                /* TBD XXX - if FCP_CMND, send PRLO */
+                fc_frame_free(fp);
+                return;
+        }
+        ft_recv_req(sess, fp);  /* must do ft_sess_put() */
+}
+
+/*
+ * Provider ops for libfc.
+ */
+struct fc4_prov ft_prov = {
+        .prli = ft_prli,
+        .prlo = ft_prlo,
+        .recv = ft_recv,
+        .module = THIS_MODULE,
+};
diff --git a/drivers/usb/storage/isd200.c b/drivers/usb/storage/isd200.c
index 09e52ba47ddf..ffc4193e9505 100644
--- a/drivers/usb/storage/isd200.c
+++ b/drivers/usb/storage/isd200.c
@@ -499,7 +499,6 @@ static int isd200_action( struct us_data *us, int action,
         memset(&ata, 0, sizeof(ata));
         srb->cmnd = info->cmnd;
         srb->device = &srb_dev;
-        ++srb->serial_number;
 
         ata.generic.SignatureByte0 = info->ConfigData.ATAMajorCommand;
         ata.generic.SignatureByte1 = info->ConfigData.ATAMinorCommand;